MaskedRenderRegion Class Reference

The Masked Render region is used when rendering to regions that can not do all the fabby things that GRender Regions are capable of (eg Transparancy). They are used as part of the 3 phase rendering process, in the middle phase. In this phase all the objects that are deemed to be too complicated to be rendered by the host render region are actually rendered into a GRenderRegion. Each of the individual objects that are complex are also rendered into this Mono Masked Render Region. At the end of the process this Masked Render region is used to identify the minimum area of the render region that needs to be blitted into the host render region. More...

#include <maskedrr.h>

Inheritance diagram for MaskedRenderRegion:

List of all members.

Public Member Functions
	MaskedRenderRegion (DocRect, Matrix, FIXED16, double)
	Constructor. Sends everything on to the base class. INT32 dpi changed to FIXED16 dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using.
	~MaskedRenderRegion ()
	Default destructor.
BOOL	StartRender ()
	Starts the render region up. This version just calls the base class and allocates a couple of attributes used during the rendering.
void	SetHostCaps (RRCaps *pCaps)
	Tells the mask region what attributes are considered complex.
virtual void	DrawPathToOutputDevice (Path *PathToRender, PathShape shapePath=PATHSHAPE_PATH)
	Renders the path into the mask. It makes sure that all the attributes are set up correctly first though.
virtual void	DrawRect (DocRect *RectToRender)
	This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function.
virtual void	DrawLine (const DocCoord &StartPoint, const DocCoord &EndPoint)
	This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function.
virtual void	DrawPixel (const DocCoord &Point)
	This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function.
virtual void	DrawBitmap (const DocCoord &Point, KernelBitmap *pBitmap)
	This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function.
virtual void	DrawBitmap (const DocCoord &Point, UINT32 BitmapID, UINT32 ToolID=NULL)
	This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function.
virtual BOOL	DrawTransformedBitmap (NodeBitmap *pNodeBitmap)
virtual void	DrawDragRect (DocRect *RectToRender)
	None - Does nothing.
virtual void	DrawBlob (DocCoord p, BlobType type)
	None - Does nothing.
virtual void	DrawCross (const DocCoord &Point, const UINT32 Size)
	None - Does nothing.
virtual void	DrawBitmapBlob (const DocCoord &Point, KernelBitmap *BlobShape)
	None - Does nothing.
virtual void	DrawBitmapBlob (const DocCoord &Point, ResourceID resID)
	None - Does nothing.
BOOL	SpreadMask ()
	Spreads the mask out by a pixel. This allows us to make the area that is blitted slightly bigger to cover up any differences between the device resolution and the bitmap resolution. This function will grow the mask above, below, to the left and right by a single pixel. If this is not enough, call this function more than once.
INT32	FindCoverage (BOOL AnyCoverageReturns100=FALSE)
	Finds out how much of the mask has been set.
INT32	FindMaskDpi ()
	This function is used to find out the DPI that the region was created at. This is important as the device it is displaying to may have a different dpi and the difference has to be compensated for. Returns a INT32 form of the dpi As most printing and masking related items only require non-fractional dpis then this should not be a problem. So return a rounded up form of the stored double form.
void	GetFirstMaskRegion (MaskRegion *pMaskInfo)
	This function is used to find out the DPI that the region was created at. This is important as the device it is displaying to may have a different dpi and the difference has to be compensated for. Returns the new double form of the dpiThis function finds the first scan line section in the mask that indicates pixels need to be set. When it finds the next section it fills in the info about it in pMaskInfo and returns. If there are no regions to be found in the mask then the Length member of pMaskInfo will be set to zero. This is your clue that there are no scan line sections to process.
void	GetNextMaskRegion (MaskRegion *pMaskInfo)
	This function finds the next scan line section in the mask that indicates pixels need to be set. It uses the info in the pMaskInfo param to work out where to start looking from. When it finds the next section, which could be on the same scan line as the present one, it fills in the info about it in pMaskInfo and returns. If there are no more regions to be found in the mask then the Length member of pMaskInfo will be set to zero. This is your clue that there are no more scan line sections to process.
virtual void	SetOffscreen (OffscreenAttrValue *)
	Create a new bitmap into which, the subtree rooted at this attributes parent, will be rendered. Then call base version to push the current OffscreenAttr onto the context stack.
virtual void	RestoreOffscreen (OffscreenAttrValue *)
Protected Member Functions
void	ScanMaskFrom (MaskRegion *pMaskInfo)
	Searchs the mask for a section that means we will have to blit something. The starting position of the section and the length of the section are put into pMaskInfo and returned. pMaskInfo->Length will be set to zero if there are no more sections in the mask.
void	SetNextShapeColour (DocColour &RequiredCol)
	Sets all the attributes up so that we can render into our mask. It will boil everything down to a flat fill and stroke ready to be rendered into the mask. The colour passed in will probably be Black or White, but I left it open in case I thought of some other use for this.
Protected Attributes
DocColour	Black
DocColour	White
RRCaps	HostCaps
FlatTranspFillAttribute *	pFillAttr
StrokeTranspAttribute *	pStrokeAttr
Static Protected Attributes
static INT32	BitCountTable [256]

---

Detailed Description

The Masked Render region is used when rendering to regions that can not do all the fabby things that GRender Regions are capable of (eg Transparancy). They are used as part of the 3 phase rendering process, in the middle phase. In this phase all the objects that are deemed to be too complicated to be rendered by the host render region are actually rendered into a GRenderRegion. Each of the individual objects that are complex are also rendered into this Mono Masked Render Region. At the end of the process this Masked Render region is used to identify the minimum area of the render region that needs to be blitted into the host render region.

Author:

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

Date:

11/4/95

Definition at line 155 of file maskedrr.h.

---

Constructor & Destructor Documentation

MaskedRenderRegion::MaskedRenderRegion (  DocRect  ClipRegion, Matrix  ConvertMatrix, FIXED16  ViewScale, double  dpi )

Constructor. Sends everything on to the base class. INT32 dpi changed to FIXED16 dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/4/95 Parameters: ClipRect  - the Clipping rectangle [INPUTS] ConvertMatrix - the Matrix to render through ViewScale - The Scale Factor dpi - Dots per inch Definition at line 197 of file maskedrr.cpp. : GRenderBitmap(ClipRegion, ConvertMatrix, ViewScale, 1, dpi) { // Some attrs we use. NULL by default pFillAttr = NULL; pStrokeAttr = NULL; Black = DocColour(0,0,0); White = DocColour(255,255,255); }

MaskedRenderRegion::~MaskedRenderRegion (   )

Default destructor. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/4/95 Definition at line 219 of file maskedrr.cpp. { // Kill the fill attr if (pFillAttr!=NULL) { delete pFillAttr; pFillAttr = NULL; } // kill the stroke attr if (pStrokeAttr!=NULL) { delete pStrokeAttr; pStrokeAttr = NULL; } }

---

Member Function Documentation

void MaskedRenderRegion::DrawBitmap (  const DocCoord &  Point, UINT32  BitmapID, UINT32  ToolID = NULL )  [virtual]

This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: Point  - the position to draw the bitmap at [INPUTS] BitmapID - The ID of the bitmap to render ToolID - the ID of the tool that the bitmap belongs to Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 506 of file maskedrr.cpp. { // Save the context SaveContext(); // Does this shape make use of complex things if (TestForComplexShape(&HostCaps)) SetNextShapeColour(Black); else SetNextShapeColour(White); // Draw the path GRenderBitmap::DrawBitmap(Point, BitmapID, ToolID); // restore the context RestoreContext(); }

void MaskedRenderRegion::DrawBitmap (  const DocCoord &  Point, KernelBitmap *  pBitmap )  [virtual]

This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: Point  - The position to draw the bitmap at [INPUTS] pBitmap - the bitmap that needs drawing Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 471 of file maskedrr.cpp. { // Save the context SaveContext(); // Does this shape make use of complex things if (TestForComplexShape(&HostCaps)) SetNextShapeColour(Black); else SetNextShapeColour(White); // Draw the path GRenderBitmap::DrawBitmap(Point, pBitmap); // restore the context RestoreContext(); }

void MaskedRenderRegion::DrawBitmapBlob (  const DocCoord &  Point, ResourceID  resID )  [virtual]

None - Does nothing. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: Point  - A coord [INPUTS] BitmapID - the ID of a bitmap ToolID - the Id of the tool the bitmap resource is in Reimplemented from GRenderRegion. Definition at line 682 of file maskedrr.cpp. { }

void MaskedRenderRegion::DrawBitmapBlob (  const DocCoord &  Point, KernelBitmap *  BlobShape )  [virtual]

None - Does nothing. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: Point  - A Coord [INPUTS] BlobShape - the bitmap to use Reimplemented from GRenderRegion. Definition at line 663 of file maskedrr.cpp. { }

void MaskedRenderRegion::DrawBlob (  DocCoord  p, BlobType  type )  [virtual]

None - Does nothing. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: p  - A coord [INPUTS] type - The type of blob Reimplemented from GRenderRegion. Definition at line 628 of file maskedrr.cpp. { }

void MaskedRenderRegion::DrawCross (  const DocCoord &  Point, const UINT32  Size )  [virtual]

None - Does nothing. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: Point  - a Coord [INPUTS] Size - the size of the cross Reimplemented from GRenderRegion. Definition at line 645 of file maskedrr.cpp. { }

void MaskedRenderRegion::DrawDragRect (  DocRect *  RectToRender  )  [virtual]

None - Does nothing. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: RectToRender  - The Rectangle [INPUTS] Reimplemented from GRenderRegion. Definition at line 611 of file maskedrr.cpp. { }

void MaskedRenderRegion::DrawLine (  const DocCoord &  StartPoint, const DocCoord &  EndPoint )  [virtual]

This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: StartPoint,EndPoint  - the coords to draw a line between [INPUTS] Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 406 of file maskedrr.cpp. { // Save the context SaveContext(); // Does this shape make use of complex things if (TestForComplexShape(&HostCaps)) SetNextShapeColour(Black); else SetNextShapeColour(White); // Draw the path GRenderBitmap::DrawLine(StartPoint, EndPoint); // restore the context RestoreContext(); }

void MaskedRenderRegion::DrawPathToOutputDevice (  Path *  pPath, PathShape  shapePath = PATHSHAPE_PATH )  [virtual]

Renders the path into the mask. It makes sure that all the attributes are set up correctly first though. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/4/95 Parameters: pPath  - The path that needs rendering [INPUTS] Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 313 of file maskedrr.cpp. { // Save the context SaveContext(); BOOL RenderFill = FALSE; // Get the current fill attr FillGeometryAttribute* pFillAttr = (FillGeometryAttribute*) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if (pFillAttr->GetBitmap() != NULL && pFillAttr->GetBitmap()->GetBPP() <= 8) { INT32 TranspIndex; // If it's a masked bitmap fill, then we'll need to actually render it // (but we'll force all the non-masked pixels to be rendered black) if (pFillAttr->GetBitmap()->GetTransparencyIndex(&TranspIndex)) RenderFill = TRUE; } if (RenderFill) { BOOL OldVMState = RenderFlags.VeryMono; RenderFlags.VeryMono = TRUE; // Forces non-masked pixels to be plotted black // Draw the path, with the bitmap fill GRenderBitmap::DrawPathToOutputDevice(pPath); RenderFlags.VeryMono = OldVMState; } else { // Does this shape make use of complex things if (TestForComplexShape(&HostCaps)) SetNextShapeColour(Black); else SetNextShapeColour(White); // Draw the path GRenderBitmap::DrawPathToOutputDevice(pPath); } // restore the context RestoreContext(); }

void MaskedRenderRegion::DrawPixel (  const DocCoord &  Point  )  [virtual]

This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: Point  - the coord to draw the pixel in [INPUTS] Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 438 of file maskedrr.cpp. { // Save the context SaveContext(); // Does this shape make use of complex things if (TestForComplexShape(&HostCaps)) SetNextShapeColour(Black); else SetNextShapeColour(White); // Draw the path GRenderBitmap::DrawPixel(Point); // restore the context RestoreContext(); }

void MaskedRenderRegion::DrawRect (  DocRect *  pRectToRender  )  [virtual]

This function will examine the attributes etc to see if this represents a simple or compex shape. It will set up the attributes according to the result of this and then call the base class version of the function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: pRectToRender  - The Rectangle that we need to render [INPUTS] Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 373 of file maskedrr.cpp. { // Save the context SaveContext(); // Does this shape make use of complex things if (TestForComplexShape(&HostCaps)) SetNextShapeColour(Black); else SetNextShapeColour(White); // Draw the path GRenderBitmap::DrawRect(pRectToRender); // restore the context RestoreContext(); }

BOOL MaskedRenderRegion::DrawTransformedBitmap (  NodeBitmap *  pNodeBitmap  )  [virtual]

Reimplemented from RenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 524 of file maskedrr.cpp. { // Save the context SaveContext(); // Work out if we can do this bitmap directly BOOL CanDoBitmap = FALSE; // Does this shape make use of complex things if (!(TestForComplexShape(&HostCaps) || pNodeBitmap->NeedsTransparency())) { // See what kind of bitmaps this render region can do if (HostCaps.ArbitraryBitmaps) { // We can do anything... CanDoBitmap = TRUE; } else { if (HostCaps.SimpleBitmaps) { // Check that the bitmap area is rectangular, and is perpendicular to // the x and y axes. if (pNodeBitmap->HasSimpleOrientation(this)) { // Yes - simple scaling - the render region can do this. CanDoBitmap = TRUE; } } } } // Here we set up reasonable attributes - we want to fill the bitmap // path but not stroke it. NB. This is very important - do not remove // otherwise the mask will be wrong! DocColour colorBlack( COLOUR_BLACK ); SetFillColour( colorBlack ); DocColour colorNone( COLOUR_NONE ); SetLineColour( colorNone ); if (CanDoBitmap) { SetNextShapeColour(White); // Draw the path (that represents the bitmap object) GRenderBitmap::DrawPathToOutputDevice(&pNodeBitmap->InkPath); } else { if (pNodeBitmap->NeedsTransparency()) { // It's a masked bitmap, so we'll need to actually render the non-masked // pixels as black BOOL OldVMState = RenderFlags.VeryMono; RenderFlags.VeryMono = TRUE; // Forces non-masked pixels to be plotted black // Call base class to plot the bitmap RenderRegion::DrawTransformedBitmap(pNodeBitmap); RenderFlags.VeryMono = OldVMState; } else { SetNextShapeColour(Black); // Draw the path (that represents the bitmap object) GRenderBitmap::DrawPathToOutputDevice(&pNodeBitmap->InkPath); } } // restore the context RestoreContext(); return TRUE; }

INT32 MaskedRenderRegion::FindCoverage (  BOOL  AnyCoverageReturns100 = FALSE  )

Finds out how much of the mask has been set. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/4/95 Parameters: AnyConverageReturns100  - In most (if not all) calls to this function, [INPUTS] the caller is only interested in whether coverage is equal to zero or not (i.e. "Do I have to bother rendering anything?"). If you set this flag to TRUE, this function will return 100% immediately if it finds a single pixel set in the mask, or 0% only if there are no pixels set in the mask. This is thus a much faster test of "do we need to render" because it usually doesn't have to scan far before it finds a pixel to plot. (Added by Jason, 1/7/96) Returns: 0 - 100. This represents the percentage of the masked bitmap that has pixels set in it. A value of 0 means that there are no pixels set in the mask. You can take this value to mean 'do not bother trying to display the bitmap cos none of it is visible'. A value of 100 means that every pixel in the mask is set so no clever masked plotting of the bitmap is required. (or, if the AnyConverageReturns100 flag was set, a value of 100 just means that there was at least one pixel requiring plotting) Definition at line 926 of file maskedrr.cpp. { INT32 TotalPixels = 0; INT32 TotalClearPixels = 0; if (pBits!=NULL && pBitmapInfo!=NULL) { // Get the scan line size in bytes const INT32 ScanLineByteSize = (pBitmapInfo->bmiHeader.biWidth+7)/8; // Round it up to the nearest word boundary. Note, this is still a count of bytes const INT32 ScanLineWordSize = ((ScanLineByteSize+3)/4)*4; // Work out how many padding pixels (bits) are on the end of the scanline const INT32 EndPixels = 8- ((ScanLineByteSize*8) - pBitmapInfo->bmiHeader.biWidth); // The last byte of each scanline may not use all its pixels, so we build a mask, // which is used to discount padding pixels from consideration BYTE Mask = 0x0; { BYTE Bit = 0x80; for (INT32 i=0; i<EndPixels; i++) Mask |= Bit>>i; } // Start looping through all the scan lines in the mask LPBYTE CurrentByte = NULL; for (INT32 i=0; i<pBitmapInfo->bmiHeader.biHeight; i++) { // point CurrentByte at the start of the next scan line CurrentByte = pBits + (i*ScanLineWordSize); // Count this scan line of pixels TotalPixels += pBitmapInfo->bmiHeader.biWidth; // Go along the scan line, counting pixels for (INT32 j=0; j<ScanLineByteSize-1; j++) { // look up the current byte TotalClearPixels += BitCountTable[*CurrentByte]; // Move to the next byte CurrentByte ++; } BYTE EndByte = *CurrentByte & Mask; TotalClearPixels += BitCountTable[EndByte]; // If we just want to know if the entire mask is clear, then check if we found // any non-masked pixels at all in this scanline - if so, return immediately. if (AnyCoverageReturns100 && TotalClearPixels != TotalPixels) return(100); } } // The mask was empty or missing if ((TotalClearPixels==TotalPixels) || (TotalPixels==0)) { TRACEUSER( "Rik", _T("Coverage = 0\n")); return 0; } // Every pixel was set if (TotalClearPixels==0) { TRACEUSER( "Rik", _T("Coverage = 100\n")); return 100; } // Work out the result INT32 Result = 100 - ((TotalClearPixels*100) / TotalPixels); // Rounding errors could give this misleading result if (Result<=0) Result = 1; // and this one, so change them if (Result>=100) Result = 99; // Tell them what percentage of pixels were set TRACEUSER( "Rik", _T("Coverage = %ld\n"), Result); return Result; }

INT32 MaskedRenderRegion::FindMaskDpi (   )

This function is used to find out the DPI that the region was created at. This is important as the device it is displaying to may have a different dpi and the difference has to be compensated for. Returns a INT32 form of the dpi As most printing and masking related items only require non-fractional dpis then this should not be a problem. So return a rounded up form of the stored double form. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/95 Returns: The Dpi of the mask in this region Definition at line 1031 of file maskedrr.cpp. { // tell them about the dpi // Need to return a rounded form of the stored double dpi return (INT32)(PixelsPerInch + 0.5); }

void MaskedRenderRegion::GetFirstMaskRegion (  MaskRegion *  pMaskInfo  )

This function is used to find out the DPI that the region was created at. This is important as the device it is displaying to may have a different dpi and the difference has to be compensated for. Returns the new double form of the dpiThis function finds the first scan line section in the mask that indicates pixels need to be set. When it finds the next section it fills in the info about it in pMaskInfo and returns. If there are no regions to be found in the mask then the Length member of pMaskInfo will be set to zero. This is your clue that there are no scan line sections to process. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/4/95 Parameters: pMaskInfo  - holds info about the first region as output [OUTPUTS] See also: MaskedRenderRegion::GetNextMaskRegion; struct MaskRegion Definition at line 1076 of file maskedrr.cpp. { // Set up the starting conditions pMaskInfo->x = 0; pMaskInfo->y = 0; pMaskInfo->Length = 0; // start looking for a bit we have to blit ScanMaskFrom(pMaskInfo); }

void MaskedRenderRegion::GetNextMaskRegion (  MaskRegion *  pMaskInfo  )

This function finds the next scan line section in the mask that indicates pixels need to be set. It uses the info in the pMaskInfo param to work out where to start looking from. When it finds the next section, which could be on the same scan line as the present one, it fills in the info about it in pMaskInfo and returns. If there are no more regions to be found in the mask then the Length member of pMaskInfo will be set to zero. This is your clue that there are no more scan line sections to process. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/4/95 Parameters: pMaskInfo  - Holds info about the last region that was found [INPUTS] pMaskInfo  - but holds info about the next region as output [OUTPUTS] See also: MaskedRenderRegion::GetFirstMaskRegion; struct MaskRegion Definition at line 1110 of file maskedrr.cpp. { // Find the end of the last scan section // Move to the end of the last region pMaskInfo->x += pMaskInfo->Length; // are we at the end of the scan line if (pMaskInfo->x >= pBitmapInfo->bmiHeader.biWidth) { pMaskInfo->x = 0; pMaskInfo->y++; } // Reset the length to zero pMaskInfo->Length = 0; // start looking for a bit we have to blit ScanMaskFrom(pMaskInfo); }

virtual void MaskedRenderRegion::RestoreOffscreen (  OffscreenAttrValue *   )  [inline, virtual]

Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 203 of file maskedrr.h. { }

void MaskedRenderRegion::ScanMaskFrom (  MaskRegion *  pMaskInfo  )  [protected]

Searchs the mask for a section that means we will have to blit something. The starting position of the section and the length of the section are put into pMaskInfo and returned. pMaskInfo->Length will be set to zero if there are no more sections in the mask. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/95 Parameters: pMaskInfo  - Holds the position to start looking from [INPUTS] pMaskInfo  - Hold info about the next scan section to look at [OUTPUTS] Definition at line 1147 of file maskedrr.cpp. { // Assume we will find no more scan sections pMaskInfo->Length = 0; // get a mask to look along the bits in the mask INT32 Mask = 0x80; INT32 XStartPos = pMaskInfo->x; INT32 YStartPos = pMaskInfo->y; // Set the mask up correctly, as the X starting pos may not be at the start of a byte if (XStartPos!=0) { // Go through the byte, setting the bits back to 1 as needed INT32 PixelNum = (XStartPos/8) * 8; while (PixelNum < XStartPos) { // Shift the bit along Mask = Mask>>1; // Count the pixel PixelNum++; } } // Find out how many bytes in a scan line INT32 ScanLineSize = (pBitmapInfo->bmiHeader.biWidth+7)/8; ScanLineSize = (ScanLineSize+3)&~3; // We start out looking for the start of a region BOOL LookingForStart = TRUE; // a pointer to the byte we are dealing with LPBYTE pByte = NULL; // try and find the start of the first region for (INT32 j=YStartPos; j<pBitmapInfo->bmiHeader.biHeight; j++) { // Get the byte we are interested in pByte = pBits + (j*ScanLineSize) + (XStartPos/8); // start going accross the scan line for (INT32 i=XStartPos; i<pBitmapInfo->bmiHeader.biWidth; i++) { // Find out what this bit is (1 or 0) INT32 ThisBit = (*pByte) & Mask; // what are we looking for - the start or the end of a region. if (LookingForStart) { if (ThisBit == 0) { // Set the start position in the mask region pMaskInfo->x = i; pMaskInfo->y = j; // This bit could be all there is of a 1 pixel wide region pMaskInfo->Length = 1; // we are no longer looking for the start of the region LookingForStart = FALSE; } } else { // We are looking for the end of the region if (ThisBit!=0) { // we have reached the end of the region return; } else { // we are still in the region, so count the pixel pMaskInfo->Length++; } } // Move the mask bit along to the next pixel Mask = Mask>>1; // if we have exhasuted this byte, go on to the next one and reset the mask if (Mask==0) { Mask = 0x80; pByte++; } } // if we have found part of a region at the end of the scan line, return it if (pMaskInfo->Length>0) return; // Start the next scan line from the beginning XStartPos = 0; Mask = 0x80; } }

void MaskedRenderRegion::SetHostCaps (  RRCaps *  pCaps  )

Tells the mask region what attributes are considered complex. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/4/95 Parameters: pCaps  - pointer to the render caps for the host render region [INPUTS] Definition at line 293 of file maskedrr.cpp. { // Make a copy of the host regions caps HostCaps = *pCaps; }

void MaskedRenderRegion::SetNextShapeColour (  DocColour &  RequiredCol  )  [protected]

Sets all the attributes up so that we can render into our mask. It will boil everything down to a flat fill and stroke ready to be rendered into the mask. The colour passed in will probably be Black or White, but I left it open in case I thought of some other use for this. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/95 Parameters: RequiredCol  - The colour to replace fill and stroke colours with [INPUTS] Definition at line 704 of file maskedrr.cpp. { // Find out about the fill attr ColourFillAttribute* pColFillAttr = (ColourFillAttribute*) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if ((pColFillAttr!=NULL) && (pColFillAttr->IS_KIND_OF(GradFillAttribute))) { // This is a grad fill, so just set the colour as required SetFillColour(RequiredCol); } else { // Is there a fill colour of any kind DocColour MyFillColour = RR_FILLCOLOUR(); // See if it is 'no colour' if (!MyFillColour.IsTransparent()) { // Nope, its a real colour alright, so we had better set the fill colour SetFillColour(RequiredCol); } } // Find out about the line colour DocColour MyStrokeColour = RR_STROKECOLOUR(); // See if it is 'no colour' if (!MyStrokeColour.IsTransparent()) { // Nope, its a real colour alright, so we had better set the fill colour SetLineColour(RequiredCol); } // Set Fill transp to none if (pFillAttr!=NULL) RenderRegion::SetTranspFillGeometry(pFillAttr, FALSE); // Set the stroke transp to none if (pStrokeAttr!=NULL) RenderRegion::SetLineTransp(pStrokeAttr, FALSE); }

virtual void MaskedRenderRegion::SetOffscreen (  OffscreenAttrValue *   )  [inline, virtual]

Create a new bitmap into which, the subtree rooted at this attributes parent, will be rendered. Then call base version to push the current OffscreenAttr onto the context stack. Following only used by GRenderRegion version ** info pointer to bmp info struct which we will setup. bits pointer to bitmap bits which we'll setup. See also: GRenderRegion::RestoreOffscreen; GRenderRegion:: Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 200 of file maskedrr.h. { }

BOOL MaskedRenderRegion::SpreadMask (   )

Spreads the mask out by a pixel. This allows us to make the area that is blitted slightly bigger to cover up any differences between the device resolution and the bitmap resolution. This function will grow the mask above, below, to the left and right by a single pixel. If this is not enough, call this function more than once. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/95 Returns: TRUE if the mask was spread, FALSE if there was no mask in the first place Definition at line 763 of file maskedrr.cpp. { // If there is a bitmap if (pBits!=NULL && pBitmapInfo!=NULL) { // Get the scan line size in bytes INT32 ScanLineByteSize = (pBitmapInfo->bmiHeader.biWidth+7)/8; // Round it up to the nearest word boundary. Note, this is still a count of bytes INT32 ScanLineWordSize = ((ScanLineByteSize+3)/4)*4; // Start looping through all the scan lines in the mask, // going from top to bottom, moving set pixels up LPBYTE CurrentByte = NULL; LPBYTE ByteAbove = NULL; INT32 i; for (i=1; i<pBitmapInfo->bmiHeader.biHeight; i++) { // point CurrentByte at the start of the next scan line CurrentByte = pBits + (i*ScanLineWordSize); ByteAbove = pBits + ((i-1)*ScanLineWordSize); // Go along the scan line BOOL SetHighBit = FALSE; for (INT32 j=0; j<ScanLineByteSize; j++) { // Try and set the leading pixel on the current byte BYTE Mask = 0x01; BYTE Current = BYTE(~(*CurrentByte)); // Loop though the mask BOOL Found = FALSE; while (Mask!=0) { // See if we have found the least sig. pixel yet if ((Mask & Current) != 0) { Found = TRUE; break; } // Move the mask along a bit Mask = Mask << 1; } // Set the high bit if needed if (SetHighBit) { Current = Current | 0x80; SetHighBit = FALSE; } // If we found a bit in this byte, set the bit next to the least sig bit if (Found) { if (Mask==0x01) SetHighBit = TRUE; else Current = Current | (Mask>>1); } // Or this byte with the one in the scan line above BYTE Result = BYTE(~(*ByteAbove)) | Current; *ByteAbove = BYTE(~Result); // Move to the next byte CurrentByte++; ByteAbove++; } } // Start looping through all the scan lines in the mask, // going from bottom to top, moving set pixels down CurrentByte = NULL; LPBYTE ByteBelow = NULL; for (i=pBitmapInfo->bmiHeader.biHeight-2; i>=0; i--) { // point CurrentByte at the start of the next scan line CurrentByte = pBits + (i*ScanLineWordSize) + ScanLineByteSize; ByteBelow = pBits + ((i+1)*ScanLineWordSize) + ScanLineByteSize; // Go along the scan line BOOL SetLowBit = FALSE; for (INT32 j=ScanLineByteSize-1; j>=0; j--) { // Try and set the leading pixel on the current byte BYTE Mask = 0x80; BYTE Current = BYTE(~(*CurrentByte)); // loop though the mask BOOL Found = FALSE; while (Mask!=0) { // See if we have found the least sig. pixel yet if ((Mask & Current) != 0) { Found = TRUE; break; } // Move the mask along a bit Mask = Mask >> 1; } // Set the low bit if needed if (SetLowBit) { Current = Current | 0x01; SetLowBit = FALSE; } // If we found a bit in this byte, set the bit next to the most sig bit if (Found) { if (Mask==0x80) SetLowBit = TRUE; else Current = Current | (Mask<<1); } // Or this byte with the one in the scan line below BYTE Result = BYTE(~(*ByteBelow)) | Current; *ByteBelow = BYTE(~Result); // Move to the next byte CurrentByte--; ByteBelow--; } } } return TRUE; }

BOOL MaskedRenderRegion::StartRender (  void   )  [virtual]

Starts the render region up. This version just calls the base class and allocates a couple of attributes used during the rendering. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/95 Returns: TRUE if it worked, FALSE if it failed Reimplemented from GRenderBitmap. Definition at line 249 of file maskedrr.cpp. { // Call the base class if (!GRenderBitmap::StartRender()) return FALSE; // If we got a bitmap, then clear it if (pBits!=NULL && pBitmapInfo!=NULL) { // Find out how many bytes there are to look at INT32 TotalBytes = pBitmapInfo->bmiHeader.biSizeImage; // clear it all out - a Set pixels is transparent, an Unset pixel is not memset(pBits, 0xFF, TotalBytes); } // Do our own thing - We need some attrs if (pFillAttr==NULL) pFillAttr = new FlatTranspFillAttribute(0); if (pStrokeAttr==NULL) pStrokeAttr = new StrokeTranspAttribute(0); // See if we got the ram we wanted if ((pFillAttr==NULL) || (pStrokeAttr==NULL)) return FALSE; // if we get here, everything has worked return TRUE; }

---

Member Data Documentation

INT32 MaskedRenderRegion::BitCountTable [static, protected]

Definition at line 227 of file maskedrr.h.

DocColour MaskedRenderRegion::Black [protected]

Definition at line 215 of file maskedrr.h.

RRCaps MaskedRenderRegion::HostCaps [protected]

Definition at line 221 of file maskedrr.h.

FlatTranspFillAttribute* MaskedRenderRegion::pFillAttr [protected]

Definition at line 224 of file maskedrr.h.

StrokeTranspAttribute* MaskedRenderRegion::pStrokeAttr [protected]

Definition at line 225 of file maskedrr.h.

DocColour MaskedRenderRegion::White [protected]

Definition at line 216 of file maskedrr.h.

---

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

• Kernel/maskedrr.h (r1785/r1288)
• Kernel/maskedrr.cpp (r1785/r1288)

---