GRenderBitmap Class Reference

A GDraw render region that uses normal DIBs for the bitmap and can save itself out into an OIL bitmap. More...

#include <grndbmp.h>

Inheritance diagram for GRenderBitmap:

List of all members.

Public Member Functions
	GRenderBitmap (DocRect ClipRegion, Matrix ConvertMatrix, FIXED16 ViewScale, UINT32 Depth, double dpi, BOOL Printing=FALSE, UINT32 Dither=XARADITHER_ORDERED_GREY, LPLOGPALETTE pPalette=NULL, BOOL AutoConvert=FALSE)
	GRenderBitmap constructor. Doesn't do anything actually, just calls base class. INT32 dpi changed to double dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using.
	~GRenderBitmap ()
	GRenderBitmap destructor. Frees up the bitmap.
OILBitmap *	ExtractBitmap (LPLOGPALETTE pPalette=NULL)
	So that the caller may do what he likes with the bitmap.
OILBitmap *	ExtractBitmapCopy (LPLOGPALETTE pPalette=NULL, LPBITMAPINFO pMaskInfo=NULL, LPBYTE pMaskData=NULL, INT32 MaskColour=-1, BOOL LookForDuplicates=FALSE)
	So that the caller may do what he likes with the bitmap.
BOOL	GetBitmapData (LPBITMAPINFO *pBitmapInfo, LPBYTE *pBitmapData, BOOL Convert=FALSE)
LPBITMAPINFO	GetBitmapInfo ()
BOOL	StartRender ()
	Uses base class to do normal stuff, then fills bitmap with White as a sort of paper background.
virtual BOOL	SetFirstBand ()
	Sets up for banded rendering. This class will always band the region into 128 pixel high bands.
virtual BOOL	GetNextBand ()
	Since this class does not do banded rendering, there are never any more bands.
INT32	GetNumBands ()
	The bitmap export and printing both need to know how many bands there will be when doing banded rendering. Since the bands are of a fixed size in GRenderBitmaps we are able to work out how many there will be before hand. This function tells you how many bands there would be if you were to banded render this region.
void	SetOverlapBands (BOOL NewVal)
	This function allows to you switch band overlapping on and off. It is off by default. Bands need to be overlapped when printing to stop the error at the edge of dither pattens.
BOOL	SetRenderBottomToTop (BOOL NewVal)
	This function allows to you switch the direction that the bands are rendered in. It is bottom to top by default. We need to switch the direction when exporting as a bitmap as the Accusoft code needs it in both directions.
INT32	GetFullRegionHeight ()
	The bitmap export needs to know what the total height of the bitmap is when doing banded rendering as the region will be created the height of the band and not the full height of the bitmap.
virtual WinRect	CalculateWinRect (Matrix &RenderMatrix, const DocRect &docrect, const double dpi)
	To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi. Virtual so that it can be overriden by different render regions if so required.
void	UseGreyscaleContextDangerous (void)
	DANGEROUS! Don't use this unless you really know what you're doing.
void	StopUsingGreyscaleContextDangerous (void)
	DANGEROUS! Don't use this unless you really know what you're doing.
virtual GMATRIX	MakeGavinMatrix (Matrix NewRenderMatrix, DocRect ClipRect, double dPixelsPerInch, BOOL bMasterCapture)
	Make a Gavin Matrix out of a Kernel Matrix.
Static Public Member Functions
static void	Deinit (void)
	De-initialises the GRenderBitmap class. Mainly used to stop memory leaks after someone has been using the nasty greyscale context bodge (See StartUsingGreyscaleContextDangerous()).
static BOOL	DitheringNeeds32bpp (UINT32 Dither)
Protected Member Functions
LPBITMAPINFO	GetLPBits (INT32 Width, INT32 Height, INT32 Depth, LPBYTE *)
	Allocates a bitmap from the CCMalloc heap.
void	FreeLPBits (LPBITMAPINFO, LPBYTE)
	Frees the memory allocated in GetLPBits.
BOOL	DisplayBits (LPBITMAPINFO lpDisplayBitmapInfo=NULL, LPBYTE lpDisplayBits=NULL)
	None really, except that the base class needs one, so we supply it.
BOOL	DoOutputBitmapConversion (LPBITMAPINFO *lpConvInfo, LPBYTE *lpConvBits, LPLOGPALETTE pPalette)
LPLOGPALETTE	GetConversionPalette ()
Protected Attributes
BOOL	OverlapBands
BOOL	RenderBottomToTop
UINT32	DitherType
UINT32	uOutputDepth
LPLOGPALETTE	pConvPalette
LPBITMAPINFO	lpOutputInfo
LPBYTE	lpOutputBits
double	m_dXCentralAdjust
double	m_dYCentralAdjust
Private Attributes
GDrawContext *	pPreviousGDrawContext
Static Private Attributes
static GDrawContext *	pGreyscaleContext = NULL

---

Detailed Description

A GDraw render region that uses normal DIBs for the bitmap and can save itself out into an OIL bitmap.

Author:

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

Date:

2/6/94

Definition at line 118 of file grndbmp.h.

---

Constructor & Destructor Documentation

GRenderBitmap::GRenderBitmap (  DocRect  ClipRegion, Matrix  ConvertMatrix, FIXED16  ViewScale, UINT32  Depth, double  dpi, BOOL  Printing = FALSE, UINT32  Dither = XARADITHER_ORDERED_GREY, LPLOGPALETTE  pPalette = NULL, BOOL  AutoConvert = FALSE )

GRenderBitmap constructor. Doesn't do anything actually, just calls base class. INT32 dpi changed to double dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: GRenderRegion::GRenderRegion Definition at line 176 of file grndbmp.cpp. : GRenderDIB( ClipRegion, ConvertMatrix, ViewScale, Depth, dpi) { // normally our colour context is obtained by RenderRegion::InitDevice, // but sadly this requires a RenderWindow, which we ain't got. There must // be a better way than this, but don't knock it. This must be done BEFORE // InitDevice as that renders default attributes, which tend to rely on a colour context if (RenderView==NULL) CurrentColContext = ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); // we do not want to overlap the bands by default OverlapBands = FALSE; // We do want to render bottom to top by default RenderBottomToTop = TRUE; // Render flag stuff RenderFlags.Printing = Printing; // This next bit was added to cope with the conversion needed when using certain // dithering techniques DitherType = Dither; uOutputDepth = Depth; // If different from the actual RR bpp, then the bitmap will // be converted before output lpOutputInfo = NULL; lpOutputBits = NULL; m_dXCentralAdjust = 0; m_dYCentralAdjust = 0; pConvPalette = pPalette; if (AutoConvert && uOutputDepth<32) { // The dithering we are using requires us to render to 32bpp and then convert it down // to our output bpp at the end // Force rendering to 32bpp, we will convert it to 'Depth' at the end uBitmapDepth = 32; } pPreviousGDrawContext = NULL; }

GRenderBitmap::~GRenderBitmap (   )

GRenderBitmap destructor. Frees up the bitmap. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 370 of file grndbmp.cpp. { // we should NOT delete the CurrentColContext cos we didn't alloc it - we just // got a pointer to something allocated by somebody else if (lpOutputInfo!=NULL || lpOutputBits!=NULL) { // Free up the conversion bitmap FreeDIB(lpOutputInfo, lpOutputBits); lpOutputInfo = NULL; lpOutputBits = NULL; } // Free up the bitmap here, as the call to FreeLPBits in the // GRenderDIB will not call the correct version (the virtual-ness will be // broken as it is called from a destructor if (pBitmapInfo!=NULL) { // NB Export rendering can be cancelled by user // Hence can be in the middle of offscreen rendering at this point FreeOffscreenState(); pBitmapInfo = NULL; pBits = NULL; } // Make sure we restore the state of the GDrawContext if our client forgot to // turn off the context replacement. See UseGreyscaleContextDangerous(), below. if (pPreviousGDrawContext != NULL) { if (SetTempDrawContext(pPreviousGDrawContext) != pGreyscaleContext) { ERROR3("Not pGreyscaleContext when restoring"); } pPreviousGDrawContext = NULL; } }

---

Member Function Documentation

WinRect GRenderBitmap::CalculateWinRect (  Matrix &  RenderMatrix, const DocRect &  docrect, const double  dpi )  [virtual]

To convert a rectangle in Doc coordinates to a rectangle in Win coordinates taking account of the destination dpi rather than assuming screen dpi. Virtual so that it can be overriden by different render regions if so required. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/96 Parameters: DocRect  is a rectangle on document co-ords. [INPUTS] dpi is the resolution of the device we are rendering to RenderMatrix  is the rendering matrix, may have e anf f components changed by the call [OUTPUTS] Returns: Object containing the new rectangle coordinates. See also: OSRenderRegion::DocRectToWin; Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 298 of file grndbmp.cpp. { // lets get the Rect into screen co-ords so we can use our big screen bitmap // Use a version of OSRenderRegion::DocRectToWin that uses the actual dpi we have stored // in PixelsPerInch and that tries to sort out the pixel problems return OSRenderRegion::BitmapDocRectToWin( RenderMatrix, docrect, dpi ); }

void GRenderBitmap::Deinit (  void   )  [static]

De-initialises the GRenderBitmap class. Mainly used to stop memory leaks after someone has been using the nasty greyscale context bodge (See StartUsingGreyscaleContextDangerous()). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 5/2/97 Definition at line 1480 of file grndbmp.cpp. { ERROR3IF(GD != NULL && GD == pGreyscaleContext, "GRenderBitmap greyscale context still in use"); if (pGreyscaleContext != NULL) { delete pGreyscaleContext; pGreyscaleContext = NULL; } }

BOOL GRenderBitmap::DisplayBits (  LPBITMAPINFO  lpDisplayBitmapInfo = NULL, LPBYTE  lpDisplayBits = NULL )  [protected, virtual]

None really, except that the base class needs one, so we supply it. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if worked, FALSE if failed. Errors: - Reimplemented from GRenderDIB. Definition at line 800 of file grndbmp.cpp. { return TRUE; }

BOOL GRenderBitmap::DitheringNeeds32bpp (  UINT32  Dither  )  [static]

Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 237 of file grndbmp.cpp. { return (Dither != XARADITHER_ORDERED_GREY); }

BOOL GRenderBitmap::DoOutputBitmapConversion (  LPBITMAPINFO *  lpConvInfo, LPBYTE *  lpConvBits, LPLOGPALETTE  pPalette )  [protected]

Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/96 Returns: - Definition at line 1196 of file grndbmp.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(lpConvInfo == NULL, "NULL info pointer passed to GRenderBitmap::DoOutputBitmapConversion"); if (lpConvInfo == NULL) return FALSE; ERROR3IF(lpConvBits == NULL, "NULL data pointer passed to GRenderBitmap::DoOutputBitmapConversion"); if (lpConvBits == NULL) return FALSE; if (uOutputDepth == uBitmapDepth) { // No conversion is needed !! *lpConvInfo = pBitmapInfo; *lpConvBits = pBits; if(m_bEnableConversion && m_DoCompression) { UINT32 Width = pBitmapInfo->bmiHeader.biWidth; UINT32 Height = pBitmapInfo->bmiHeader.biHeight; BYTE* lpOutput = pBits; DIBConvert* Converter = DIBConvert::Create( 32, 32, Width, NULL, 0 ); if(Converter != NULL) { Converter->Convert(pBits, lpOutput, Height); delete Converter; Converter = NULL; // Force the bitmap to be reinitialised when StartRender is next called ForceInitBmpBits = TRUE; ENSURE(GetMasterCapture()==NULL || MasterCaptureIsCurrent(), "Bitmap converted in-place while captures are running\n"); } } return TRUE; } // Blank the pointer in case of an error *lpConvInfo = NULL; *lpConvBits = NULL; // We must need to do some Bitmap conversion then .... UINT32 Width = pBitmapInfo->bmiHeader.biWidth; UINT32 Height = pBitmapInfo->bmiHeader.biHeight; // Make a converter object DIBConvert* Converter = DIBConvert::Create( uBitmapDepth, uOutputDepth, Width, pPalette, DitherType ); ERROR3IF(Converter == NULL, "Failed to create DIBConvert object in GRenderBitmap::DoOutputBitmapConversion"); if (Converter == NULL) return FALSE; if (lpOutputInfo != NULL || lpOutputBits != NULL) { // Free the existing bitmap data FreeDIB(lpOutputInfo, lpOutputBits); lpOutputInfo = NULL; lpOutputBits = NULL; } // Allocate some memory for the converted bitmap lpOutputInfo = AllocDIB(Width, Height, uOutputDepth, &lpOutputBits); ERROR3IF(lpOutputInfo == NULL, "Failed to allocate conversion info in GRenderBitmap::DoOutputBitmapConversion"); ERROR3IF(lpOutputBits == NULL, "Failed to allocate conversion data in GRenderBitmap::DoOutputBitmapConversion"); if (lpOutputInfo == NULL || lpOutputBits == NULL) return FALSE; // Do the conversion BOOL ok = Converter->Convert(pBits, lpOutputBits, Height); delete Converter; if (ok) { *lpConvInfo = lpOutputInfo; *lpConvBits = lpOutputBits; } return ok; #else return FALSE; #endif }

OILBitmap * GRenderBitmap::ExtractBitmap (  LPLOGPALETTE  pPalette = NULL  )

So that the caller may do what he likes with the bitmap. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Returns: A pointer to a fresh OILBitmap, or NULL if failed. This OILBitmap has Attach called on and will stay around after the RR is long gone. Returns NULL if something bad happened. The OilBitmap is attached as a tempory bitmap so if you want it to hang around as a permanent bmp, then don't forget to do something about it. Definition at line 819 of file grndbmp.cpp. { if (pBitmapInfo && pBits) { LPBITMAPINFO lpConvInfo; LPBYTE lpConvBits; BOOL DeletePalette = FALSE; if(!pPalette) { pPalette = GetConversionPalette(); if (pPalette && pPalette != pConvPalette) DeletePalette = TRUE; } BOOL ok = DoOutputBitmapConversion(&lpConvInfo, &lpConvBits, pPalette); ERROR3IF(!ok, "Output conversion failed in GRenderBitmap::ExtractBitmap"); if (!ok) { if(DeletePalette) CCFree(pPalette); return NULL; } CWxBitmap *OILBM = new CWxBitmap( lpConvInfo, lpConvBits ); if (OILBM) { // Setup the Oil bitmap's pallete RGBQUAD* pOilPalette = OILBM->BMInfo->bmiColors; PALETTEENTRY* pPaletteEntry = pPalette->palPalEntry; // Copy the palette entries over, we cannot copy a structure at a time because // the bytes are in different orders for (DWORD i=0; i< OILBM->BMInfo->bmiHeader.biClrUsed; i++) { pOilPalette[i].rgbBlue = pPaletteEntry[i].peBlue; pOilPalette[i].rgbGreen = pPaletteEntry[i].peGreen; pOilPalette[i].rgbRed = pPaletteEntry[i].peRed; pOilPalette[i].rgbReserved = pPaletteEntry[i].peFlags; } if (lpConvBits == pBits) { // ensure empty offscreen stack //#ifdef _DEBUG // DumpCaptureStack(); //#endif ENSURE(MasterCaptureIsCurrent(), "Extract bitmap whilst rendering offscreen not finished!"); // bytes owned by CWxBitmap now - zero them so we don't free them up SetBitmapPointers(NULL, NULL); } if (lpConvBits == lpOutputBits) { // bytes owned by CWxBitmap now - zero them so we don't free them up lpOutputInfo = NULL; lpOutputBits = NULL; } if(DeletePalette) CCFree(pPalette); return OILBM; } if(DeletePalette) CCFree(pPalette); } return NULL; }

OILBitmap * GRenderBitmap::ExtractBitmapCopy (  LPLOGPALETTE  pPalette = NULL, LPBITMAPINFO  pMaskInfo = NULL, LPBYTE  pMaskData = NULL, INT32  MaskColour = -1, BOOL  LookForDuplicates = FALSE )

So that the caller may do what he likes with the bitmap. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/96 Parameters: pPalette  [INPUTS] pMaskInfo pMaskData MaskColour LookForDuplicates - if True then see if this bitmap is a duplicate of an existing one in the system Returns: A pointer to a fresh OILBitmap, or NULL if failed. This OILBitmap has Attach called on and will stay around after the RR is long gone. Returns NULL if something bad happened. The OilBitmap is attached as a tempory bitmap so if you want it to hang around as a permanent bmp, then don't forget to do something about it. The bitmap extracted is a COPY of the Regions bitmap data, which is left untouched. Definition at line 920 of file grndbmp.cpp. { ERROR3IF(MaskColour==-2,"Someone`s using a MaskColour of -2!!! Please Correct!"); BOOL bBrowserPalette = FALSE; if(!pPalette) bBrowserPalette = TRUE; if (pBitmapInfo && pBits) { LPBITMAPINFO lpCopyInfo = NULL; LPBYTE lpCopyBits = NULL; LPBITMAPINFO lpConvInfo = NULL; LPBYTE lpConvBits = NULL; BOOL DeletePalette = FALSE; if (!pPalette) { pPalette = GetConversionPalette(); DeletePalette = (pPalette && pPalette != pConvPalette); } if (pPalette && MaskColour >= 0 && MaskColour < pPalette->palNumEntries) { pPalette->palPalEntry[MaskColour].peRed = 255; pPalette->palPalEntry[MaskColour].peGreen = 255; pPalette->palPalEntry[MaskColour].peBlue = 255; pPalette->palPalEntry[MaskColour].peFlags = 255; } BOOL ok = DoOutputBitmapConversion(&lpConvInfo, &lpConvBits, pPalette); ERROR3IF(!ok, "Output conversion failed in GRenderBitmap::ExtractBitmap"); if (!ok) { if (DeletePalette) CCFree(pPalette); return NULL; } if (lpConvBits == pBits) { BOOL CopyOK = DIBUtil::CopyBitmap(pBitmapInfo, pBits, &lpCopyInfo, &lpCopyBits); if (!CopyOK) { ERROR3("Failed to copy bitmap in ExtractBitmapCopy"); if (DeletePalette) CCFree(pPalette); return NULL; } } else { lpCopyInfo = lpConvInfo; lpCopyBits = lpConvBits; } if (pMaskInfo && pMaskData && MaskColour>=0) { // We've been given a mask for the bitmap ... if (!DIBUtil::MakeTransparentBitmap(lpCopyInfo, lpCopyBits, pMaskInfo, pMaskData, MaskColour)) { ERROR3("Failed to apply mask in GRenderBitmap::ExtractBitmapCopy"); if (DeletePalette) CCFree(pPalette); FreeDIB(lpCopyInfo, lpCopyBits); return NULL; } } CWxBitmap *OILBM = new CWxBitmap( lpCopyInfo, lpCopyBits ); if (OILBM) { // Make sure that the bitmap has a width and height which are an integral // number of pixels. INT32 width = (INT32)(( OILBM->BMInfo->bmiHeader.biWidth ) * 72000 / 96.0); INT32 height = (INT32)(( OILBM->BMInfo->bmiHeader.biHeight ) * 72000 / 96.0); OILBM->SetRecommendedWidth( width ); OILBM->SetRecommendedHeight( height ); // Setup the Oil bitmap's pallete RGBQUAD* pOilPalette = OILBM->BMInfo->bmiColors; // Only change the palette if there is on already present // REMEMBER bitmaps with more than 8bpp generally do not have palettes if (pPalette != NULL) { // This will be the optimised palette INT32 ColoursInPal = pPalette->palNumEntries; // The optimised palette will NOT contain the transparent colour // Therefore, if we have a transparent colour then increment our count if (MaskColour >= 0) { // We have to ensure that the number of colours we are requesting will // be enough to contain the transparent colour index. if (MaskColour > ColoursInPal) { // Not enough entries in out palette // So expand it to include the mask colour ColoursInPal = MaskColour + 1; } else ColoursInPal++; } // The bitmap header will contain the colour depth number of colours INT32 MaxColours = OILBM->BMInfo->bmiHeader.biClrUsed; // Ensure that we have not gone over this limit if (ColoursInPal > MaxColours) ColoursInPal = MaxColours; // Copy the palette entries over, we cannot copy a structure at a time because // the bytes are in different orders PALETTEENTRY* pPaletteEntry = pPalette->palPalEntry; for (INT32 i = 0; i < MaxColours; i++) { if (i == MaskColour) { // Force the masked colour to White, so it looks right // even if we can't render it with transparency pOilPalette[i].rgbBlue = 255; pOilPalette[i].rgbGreen = 255; pOilPalette[i].rgbRed = 255; pOilPalette[i].rgbReserved = 255; } else if (i > ColoursInPal) { // Force any unused colours to be black pOilPalette[i].rgbBlue = 0; pOilPalette[i].rgbGreen = 0; pOilPalette[i].rgbRed = 0; pOilPalette[i].rgbReserved = 0; } else { pOilPalette[i].rgbBlue = pPaletteEntry[i].peBlue; pOilPalette[i].rgbGreen = pPaletteEntry[i].peGreen; pOilPalette[i].rgbRed = pPaletteEntry[i].peRed; pOilPalette[i].rgbReserved = 0; } } // Only set up the required number of palette entries OILBM->BMInfo->bmiHeader.biClrUsed = ColoursInPal; } if (lpCopyBits == pBits) { // bytes owned by CWxBitmap now - zero them so we don't free them up SetBitmapPointers(NULL, NULL); // ensure empty offscreen stack ENSURE(MasterCaptureIsCurrent(), "Extract bitmap whilst rendering offscreen not finished!"); } if (lpCopyBits == lpOutputBits) { // bytes owned by CWxBitmap now - zero them so we don't free them up lpOutputInfo = NULL; lpOutputBits = NULL; } if (LookForDuplicates) { // This check was not here before 25/4/97 // Check to see if this bitmap exists in the global bitmap list // This will actually check the bitmap itself to see if it is the same // rather than doing a simple and explicit pointer check. GlobalBitmapList * pBmpList = GetApplication()->GetGlobalBitmapList(); OILBitmap* pExistingBmp = NULL; if (pBmpList) pExistingBmp = pBmpList->FindDuplicateBitmap(OILBM); if (pExistingBmp) { TRACEUSER( "Neville", _T("This bitmap already exists. Re-using existing OILBitmap.\n")); // There's already an existing OIL bitmap we can use, // so we'll make a new kernel bitmap out of it ... if (DeletePalette) CCFree(pPalette); delete OILBM; return pExistingBmp; } } if (DeletePalette) CCFree(pPalette); return OILBitmap::Attach(OILBM, FALSE); } if(DeletePalette) CCFree(pPalette); } return NULL; }

void GRenderBitmap::FreeLPBits (  LPBITMAPINFO  lpBMI, LPBYTE  lpB )  [protected, virtual]

Frees the memory allocated in GetLPBits. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/95 Reimplemented from GRenderDIB. Definition at line 777 of file grndbmp.cpp. { // Free up the memory. Not from Limited Heap FreeDIB(lpBMI, lpB, NULL, FALSE); }

BOOL GRenderBitmap::GetBitmapData (  LPBITMAPINFO *  pBmpInfo, LPBYTE *  pBmpData, BOOL  Convert = FALSE )

Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/96 Returns: - Definition at line 1129 of file grndbmp.cpp. { ERROR3IF(pBmpInfo == NULL, "NULL info pointer passed to GetBitmapData"); if (pBmpInfo == NULL) return FALSE; ERROR3IF(pBmpData == NULL, "NULL data pointer passed to GetBitmapData"); if (pBmpData == NULL) return FALSE; if (!Convert) { *pBmpInfo = pBitmapInfo; *pBmpData = pBits; if(m_bEnableConversion && m_DoCompression) { UINT32 Width = pBitmapInfo->bmiHeader.biWidth; UINT32 Height = pBitmapInfo->bmiHeader.biHeight; BYTE* lpOutput = *pBmpData; DIBConvert* Converter = DIBConvert::Create( 32, 32, Width, NULL, 0 ); if(Converter != NULL) { Converter->Convert(pBits, lpOutput, Height); delete Converter; Converter = NULL; // Force the bitmap to be reinitialised when StartRender is next called ForceInitBmpBits = TRUE; ENSURE(GetMasterCapture()==NULL || MasterCaptureIsCurrent(), "Bitmap converted in-place while captures are running\n"); } } return TRUE; } LPBITMAPINFO lpConvInfo=NULL; LPBYTE lpConvBits=NULL; LPLOGPALETTE pPalette = GetConversionPalette(); BOOL ok = DoOutputBitmapConversion(&lpConvInfo, &lpConvBits, pPalette); ERROR3IF(!ok, "Output conversion failed in GRenderBitmap::GetBitmapData"); *pBmpInfo = lpConvInfo; *pBmpData = lpConvBits; if (pPalette != pConvPalette) CCFree(pPalette); return ok; }

LPBITMAPINFO GRenderBitmap::GetBitmapInfo (   )  [inline]

Definition at line 146 of file grndbmp.h. { return pBitmapInfo; }

LPLOGPALETTE GRenderBitmap::GetConversionPalette (   )  [protected]

Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/96 Returns: - Definition at line 1294 of file grndbmp.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (uOutputDepth>8) return NULL; // Must be 8bpp or less if (pConvPalette) return pConvPalette; // Use specified palette if one exists //ASSERT(FALSE); // we should have a palette!! sjk SMFIX // most times we should have a palette but for now animated gifs like to use this code so we will leave it for now LPLOGPALETTE pPalette; size_t TotalPal; switch (uOutputDepth) { case 8: // Get the standard 256 colour palette TotalPal = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 ); pPalette = (LPLOGPALETTE)CCMalloc( TotalPal ); if (pPalette != NULL) { LPLOGPALETTE pRecPalette = GetErrorDiffPalette(); if (pRecPalette) { memcpy(pPalette, pRecPalette, TotalPal); } else { CCFree(pPalette); return NULL; } } break; case 4: TotalPal = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 16 ); pPalette = (LPLOGPALETTE)CCMalloc( TotalPal ); if (pPalette != NULL) { // Make a standard 16 colour palette OutputDIB::Fix16ColourPalette(pPalette); } break; case 1: TotalPal = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 2 ); pPalette = (LPLOGPALETTE)CCMalloc( TotalPal ); if (pPalette != NULL) { // Make a simple black and white palette OutputDIB::FixBlackAndWhitePalette(pPalette); } break; default: ERROR3("Bad colour depth in GRenderBitmap::GetConversionPalette"); pPalette = NULL; break; } return pPalette; #else return NULL; #endif }

INT32 GRenderBitmap::GetFullRegionHeight (   )

The bitmap export needs to know what the total height of the bitmap is when doing banded rendering as the region will be created the height of the band and not the full height of the bitmap. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/95 Returns: The total height of the render region. Definition at line 460 of file grndbmp.cpp. { // Find out the actual size in pixels of this render region // Use the same method that is used to construct the matrix and we use in // the bitmap options dialog box to work out the size so that we are consistent Matrix Identity; // default construction is an identity matrix WinRect Rect = OSRenderRegion::BitmapDocRectToWin( Identity, RegionRect, PixelsPerInch ); return Rect.height; }

LPBITMAPINFO GRenderBitmap::GetLPBits (  INT32  Width, INT32  Height, INT32  Depth, LPBYTE *  lplpBits )  [protected, virtual]

Allocates a bitmap from the CCMalloc heap. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/95 Parameters: Width,Height  - the width and height of the required bitmap [INPUTS] Depth - the bpp of the bitmap Returns: Pointer to a bitmap header block Reimplemented from GRenderDIB. Definition at line 754 of file grndbmp.cpp. { // Get a DIB out of the CCMalloc heap LPBITMAPINFO bmInfo = NULL; bmInfo = AllocDIB( abs(Width), abs(Height), Depth, lplpBits, NULL, FALSE); // return it. return bmInfo; }

BOOL GRenderBitmap::GetNextBand (   )  [virtual]

Since this class does not do banded rendering, there are never any more bands. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/95 Returns: FALSE Reimplemented from GRenderDIB. Reimplemented in GRenderOptPalette. Definition at line 620 of file grndbmp.cpp. { // Go find the next band, if there is one. // Give back the memory we already have if (pBitmapInfo!=NULL) { FreeOffscreenState(); pBitmapInfo = NULL; pBits = NULL; } // ENSURE(GetCaptureDepth()==0, "Can't set a band while there are any captures running"); ENSURE(GetCaptureDepth()==0 || MasterCaptureIsCurrent(), "Can't set a band while there are any non-master captures running\n"); // if this is not a banded render region, then there are no more bands if (!IsBanded()) return FALSE; if (RenderBottomToTop) { // Render from the bottom upwards // See if we are out of bands if ((CurrentClipRect.hi.y >= RegionRect.hi.y) || (IsLastBand)) return FALSE; } else { // Render from the top downwards // See if we are out of bands if ((CurrentClipRect.lo.y <= RegionRect.lo.y) || (IsLastBand)) return FALSE; } // we're going to need to be re-rendered IsPaperRendered = FALSE; IsInkRenderStarted = FALSE; // Get the number of scan lines we are prepared to do INT32 MaxScanLines = FIXEDBANDSIZE; // Work out how many scan lines there are left to do double TruePixelHeight = 72000.0 / PixelsPerInch; //.MakeDouble(); // Removed due to problems with printing feathers (see comment at top of file) // ERROR3IF(ScaleFactor.MakeDouble() != 1.0, "ScaleFactor not 1, see comment at top of grndbmp.cpp"); INT32 Height = 0; if (RenderBottomToTop) { // Render from the bottom upwards Height = (INT32) ((double)(RegionRect.hi.y - CurrentClipRect.hi.y) / TruePixelHeight); } else { // Render from the top downwards Height = (INT32) ((double)(CurrentClipRect.lo.y - RegionRect.lo.y ) / TruePixelHeight); } // see if there are enought to bother with IsWaitingForRAM = FALSE; // Do what we can INT32 ScanLinesToDo = (MaxScanLines < Height) ? MaxScanLines : Height; if (ScanLinesToDo==Height) IsLastBand = TRUE; else IsLastBand = FALSE; // Find out how big in millipoints we can do MILLIPOINT MaxHeight = (MILLIPOINT) (TruePixelHeight * (double)ScanLinesToDo); DocRect NewClipRect = CurrentClipRect; if (RenderBottomToTop) { // Render from the bottom upwards // Set up the new clip rect ready NewClipRect.lo.y = CurrentClipRect.hi.y; NewClipRect.hi.y = NewClipRect.lo.y + MaxHeight; // if we want to overlap the bands, make an adjustment if (OverlapBands) NewClipRect.lo.y -= (INT32)(2 * TruePixelHeight); // Sanity check if ((NewClipRect.hi.y > RegionRect.hi.y) || (IsLastBand)) NewClipRect.hi.y = RegionRect.hi.y; } else { // Render from the top downwards // Set up the new clip rect ready NewClipRect.hi.y = CurrentClipRect.lo.y; NewClipRect.lo.y = NewClipRect.hi.y - MaxHeight; // if we want to overlap the bands, make an adjustment if (OverlapBands) NewClipRect.hi.y -= (INT32)(2 * TruePixelHeight); // Sanity check if ((NewClipRect.lo.y < RegionRect.lo.y) || (IsLastBand)) NewClipRect.lo.y = RegionRect.lo.y; } // Make sure that we are not dealing with an empty rect if (NewClipRect.Height()==0) return FALSE; // Set the new clip rect up ready for rendering SetClipRect(NewClipRect); // we're going to need to be re-rendered IsPaperRendered = FALSE; IsInkRenderStarted = FALSE; TRACEUSER("Gavin",_T("GRenderBitmap::GetNextBand - RenderFlags.Rendering = FALSE;\n")); RenderFlags.Rendering = FALSE; // Say it all worked return TRUE; }

INT32 GRenderBitmap::GetNumBands (   )

The bitmap export and printing both need to know how many bands there will be when doing banded rendering. Since the bands are of a fixed size in GRenderBitmaps we are able to work out how many there will be before hand. This function tells you how many bands there would be if you were to banded render this region. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/95 Returns: The number of strips the banded region will take. Definition at line 424 of file grndbmp.cpp. { // Find out how big in millipoints we can do double TruePixelHeight = 72000.0 / PixelsPerInch; //.MakeDouble(); // Removed due to problems with printing feathers (see comment at top of file) // ERROR3IF(ScaleFactor.MakeDouble() != 1.0, "ScaleFactor not 1, see comment at top of grndbmp.cpp"); // Work out how many scan lines That works out to be INT32 Height = (INT32)((double)RegionRect.Height() / TruePixelHeight); // count the bands INT32 Bands = 0; while (Height>0) { Bands++; Height -= FIXEDBANDSIZE; } // say how many we found return Bands; }

GMATRIX GRenderBitmap::MakeGavinMatrix (  Matrix  NewRenderMatrix, DocRect  ClipRect, double  dPixelsPerInch, BOOL  bMasterCapture )  [virtual]

Make a Gavin Matrix out of a Kernel Matrix. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> (from Will (from Phil code)) Date: ??/??/2004 Parameters: The  Kernel Matrix and cliprect to use to create the Gavin Matrix. [INPUTS] Returns: TRUE if the GMatrix was created ok. See also: GRenderRegion::SetGavinMatrix Notes: Doesn't rely on current state of CurrentClipRect like the above version Reimplemented from GRenderRegion. Reimplemented in PrintingMaskedRenderRegion. Definition at line 321 of file grndbmp.cpp. { GMATRIX gmat; // Get the scale factors from the original render matrix FIXED16 abcd[4]; NewRenderMatrix.GetComponents( abcd, NULL ); // Use them to call DocRect to win on the clipping region, without attempting any translation. // Thus, the DocCoord cliprect gets turned directly into a Windows pixel values cliprect! Matrix UnscrolledRender(abcd[0], abcd[1], abcd[2], abcd[3], 0, 0); // in order to get Gavin's matrix calcs to agree with ours, we have to force him to // round before shifting down. We do this by adding half a pixel to the offsets in // his matrices. There is a school of thought which says that his matrix code // should be made to round, but it might have unpleasant side-effects. For now, we do // it this way. A pixel is 1<<(FX+16), so half a pixel is this incantation: // sjk's (5/12/00) preferred version as this works with the decimal places that may be in PixelsPerInch const XLONG Mult = (INT32)(dPixelsPerInch*(double)(1 << FX) + 0.5); gmat.AX = ( (XLONG)abcd[0].GetRawLong() * Mult ) / XLONG(72000); gmat.AY = ( (XLONG)abcd[1].GetRawLong() * Mult ) / XLONG(72000); gmat.BX = ( (XLONG)abcd[2].GetRawLong() * Mult ) / XLONG(72000); gmat.BY = ( (XLONG)abcd[3].GetRawLong() * Mult ) / XLONG(72000); // Work out the offsets in the GMatrix, taking into account special handling // to centralise the drawing within the bitmap // If we're making the matrix for the master capture // Then DO centralise teh rendering within the whole-pixel bitmap // Else DON'T centralise again, just re-use the offsets we calculated the first time OSRenderRegion::CalculateGavinOffsetsWinRect(UnscrolledRender, ClipRect, dPixelsPerInch, &gmat, bMasterCapture, &m_dXCentralAdjust, &m_dYCentralAdjust); return gmat; }

BOOL GRenderBitmap::SetFirstBand (   )  [virtual]

Sets up for banded rendering. This class will always band the region into 128 pixel high bands. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/95 Returns: TRUE if it worked, FLASE if it failed Reimplemented from GRenderDIB. Definition at line 523 of file grndbmp.cpp. { // if we are already banded, or we already have a bitmap, then stop looking // SMFIX we do want to come in here twice - once sometimes to do the palette, the second time to do the render // if (IsBanded() || lpBitmapInfo!=NULL) // return TRUE; // ENSURE(GetCaptureDepth()==0, "Can't set a band while there are any captures running"); ENSURE(GetCaptureDepth()==0 || MasterCaptureIsCurrent(), "Can't set a band while there are any non-master captures running\n"); // They can be merged for the time being CanRegionBeMerged = TRUE; // Make sure the InitDevice has been called. if (!RenderFlags.ValidDevice) { // Device needs to be initialised if (!InitDevice()) { // Something's gone wrong - inform the user. TRACE( _T("InitDevice failed in Render Region")); return FALSE; } // Make sure we don't do this again for this render region RenderFlags.ValidDevice = TRUE; } // Work out how many scan lines there are double TruePixelHeight = 72000.0 / PixelsPerInch; //.MakeDouble(); // Removed due to problems with printing feathers (see comment at top of file) // ERROR3IF(ScaleFactor.MakeDouble() != 1.0, "ScaleFactor not 1, see comment at top of grndbmp.cpp"); INT32 Height = (INT32) ((double)(RegionRect.hi.y - RegionRect.lo.y) / TruePixelHeight); // Work out how many scan lines we could fit into the available ram INT32 MaxScanLines = FIXEDBANDSIZE; // See if we can do it if (MaxScanLines>=Height) { // No Banding needed IsRegionBanded = FALSE; IsWaitingForRAM = FALSE; IsLastBand = TRUE; return TRUE; } else { // Lets band this region then IsRegionBanded = TRUE; IsWaitingForRAM = FALSE; IsLastBand = FALSE; CanRegionBeMerged = FALSE; // Find out how big in millipoints we can do MILLIPOINT MaxHeight = (MILLIPOINT)(TruePixelHeight * (double)MaxScanLines); // Set up the new clip rect ready DocRect NewClipRect = CurrentClipRect; if (RenderBottomToTop) { // Render from the bottom upwards NewClipRect.hi.y = NewClipRect.lo.y + MaxHeight; // Sanity check if (NewClipRect.hi.y > CurrentClipRect.hi.y) NewClipRect.hi.y = CurrentClipRect.hi.y; } else { // Render from the top downwards NewClipRect.lo.y = NewClipRect.hi.y - MaxHeight; // Sanity check if (NewClipRect.lo.y < CurrentClipRect.lo.y) NewClipRect.lo.y = CurrentClipRect.lo.y; } // Set the new clip rect up ready for rendering SetClipRect(NewClipRect); return TRUE; } }

void GRenderBitmap::SetOverlapBands (  BOOL  NewVal  )

This function allows to you switch band overlapping on and off. It is off by default. Bands need to be overlapped when printing to stop the error at the edge of dither pattens. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: TRUE  to start overlapping bands, FALSE to switch overlapping off [INPUTS] Definition at line 484 of file grndbmp.cpp. { OverlapBands = NewVal; }

BOOL GRenderBitmap::SetRenderBottomToTop (  BOOL  NewVal  )

This function allows to you switch the direction that the bands are rendered in. It is bottom to top by default. We need to switch the direction when exporting as a bitmap as the Accusoft code needs it in both directions. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/95 Parameters: TRUE  to render bottom to top, FALSE to render top to bottom [INPUTS] Definition at line 503 of file grndbmp.cpp. { BOOL OldVal = RenderBottomToTop; RenderBottomToTop = NewVal; return OldVal; }

BOOL GRenderBitmap::StartRender (  void   )  [virtual]

Uses base class to do normal stuff, then fills bitmap with White as a sort of paper background. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if worked, FALSE if failed Errors: - See also: GRenderDIB::StartRender Reimplemented from GRenderRegion. Reimplemented in MaskedRenderRegion. Definition at line 258 of file grndbmp.cpp. { // call base class first const BOOL ok = GRenderDIB::StartRender(); if (!ok) return FALSE; /* In an attempt to standardise things, all bmp initing is now done by the InitBmpBits() virtual function. I am pretty sure that in the past, double bmp initialisation was occuring ie here, and in the GetDrawContext()->SetupBitmap(..) function as well. */ // set bitmap size field so gets written out correctly pBitmapInfo->bmiHeader.biXPelsPerMeter = (INT32)((PixelsPerInch * 10000 ) / 254); //lpBitmapInfo->bmiHeader.biXPelsPerMeter = Mul32Div32( PixelsPerInch, 10000, 254 ); pBitmapInfo->bmiHeader.biYPelsPerMeter = pBitmapInfo->bmiHeader.biXPelsPerMeter; // done OK return TRUE; }

void GRenderBitmap::StopUsingGreyscaleContextDangerous (  void   )

DANGEROUS! Don't use this unless you really know what you're doing. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 5/2/97 See StartUsingGreyscaleContextDangerous() Definition at line 1451 of file grndbmp.cpp. { TRACEUSER( "Gerry", _T("GRenderBitmap::StopUsingGreyscaleContextDangerous\n")); ERROR3IF(pPreviousGDrawContext == NULL, "UseGreyscaleContextDangerous called while context not in use"); if (pPreviousGDrawContext != NULL) { if (SetTempDrawContext(pPreviousGDrawContext) != pGreyscaleContext) { ERROR3("Not pGreyscaleContext when restoring"); } pPreviousGDrawContext = NULL; } }

void GRenderBitmap::UseGreyscaleContextDangerous (  void   )

DANGEROUS! Don't use this unless you really know what you're doing. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 5/2/97 Replaces the static GRenderRegion::GD context with a new Greyscale paletted one for generating 8bpp greyscale images with. This has two purposes - 1. to allow creation of 8bpp greyscale images without having to allocate a 32bp bitmap or anything 2. to allow a GRenderRegion-derived render region to be used to render inside the rendering loop of another GRenderRegion. This is currently used by the airbrush path stroking code to draw transparency information into an 8bpp greyscale bitmap, on the fly, during normal GDraw rendering. If you want to do something similar, take a look at that code, because great care must be taken when using one GRndRgn inside the other to make sure no corruption occurs. There is only one symptom of getting it wrong: a nasty access violation. Before calling StartRender on your new GRenderBitmap, call this function to install the new context. Once finished, you must restore the normal GRenderRegion state by calling StopUsingGreyscaleContextDangerous() Definition at line 1395 of file grndbmp.cpp. { TRACEUSER( "Gerry", _T("GRenderBitmap::UseGreyscaleContextDangerous\n")); ERROR3IF(pPreviousGDrawContext != NULL, "UseGreyscaleContextDangerous called while context in use"); if (pPreviousGDrawContext == NULL) { if (pGreyscaleContext == NULL) { PORTNOTE("other","GRenderBitmap::UseGreyscaleContextDangerous - removed progress reporting") #if !defined(EXCLUDE_FROM_XARALX) Progress::Start(); #endif // Create a new context the first time anyone actually wants one pGreyscaleContext = new GDrawAsm; if (pGreyscaleContext != NULL) { // pGreyscaleContext->Init(); // And initialise the palette - this can unfortunately take a couple of seconds DWORD PaletteFlag = 0; if (WhichDither == 0 || WhichDither == 3) PaletteFlag = 1; if (pGreyscaleContext->SelectPalette(PaletteFlag) != NULL) pGreyscaleContext->InitialiseWithPalette(pConvPalette); } #if !defined(EXCLUDE_FROM_XARALX) Progress::Stop(); #endif } if (pGreyscaleContext != NULL) { pPreviousGDrawContext = SetTempDrawContext(pGreyscaleContext); } } }

---

Member Data Documentation

UINT32 GRenderBitmap::DitherType [protected]

Definition at line 198 of file grndbmp.h.

LPBYTE GRenderBitmap::lpOutputBits [protected]

Definition at line 206 of file grndbmp.h.

LPBITMAPINFO GRenderBitmap::lpOutputInfo [protected]

Definition at line 205 of file grndbmp.h.

double GRenderBitmap::m_dXCentralAdjust [protected]

Definition at line 216 of file grndbmp.h.

double GRenderBitmap::m_dYCentralAdjust [protected]

Definition at line 217 of file grndbmp.h.

BOOL GRenderBitmap::OverlapBands [protected]

Definition at line 193 of file grndbmp.h.

LPLOGPALETTE GRenderBitmap::pConvPalette [protected]

Definition at line 202 of file grndbmp.h.

GDrawContext * GRenderBitmap::pGreyscaleContext = NULL [static, private]

Definition at line 180 of file grndbmp.h.

GDrawContext* GRenderBitmap::pPreviousGDrawContext [private]

Definition at line 178 of file grndbmp.h.

BOOL GRenderBitmap::RenderBottomToTop [protected]

Definition at line 194 of file grndbmp.h.

UINT32 GRenderBitmap::uOutputDepth [protected]

Definition at line 199 of file grndbmp.h.

---

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

• wxOil/grndbmp.h (r1785/r1282)
• wxOil/grndbmp.cpp (r1785/r1282)

---