BfxALU Class Reference

Arithmetic and logic unit for bitmap effects. More...

#include <bfxalu.h>

Inheritance diagram for BfxALU:

List of all members.

Public Member Functions
	BfxALU ()
	Default constructor for ALU.
virtual	~BfxALU ()
	Default constructor for ALU.
virtual BOOL	Init ()
	Initialises the bitmap effect subsystem.
virtual BOOL	DeInit ()
	Initialises the bitmap effect subsystem.
virtual KernelBitmap *	NewBitmap (KernelBitmap *pBitmap, INT32 XAdjust=0, INT32 YAdjust=0, INT32 NewDepth=0, String_256 *pName=NULL, UINT32 ResID=0)
	General purpose call to claim a new kernel bitmap.
virtual BOOL	SetA (KernelBitmap *pBitmap=NULL)
	GDraw needs a bitmap to plot to & from, this is the accumulator.
virtual BOOL	SetB (KernelBitmap *pBitmap=NULL, INT32 XOffset=0, INT32 YOffset=0, const BYTE *pTable=NULL, DWORD Style=0)
	GDraw needs a bitmap to plot to & from, this is the accumulator.
virtual BOOL	SetB (DWORD Colour)
	GDraw needs a bitmap to plot to & from, this is the accumulator.
virtual BOOL	SetT (KernelBitmap *pBitmap=NULL, INT32 XOffset=0, INT32 YOffset=0, const BYTE *pTable=NULL, DWORD Style=0)
	GDraw needs a bitmap to plot to & from, this is the accumulator.
virtual BOOL	SetT (DWORD Value)
	GDraw needs a bitmap to plot to & from, this is the accumulator.
virtual BOOL	PlotB ()
	This routine sets up GDraw for A & B, and calls DoRect().
virtual BOOL	PlotBLUT (BfxALULUT *LUT)
	This routine sets up GDraw for A & B, and calls DoRect().
virtual BOOL	PartTAB ()
	Arithemtic operation to do the above.
virtual BOOL	PartMulTAB ()
	Arithemtic operation to do the above.
virtual BOOL	PartRevMulTAB ()
	Arithemtic operation to do the above.
virtual BOOL	AddTAB ()
	Arithemtic operation to do the above.
virtual BOOL	SubTAB ()
	Arithemtic operation to do the above.
virtual BOOL	PartKAB (DWORD Value)
	Arithemtic operation to do the above.
virtual BOOL	PartMulKAB (DWORD Value)
	Arithemtic operation to do the above.
virtual BOOL	PartRevMulKAB (DWORD Value)
	Arithemtic operation to do the above.
virtual BOOL	AddKAB (DWORD Value)
	Arithemtic operation to do the above.
virtual BOOL	SubKAB (DWORD Value)
	Arithemtic operation to do the above.
virtual BOOL	MarkThresholdError (INT32 Value, DWORD MarkValue, DWORD ClearValue)
	Arithemtic operation to do the above.
virtual BOOL	MarkColourThresholdError (INT32 Value, DWORD Colour, DWORD MarkValue, DWORD ClearValue, double *pAError, double *pBError, INT32 *pTotalPixels, INT32 *pMarkedPixels)
	Arithemtic operation to do the above.
virtual BOOL	MarkPositive (INT32 Value, DWORD MarkValue, DWORD ClearValue, double *pAError=NULL, double *pBError=NULL, INT32 *pTotalPixels=NULL, INT32 *pMarkedPixels=NULL)
	Arithemtic operation to do the above.
virtual BOOL	MarkLargestArea (DWORD MarkValue, DWORD ClearValue, DWORD RegionValue, BOOL *FoundRegion, INT32 *InitialX, INT32 *InitialY, INT32 *Area)
	Arithemtic operation to do the above.
virtual BOOL	MarkGivenArea (DWORD MarkValue, DWORD ClearValue, DWORD RegionValue, BOOL *FoundRegion, INT32 *InitialX, INT32 *InitialY, INT32 *Area)
	Arithemtic operation to do the above.
virtual BOOL	GradFillPath (Path *ThePath, DWORD StartColour, DWORD EndColour, INT32 StartX, INT32 StartY, INT32 EndX, INT32 EndY, BOOL AntiAlias=FALSE, BOOL ColoursAreDWORDs=FALSE)
	Calls GDraw to fill a path.
virtual BOOL	GetStatistics (Path *ThePath, KernelStatistics *pStats)
	Calls GDraw to statistically analyse the contents of a path.
virtual BOOL	MarkBitByWord (DWORD BitMask, DWORD TheWord)
	Arithemtic operation to do the above.
virtual BOOL	ClearBitByWord (DWORD BitMask, DWORD TheWord)
	Arithemtic operation to do the above.
virtual BOOL	MarkWordByBit (DWORD BitMask, DWORD MarkValue, DWORD ClearValue)
	Arithemtic operation to do the above.
virtual BOOL	BuildErrorRegionList (DWORD MarkValue, DWORD ClearValue, DWORD RegionValue, BfxErrorRegionList *pERL, INT32 MinimumArea)
	Arithemtic operation to do the above.
virtual BOOL	ScanBit (DWORD BitMask, INT32 *X, INT32 *Y, INT32 *pPixel, BOOL *Found, BOOL CheckConnected=FALSE)
	Arithemtic operation to search A for the next pixel s.t. (A & BitMask) !=0.
virtual BOOL	ScanThreshold (INT32 Value, INT32 *X, INT32 *Y, INT32 *pPixel, BOOL *Found, BOOL CheckConnected=FALSE)
	Arithemtic operation to search A for the next pixel s.t. (A & BitMask) !=0.
virtual BOOL	GetSize (KernelBitmap *pBitmap, INT32 *pXSize=NULL, INT32 *pYSize=NULL, INT32 *pDepth=NULL)
	Convenient place to overcome the inadequacies of the KernelBitmapClass.
virtual BOOL	ZeroA (DWORD FillValue=0)
	Zeros the accumulator.
virtual BOOL	ByteCopyBA ()
	Copies B into the accumulator.
virtual void	TestGD ()
virtual BOOL	FlipX (KernelBitmap **ppOutput)
	A new bitmap is created which is the flipped version of the accumulator.
virtual BOOL	FlipY (KernelBitmap **ppOutput)
	A new bitmap is created which is the flipped version of the accumulator.
virtual BOOL	Rotate90 (KernelBitmap **ppOutput)
	A new bitmap is created which is the flipped version of the accumulator.
virtual BOOL	Rotate180 (KernelBitmap **ppOutput)
	A new bitmap is created which is the flipped version of the accumulator.
virtual BOOL	Rotate270 (KernelBitmap **ppOutput)
	A new bitmap is created which is the flipped version of the accumulator.
virtual BOOL	Resize (KernelBitmap **ppOutput, INT32 Width, INT32 Height, BOOL LinearInterpolation)
	A new bitmap is created as per function name.
virtual BOOL	BrightnessContrast (KernelBitmap **ppOutput, INT32 Brightness=0, INT32 Contrast=0, INT32 Colour=0)
	A new bitmap is created as per function name.
virtual BOOL	BayerMono (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	HalftoneMono (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	DiffusionMono (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	BayerColour (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	DiffusionColour (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	PopularityColour (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	MakeGreyscale (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	MakeGreyscale32to8 (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	Octree (KernelBitmap **ppOutput)
	A new bitmap is created as per function name.
virtual BOOL	SharpenBlur (KernelBitmap **ppOutput, INT32 Degree, INT32 Times)
	A new bitmap is created as per function name.
virtual BOOL	RemoveDither (KernelBitmap **ppOutput, INT32 Thresh, INT32 QuantCols, TraceMethod Method)
virtual BOOL	SpecialEffect (KernelBitmap **ppOutput, double *Matrix, BfxSpecialEffect Type)
	A new bitmap is created as per function name.
Static Public Member Functions
static BOOL	IsGreyscaleBitmap (KernelBitmap *pKB)
	Determines whether or not a bitmap is 32bpp.
static BOOL	IsGreyscaleBitmap (OILBitmap *pOilBmp)
	Determines whether or not a bitmap is 32bpp.
Protected Member Functions
virtual BOOL	DoRect ()
	Calls GDraw to perform the desired ALU operation.
virtual BOOL	UseBT (DWORD TransparencyStyle=0)
	This routine sets up GDraw for A & B, and calls DoRect().
virtual BOOL	UseBK (DWORD TransparencyStyle, DWORD Value)
	This routine sets up GDraw for A & B, and calls DoRect().
virtual BOOL	MarkRegions (DWORD MarkValue, DWORD ClearValue, BOOL *FoundRegion, INT32 *InitialX, INT32 *InitialY, INT32 *Area, INT32 *pSize, INT32 *pHighestChain, INT32 *pWidth, DWORD **ppA)
virtual BOOL	MakeAccusoftHandle (INT32 *pHandle, BOOL DoBodge=FALSE)
	gets items from list A new accusoft bitmap handle is created for the B reg
virtual BOOL	MakeKernelBitmap (INT32 Handle, KernelBitmap **ppOutput, BOOL Make32Bits=FALSE, String_256 *pName=NULL, UINT32 ResID=0, BOOL DoBodge=FALSE)
	A new accusoft bitmap handle is created for the accumulator.
virtual BOOL	AdjustBrightnessContrastColour (LPBYTE Source, LPBYTE Dest, INT32 Size, INT32 Width, INT32 Height, INT32 Brightness, INT32 Contrast, INT32 Colour, BOOL SingleChannel)
	A new bitmap is created as per function name.
BOOL	MAH_BodgeCopyBitmap (INT32 Width, INT32 Height, INT32 Depth, LPBYTE pSourceBits, LPBYTE pDestBits)
	To copy the bitmap across to the destination but instead of doing a straight copy we copy it to a bitmap which is three times the width and to the middle section of this. We then pad the left hand side with the first left pixel. We then pad the right hand side with the right hand pixel. Assumes: Destination bitmap is three times the width of the source but is the same in all other aspects.
BOOL	MKB_BodgeCopyBitmap (INT32 Width, INT32 Height, INT32 Depth, LPBYTE pSourceBits, LPBYTE pDestBits)
	The reverse of the MAH_BodgeCopyBitmap version. This copies the bitmap across to the destination but instead of doing a straight copy we copy the middle section from the source bitmap which should be three times the width we want to the destination bitmap which should be a third of the width we want. Assumes: Source bitmap is three times the width of the destination but is the same in all other aspects.
void	ConvertScanLineToDWORD (KernelBitmap *pBitmap, INT32 Line, DWORD *pBuffer)
	Converts a scanline in the bitmap to a 32 bit scanline.
void	ConvertScanLineFromDWORD (KernelBitmap *pBitmap, INT32 Line, DWORD *pBuffer)
	Converts 32 bit scanline to a scanline in the bitmap.
void	SlowRemoveDither (BYTE *ByteLine[5], INT32 NoiseMatrix[5][5], BYTE *OutputLine, INT32 Width, INT32 Thresh, BOOL Mono)
	Removes dither (slowly).
Protected Attributes
KernelBitmap *	A
KernelBitmap *	B
KernelBitmap *	T
POINT	BPoints [3]
POINT	TPoints [3]
COLORREF	BColour
DWORD	TValue
const BYTE *	BpTable
const BYTE *	TpTable
DWORD	BStyle
DWORD	TStyle
GDrawContext *	GC
GMATRIX	identity
BOOL	ResetAccusoftDibsToRuns
Private Member Functions
	CC_DECLARE_DYNCREATE (BfxALU)

---

Detailed Description

Arithmetic and logic unit for bitmap effects.

Author:

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

Date:

12/10/1994

This class implements the Bitmap Effect ALU (Arithmetic and logic unit). You can think of this as the Kernel i/f for GDraw when using bitmap effects, but that would be a bit of a narrow view. The class is there to perform fast arithmetic and logical operations on bitmaps, and at the moment, we reckon the fastest way to do that is to use GDraw.

The ALU works very like a processor ALU, except each register holds a bitmap (actually a pointer to a bitmap which can cause some complications), and each operand (like Add) adds two bitmaps, rather than two integers. In fact, some registers may be set to 'pseudo bitmaps' like solid colour and linear fills, which are usefully expanded by the ALU at plot time without occupying memory.

The ALU has the following registers: Name Purpose ==== ======= A (Accumulator) The accumulator is the destination register for all operands, and is the source register for many. The accumulator can be 32 bit or 8 bpp grey but at the moment only 32 bpp is supported. The T channel of the accumulator is always zero (well, that's how the plot operations leave it anyway). B (Bitmap) A general purpose bitmap, normally used as a secondary source operand. T (Bitmap) And 8 bit bitmap used for weigthing values on some calls.

Here are some example arithmetic operands:

AddpAqB A <- pA+qB AddApB A <- A+pB SubApB A <- A-pB InvA A <- 255-A

Here are some example load & store operations

SetA(bitmap) SetB(bitmap) SetB(linear fill parameters)

Definition at line 265 of file bfxalu.h.

---

Constructor & Destructor Documentation

BfxALU::BfxALU (   )

Default constructor for ALU. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: None  [INPUTS] Constructs  object [OUTPUTS] Returns: Nothing Errors: None yet See also: - This constructs the ALU - most of the work is done in the Init function Definition at line 299 of file bfxalu.cpp. { #ifndef EXCLUDE_FROM_RALPH GC = NULL; ResetAccusoftDibsToRuns = FALSE; #endif }

BfxALU::~BfxALU (   )  [virtual]

Default constructor for ALU. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: None  [INPUTS] Constructs  object [OUTPUTS] Returns: Nothing Errors: Error3 if DeInit hasn't been called. See also: - This destructs the ALU - most of the work should be done in the Init function Definition at line 324 of file bfxalu.cpp. { #ifndef EXCLUDE_FROM_RALPH // has to be a level 3 check - we can't return an error code ERROR3IF( (GC!=NULL), "Someone hasn't called the BfxALU deinit function!"); #endif }

---

Member Function Documentation

BOOL BfxALU::AddKAB (  DWORD  Value  )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- A + Value.B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1270 of file bfxalu.cpp. { return UseBK(ALUC_ADD, Value); }

BOOL BfxALU::AddTAB (   )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- A + TB [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1165 of file bfxalu.cpp. { return UseBT(ALUC_ADD); }

BOOL BfxALU::AdjustBrightnessContrastColour (  LPBYTE  Source, LPBYTE  Dest, INT32  Size, INT32  Width, INT32  Height, INT32  Brightness, INT32  Contrast, INT32  Colour, BOOL  SingleChannel )  [protected, virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: Source  = pointer to source bytes [INPUTS] Size = size of entries Brightness, Contast, Colour (-127 to +127) SingleChannel set if just to do a .. urm ... single channel. Dest  bytes filled in [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 5205 of file bfxalu.cpp. { // We make a LUT which is Output = LUT[gun, sumofguns] double dBrightness = (Brightness*1.0)/127.0 *0.75; // *0.75 is the 'Charles' factor. double dContrast = pow(2.0,3.0*(Contrast*1.0)/127.0); double dColour = pow(2.0,3.0*(Colour*1.0)/127.0); // GunOut = dBrightness + dContrast * ((GunSum/3) + dColour * (GunIn- GunSum/3)) + (1-dContrast)*0.5; // = (dBrightness + ((1-dContrast)*0.5)) + GunSum * (dContrast/3.0 * (1-dColour)) + GunIn * (dContrast*dColour) double PropA = dContrast * dColour; double PropB = dContrast / 3.0 * (1.0-dColour); double Offset = dBrightness + (1.0-dContrast)*0.5; INT32 pa=(INT32)(PropA*(1<<15)); INT32 pb=(INT32)(PropB*(1<<15)); INT32 po=(INT32)(Offset*((1<<15)*255)+/* for rounding */(1<<14)); BYTE * Data = (BYTE *) CCMalloc(3*256*256); if (!Data) return FALSE; // error already set // Please note how we're *NOT* using doubles in the loop as that's // sooooo sloooooow on 486SX. We use 17.15 arithmetic throughout #ifndef FASTLINEARABK INT32 a; INT32 b; INT32 r; for (a=0; a<256; a++) for (b=0; b<256*3; b++) { r=(a*pa+b*pb+po)>>15; /* we did the rounding in the offset calc */ LUTBYTE(a,b)=(r<0)?0:((r>255)?255:(BYTE)(INT32)(r)); } #else FastLinearABK(Data, pa, pb, po, 256*3); #endif DWORD Sum; if (!SingleChannel) { for (INT32 y = 0 ;y<Height; y++) { for (INT32 x = 0; x<Width; x++) { Sum=((DWORD)Source[0])+((DWORD)Source[1])+((DWORD)Source[2]); Dest[0]=LUTBYTE(Source[0], Sum); Dest[1]=LUTBYTE(Source[1], Sum); Dest[2]=LUTBYTE(Source[2], Sum); Source+=Size; Dest+=Size; } Source = (LPBYTE)(void *)((((UINT_PTR)(void *)Source) +3)&(~3)); Dest = (LPBYTE)(void *)((((UINT_PTR)(void *)Dest) +3)&(~3)); } } else { for (INT32 y = 0 ;y<Height; y++) { for (INT32 x = 0; x<Width; x++) { *Dest=LUTBYTE((*Source), (*Source)); Source+=Size; Dest+=Size; } Source = (LPBYTE)(void *)((((UINT_PTR)(void *)Source) +3)&(~3)); Dest = (LPBYTE)(void *)((((UINT_PTR)(void *)Dest) +3)&(~3)); } } CCFree(Data); return TRUE; }

BOOL BfxALU::BayerColour (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 4019 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_bayer_color(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_BAYERCOLOUR)); }

BOOL BfxALU::BayerMono (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3877 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_bayer_mono(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } //AccusoftFilters::pfnIMG_runs_to_dib (AccusoftHandle); ResetAccusoftDibsToRuns = TRUE; return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_BAYERMONO)); }

BOOL BfxALU::BrightnessContrast (  KernelBitmap **  ppOutput, INT32  Brightness = 0, INT32  Contrast = 0, INT32  Colour = 0 )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: Brightness  & Contast (-127 to +127) [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3778 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); #if 0 INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; INT32 result = AccusoftFilters::pfnIMG_set_lut(AccusoftHandle, (INT32) Brightness, (INT32) Contrast); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_BRIGHTCONT)); #endif *ppOutput = NewBitmap(B,0,0,0,NULL, _R(IDS_BFX_BRIGHTCONT)); if (!ppOutput) return FALSE; BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)((*ppOutput)->ActualBitmap))->BMInfo->bmiHeader); DWORD PaletteUsed = pBBMI->biClrUsed; ERROR2IF ((pBBMI->biSizeImage == 0) || (pBBMI->biCompression != BI_RGB) || (pBBMI->biHeight<0), FALSE, "A naughty DIB format has been used internally"); pABMI->biXPelsPerMeter = pBBMI->biXPelsPerMeter; pABMI->biYPelsPerMeter = pBBMI->biYPelsPerMeter; ERROR2IF ((pBBMI->biSizeImage != pABMI->biSizeImage), FALSE, "BfxALU brightness & constrast size upset"); DWORD Width; DWORD Height; DWORD Size; LPBYTE Source; LPBYTE Dest; LPBYTE pSBits = (((CWxBitmap *)(B->ActualBitmap))->BMBytes); LPBYTE pDBits = (((CWxBitmap *)((*ppOutput)->ActualBitmap))->BMBytes); // We modify the image itself in the case of greyscale images BOOL SingleChannel=IsGreyscaleBitmap(B); // Handle wierd palette stuff if ((SingleChannel) || pBBMI->biBitCount>8) { if (SingleChannel && PaletteUsed) { // Copy the palette memcpy(((LPBYTE)(pABMI + 1/*ptr arith*/)) /*dest*/, ((LPBYTE)(pBBMI + 1/*ptr arith*/)) /*source*/, PaletteUsed * sizeof(DWORD)); } else { PaletteUsed = 0; } Width = pBBMI->biWidth; Height = pBBMI->biHeight; Size = (pBBMI->biBitCount / 8); Source = pSBits; Dest = pDBits; } else { // 0 is MS for maximum if (PaletteUsed == 0) PaletteUsed = 1<<pBBMI->biBitCount; Width = PaletteUsed; Height = 1; Size = 4; // This points to palette Source = ((LPBYTE)(pBBMI + 1/*ptr arith*/)); Dest = ((LPBYTE)(pABMI + 1/*ptr arith*/)); // Copy the image memcpy(pDBits /*dest*/, pSBits /*source*/, pBBMI->biSizeImage); } if (!AdjustBrightnessContrastColour(Source, Dest, Size, Width, Height, Brightness, Contrast, Colour, SingleChannel)) { delete *ppOutput; *ppOutput=NULL; return FALSE; } return TRUE; }

BOOL BfxALU::BuildErrorRegionList (  DWORD  MarkValue, DWORD  ClearValue, DWORD  RegionValue, BfxErrorRegionList *  pERL, INT32  MinimumArea )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: MarkValue  = the value marked pixel have [INPUTS] ClearValue = the value cleared pixels have pERL = error region list to alter MinimumArea = min area to consider A  = RegionValue if pixel is in region, otherwise a different number [OUTPUTS] ClearValue if pixel is not marked pERL altered Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::FindInitialPoint, BfxALU::MarkRegions, BfxALU::BuildErrorRegionList This is used by the tracer routines work out the area to mark. Definition at line 2014 of file bfxalu.cpp. { INT32 Pixel; INT32 Size; INT32 Width; DWORD * pA; BOOL FoundRegion=FALSE; ERROR2IF(!pERL, FALSE, "OK, Where's the error region list then?"); // Empty the region list if (!pERL->Empty()) return FALSE; // INT32 ListSize=pERL->GetSize(); // Most of our error checking done in MarkRegions if (!MarkRegions(MarkValue, ClearValue, &FoundRegion, NULL, NULL, NULL, &Size, NULL, &Width, &pA)) return FALSE; INT32 Area; if (FoundRegion) { Pixel = 0; do { #ifdef FASTBUILDERRORREGIONLIST FastBuildErrorRegionList(pA, Size, RegionValue, ClearValue, MinimumArea, &Pixel, &Area); #else do { if ((DWORD) (Area=(INT32)(pA[Pixel])) != ClearValue) pA[Pixel]=RegionValue; // We evilly use bit 30 to check for clearvalue } while ( (((DWORD)Area & 0xC0000000)!=0x80000000) && (Pixel++<Size)); #endif if (Pixel<Size) { if ((DWORD)(Area-0x80000000) >= (DWORD)MinimumArea) { // TRACEUSER( "Alex", _T("Found region at %d,%d Area %d\n"),Pixel % Width, Pixel / Width, Area-0x80000000); if (pERL->IsSpace()) pERL->Insert(Pixel % Width, Pixel / Width, Area-0x80000000); } } } while (Pixel<Size); } if (!pERL->IsSpace()) TRACEUSER( "Alex", _T("[[BuildErrorRegionList ran out of space]]\n")); return (pERL->Sort() && pERL->ResetRead()); }

BOOL BfxALU::ByteCopyBA (   )  [virtual]

Copies B into the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: None  [INPUTS] Accumulator  altered [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - The bitmaps must be identical in dimension and depth - this is a bytewise copy. Definition at line 2683 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount != pBBMI->biBitCount), FALSE,"Bad BfxALU A/B reg"); ERROR2IF( (pABMI->biSizeImage != pBBMI->biSizeImage), FALSE, "Incompatible bitmaps for ByteCopyBA()"); void * pA = (void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); void * pB = (void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); memcpy(pA, pB, pABMI->biSizeImage); return TRUE; }

BfxALU::CC_DECLARE_DYNCREATE (  BfxALU   )  [private]

BOOL BfxALU::ClearBitByWord (  DWORD  BitMask, DWORD  TheWord )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: TheWord  = value to look for to mark [INPUTS] A  &= ~BitMask if B=TheWord else intact [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: BfxALU::MarkWordByBit, TraceControl::FindInitialArea Definition at line 1633 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); ERROR2IF((pBBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (pABMI->biSizeImage != pBBMI->biSizeImage), FALSE, "Incompatible bitmaps for MarkBitByWord"); DWORD * pA = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); DWORD * pB = (DWORD *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Size = (pABMI->biSizeImage)>>2; #ifdef FASTCLEARBITBYWORD FastClearBitByWord(pB, pA, Size, BitMask, TheWord); #else for (INT32 Pixel = 0; Pixel < Size; Pixel ++) if (pB[Pixel]==TheWord) pA[Pixel]&=~BitMask; #endif return TRUE; }

void BfxALU::ConvertScanLineFromDWORD (  KernelBitmap *  pBitmap, INT32  Line, DWORD *  pBuffer )  [protected]

Converts 32 bit scanline to a scanline in the bitmap. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: pBitmap  pointer to bitmap [INPUTS] Line = line number pBuffer = buffer None  [OUTPUTS] Returns: None Errors: None Scope: Protected See also: - THIS FUNCTION HAS NO ERROR CHECKING. How does it smell? TERRIBLE (i.e. you are expected to do your own.). This is because it must be **FAST** Definition at line 5402 of file bfxalu.cpp. { return; }

void BfxALU::ConvertScanLineToDWORD (  KernelBitmap *  pBitmap, INT32  Line, DWORD *  pBuffer )  [protected]

Converts a scanline in the bitmap to a 32 bit scanline. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: pBitmap  pointer to bitmap [INPUTS] Line = line number pBuffer = buffer None  [OUTPUTS] Returns: None Errors: None Scope: Protected See also: - THIS FUNCTION HAS NO ERROR CHECKING. How does it smell? TERRIBLE (i.e. you are expected to do your own.). This is because it must be **FAST** Definition at line 5304 of file bfxalu.cpp. { BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiHeader); RGBQUAD * pPal=(((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiColors); void * VImage = (((CWxBitmap *)(pBitmap->ActualBitmap))->BMBytes); INT32 Width=pBMI->biWidth; switch (pBMI->biBitCount) { case 32: { DWORD * Source = &(((DWORD *) VImage)[Width*Line]); for (INT32 w=0; w<Width; w++) pBuffer[w]=Source[w] & 0x00ffffff; return; } break; // not really needed case 24: { BYTE * Source = &(((BYTE *) VImage)[(((Width*3)+3)&~3)*Line]); INT32 b=0; for (INT32 w=0; w<Width; w++) { pBuffer[w]=(((INT32)(Source[b])))|(((INT32)(Source[b+1]))<<8)|(((INT32)(Source[b+2]))<<16); b+=3; // Grrr MS bug prevents us from doing this efficiently } return; } break; // not really needed case 8: { BYTE * Source = &(((BYTE *) VImage)[((Width+3)&~3)*Line]); for (INT32 w=0; w<Width; w++) { pBuffer[w]=0x00ffffff & *((DWORD *)(&pPal[Source[w]])); } return; } break; // not really needed case 4: { BYTE * Source = &(((BYTE *) VImage)[(((Width+7)&~7)>>1)*Line]); for (INT32 w=0; w<Width; w++) { pBuffer[w]=0x00ffffff & *((DWORD *)(&pPal[ (Source[w>>1]>>( (1-(w&1)) <<2) )&0xf])); } return; } break; // not really needed case 2: { BYTE * Source = &(((BYTE *) VImage)[(((Width+15)&~15)>>2)*Line]); for (INT32 w=0; w<Width; w++) { pBuffer[w]=0x00ffffff & *((DWORD *)(&pPal[ (Source[w>>2]>>( (3-(w&3)) <<1) )&0x3])); } return; } break; // not really needed case 1: { BYTE * Source = &(((BYTE *) VImage)[(((Width+31)&~31)>>3)*Line]); for (INT32 w=0; w<Width; w++) { pBuffer[w]=0x00ffffff & *((DWORD *)(&pPal[ (Source[w>>3]>>( (7-(w&7)) /*<<0*/) )&0x1])); } return; } break; // not really needed default: { ERROR3("BPP not supported"); } break; // not really needed } return; // not really needed }

BOOL BfxALU::DeInit (  void   )  [virtual]

Initialises the bitmap effect subsystem. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] DeInitialises  subsystem [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: None from this one as yet See also: - This call's primary purposes is to deinitialise the BfxALU, releasing a GDraw context etc. Definition at line 400 of file bfxalu.cpp. { if (GC) { delete GC; GC=NULL; } return TRUE; }

BOOL BfxALU::DiffusionColour (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 4099 of file bfxalu.cpp. { //ERROR2(FALSE, "The Accusoft boys have chosen to make this function rampantly crash"); ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_diffusion_color(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_DIFFUSIONCOLOUR)); }

BOOL BfxALU::DiffusionMono (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3973 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_diffusion_mono(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } //AccusoftFilters::pfnIMG_runs_to_dib (AccusoftHandle); ResetAccusoftDibsToRuns = TRUE; return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_DIFFUSIONMONO)); }

BOOL BfxALU::DoRect (   )  [protected, virtual]

Calls GDraw to perform the desired ALU operation. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] Accumulator  altered [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - Definition at line 778 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); RECT Rect={/*L*/0,/*T*/pBMI->biHeight,/*R*/pBMI->biWidth,/*B*/0}; ERROR2IF((!GC->FillRectangle(&Rect)),FALSE,"BfxALU GDraw_FillRectangle failed"); #if 0 GC->SetColour((COLORREF) 0x0000FF00); GC->SetTransparency((COLORREF) 0x0000FF00,(enum TransparencyEnum) 0); RECT Rect2={/*L*/0+40,/*T*/pBMI->biHeight-40,/*R*/pBMI->biWidth-40,/*B*/0+40}; ERROR2IF((!GC->FillRectangle(&Rect2)),FALSE,"BfxALU GDraw_FillRectangle failed"); #endif return(TRUE); }

BOOL BfxALU::FlipX (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created which is the flipped version of the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3618 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; INT32 result = AccusoftFilters::pfnIMG_flip_bitmapx(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_FLIPX)); }

BOOL BfxALU::FlipY (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created which is the flipped version of the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3650 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; INT32 result = AccusoftFilters::pfnIMG_flip_bitmapy(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_FLIPY)); }

BOOL BfxALU::GetSize (  KernelBitmap *  pBitmap, INT32 *  pXSize = NULL, INT32 *  pYSize = NULL, INT32 *  pDepth = NULL )  [virtual]

Convenient place to overcome the inadequacies of the KernelBitmapClass. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 26/01/95 Parameters: pBitmap  [INPUTS] pXSize  (if non NULL) contains X size, [OUTPUTS] pYSize (if non NULL) contains Y size, pDepth (if non NULL) contains Depth , Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - The non NULL pointers are filled in with the appropriate items Definition at line 2649 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!pBitmap) || (pBitmap->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(pBitmap->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiHeader); if (pXSize) *pXSize=(INT32)(pABMI->biWidth); if (pYSize) *pYSize=(INT32)(pABMI->biHeight); if (pDepth) *pDepth=(INT32)(pABMI->biBitCount); return TRUE; }

BOOL BfxALU::GetStatistics (  Path *  ThePath, KernelStatistics *  pStats )  [virtual]

Calls GDraw to statistically analyse the contents of a path. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 26/01/95 Parameters: ThePath  = the path to do [INPUTS] pStats  filled in [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - NOTE! The coordinates passed to this routine, both in the parh and as the grad fill end points, are all 24.8 values (secretly), i.e. StartX=256 plots from pixel 1. Definition at line 2546 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); GMATRIX pathmatrix; pathmatrix.AX=pathmatrix.BY=1<<(FX+8);pathmatrix.CX=pathmatrix.CY=pathmatrix.AY=pathmatrix.BX=0; ERROR2IF((!GC->SetMatrix(&pathmatrix)), FALSE, "GDraw couldn't set path matrix"); GC->SetFlatness(128); // 128 is half a pixel. This is a void fn; grrr... STATISTICS Stats; BOOL Success = GC->GetStatistics( (POINT*)ThePath->GetCoordArray(), ThePath->GetVerbArray(), ThePath->GetNumCoords(), 0, &Stats); ERROR2IF((!GC->SetMatrix(&identity)), FALSE, "GDraw couldn't restore BfxALU Matrix"); ERROR2IF((!Success), FALSE, "GDraw couldn't fill BfxALU path"); pStats->N = Stats.N; double N = (double) Stats.N; if (N==0) N=1; #if 1 pStats->R = ((Stats.R )*1.0)/(N*255.0); pStats->R2= ((Stats.R2)*1.0)/(N*255.0*255.0); pStats->RX= ((Stats.RX)*1.0)/(N*255.0); pStats->RY= ((Stats.RY)*1.0)/(N*255.0); pStats->G = ((Stats.G )*1.0)/(N*255.0); pStats->G2= ((Stats.G2)*1.0)/(N*255.0*255.0); pStats->GX= ((Stats.GX)*1.0)/(N*255.0); pStats->GY= ((Stats.GY)*1.0)/(N*255.0); pStats->B = ((Stats.B )*1.0)/(N*255.0); pStats->B2= ((Stats.B2)*1.0)/(N*255.0*255.0); pStats->BX= ((Stats.BX)*1.0)/(N*255.0); pStats->BY= ((Stats.BY)*1.0)/(N*255.0); pStats->X = ((Stats.X )*1.0)/(N*255.0); pStats->Y = ((Stats.Y )*1.0)/(N*255.0); pStats->X2= ((Stats.X2)*1.0)/(N*255.0); pStats->Y2= ((Stats.Y2)*1.0)/(N*255.0); pStats->XY= ((Stats.XY)*1.0)/(N*255.0); // pStats->Pixel = (DWORD)(Stats.C); #else pStats->R = ((Stats.R ).MakeDouble())/(N*255.0); pStats->R2= ((Stats.R2).MakeDouble())/(N*255.0*255.0); pStats->RX= ((Stats.RX).MakeDouble())/(N*255.0); pStats->RY= ((Stats.RY).MakeDouble())/(N*255.0); pStats->G = ((Stats.G ).MakeDouble())/(N*255.0); pStats->G2= ((Stats.G2).MakeDouble())/(N*255.0*255.0); pStats->GX= ((Stats.GX).MakeDouble())/(N*255.0); pStats->GY= ((Stats.GY).MakeDouble())/(N*255.0); pStats->B = ((Stats.B ).MakeDouble())/(N*255.0); pStats->B2= ((Stats.B2).MakeDouble())/(N*255.0*255.0); pStats->BX= ((Stats.BX).MakeDouble())/(N*255.0); pStats->BY= ((Stats.BY).MakeDouble())/(N*255.0); pStats->X = ((Stats.X ).MakeDouble())/(N*255.0); pStats->Y = ((Stats.Y ).MakeDouble())/(N*255.0); pStats->X2= ((Stats.X2).MakeDouble())/(N*255.0); pStats->Y2= ((Stats.Y2).MakeDouble())/(N*255.0); pStats->XY= ((Stats.XY).MakeDouble())/(N*255.0); #endif INT32 Width = pBMI->biWidth; pStats->LowX = -1; pStats->LowY = -1; pStats->Pixel = (DWORD)(-1); if (Stats.C>0) { UINT32 Offset = ((UINT_PTR)(Stats.C))-((UINT_PTR)((((CWxBitmap *)(A->ActualBitmap))->BMBytes))); if (Offset<(UINT32)pBMI->biSizeImage) { pStats->LowX = (Offset>>2) % Width; pStats->LowY = (Offset>>2) / Width; DWORD pval = *((DWORD *)(Stats.C)); pStats->Pixel = (pval & 0x00FF00) | ((pval >> 16) & 0xFF) | ((pval << 16) & 0xFF0000); } } return(TRUE); }

BOOL BfxALU::GradFillPath (  Path *  ThePath, DWORD  StartColour, DWORD  EndColour, INT32  StartX, INT32  StartY, INT32  EndX, INT32  EndY, BOOL  AntiAlias = FALSE, BOOL  ColoursAreDWORDs = FALSE )  [virtual]

Calls GDraw to fill a path. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 26/01/95 Parameters: ThePath  = pointer to path to plot or NULL for whole thing [INPUTS] StartColour = COLORREF of start col EndColour = COLORREF of end colour {Start,End}{x,y} = coords of grad fill AntiAlias = TRUE for antialiasing ColoursAreDWORDS = TRUE to treat the colours as memory values to be replicated rather than disguised COLORREFs Accumulator  altered [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - The path is rendered grad filled into the accumulator NOTE! The coordinates passed to this routine, both in the parh and as the grad fill end points, are all 24.8 values (secretly), i.e. StartX=256 plots from pixel 1. Definition at line 2441 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); DWORD Style=0; GraduationTable Table; Table.Length = 0x100; // set up small one if (StartColour != EndColour) { ERROR2IF(ColoursAreDWORDs, FALSE, "Grad fill DWORD colours not yet supported"); ERROR2IF((!GC->BuildGraduationTable( (COLORREF) StartColour, (COLORREF) EndColour, FALSE, &Table)), FALSE, "GDraw couldn't build grad fill table for BfxALU"); // convert ArtWorks style attribute into Gavin-style POINT A,B,C; A.x = StartX; A.y = StartY; C.x = EndX; C.y = EndY; B.x = A.x + (C.y-A.y); // make 3 points into a rotated square B.y = A.y - (C.x-A.x); ERROR2IF((!GC->SetGraduation( Style, &Table, &A, &B, &C )), FALSE, "GDraw couldn't set BfxALU graduation"); } else { if (ColoursAreDWORDs) { DWORD DupColour=StartColour; switch(pBMI->biBitCount) { case 32: DupColour=StartColour; break; case 16: DupColour=(StartColour & 0xFFFF); DupColour|=DupColour<<16; break; case 8: DupColour=(StartColour & 0xFF); DupColour|=DupColour<<8; DupColour|=DupColour<<16; break; case 4: DupColour=(StartColour & 0xF); DupColour|=DupColour<<4; DupColour|=DupColour<<8; DupColour|=DupColour<<16; break; case 2: DupColour=(StartColour & 0x3); DupColour|=DupColour<<2; DupColour|=DupColour<<4; DupColour|=DupColour<<8; DupColour|=DupColour<<16; break; case 1: DupColour=(StartColour & 0x1); DupColour|=DupColour<<1; DupColour|=DupColour<<2; DupColour|=DupColour<<4; DupColour|=DupColour<<8; DupColour|=DupColour<<16; break; default: { ERROR2(FALSE, "Corrupt biBitCount in BfxALU::GradFillPath"); break; } } ERROR2IF((!GC->SetWordColour(DupColour )), FALSE, "GDraw couldn't set BfxALU word colour"); } else { ERROR2IF((!GC->SetColour( (COLORREF) StartColour )), FALSE, "GDraw couldn't set BfxALU colour"); } } GMATRIX pathmatrix; pathmatrix.AX=pathmatrix.BY=1<<(FX+8);pathmatrix.CX=pathmatrix.CY=pathmatrix.AY=pathmatrix.BX=0; ERROR2IF((!GC->SetMatrix(&pathmatrix)), FALSE, "GDraw couldn't set path matrix"); GC->SetAntialiasFlag(AntiAlias); // Grrr void GC->SetFlatness(AntiAlias?32:128); // 128 is half a pixel. This is a void fn; grrr... BOOL Success; if (ThePath) { Success = GC->FillPath( (POINT*)ThePath->GetCoordArray(), ThePath->GetVerbArray(), ThePath->GetNumCoords(), 0); } else { RECT Rect={/*L*/0,/*T*/(pBMI->biHeight)<<8,/*R*/(pBMI->biWidth)<<8,/*B*/0}; Success = GC->FillRectangle(&Rect); } GC->SetAntialiasFlag(FALSE); // Grrr void ERROR2IF(!(GC->SetMatrix(&identity)), FALSE, "GDraw couldn't restore BfxALU Matrix"); ERROR2IF((!Success), FALSE, "GDraw couldn't fill BfxALU path"); return(TRUE); }

BOOL BfxALU::HalftoneMono (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3921 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_halftone_mono(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } // we MUST now call this function BEFORE we create a new bitmap from the data! // see the extfilts.h file for why this is necessary! //AccusoftFilters::pfnIMG_runs_to_dib (AccusoftHandle); ResetAccusoftDibsToRuns = TRUE; // DEBUG CODE - PUT THIS LINE BACK IN IF YOU ARE WONDERING WHAT THE HEEL IS GOING ON! //AccusoftFilters::pfnIMG_display_bitmap (AccusoftHandle, GetDC (GetActiveWindow ()), 100, 0, // 100,300); return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_HALFTONEMONO)); }

BOOL BfxALU::Init (  void   )  [virtual]

Initialises the bitmap effect subsystem. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] Initialises  subsystem [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Level 2 if out of memory (this isn't a resource problem as we can't start camelot if this fails...) See also: - This call's primary purposes is to initialise the BfxALU, claiming a GDraw context etc. Reimplemented from SimpleCCObject. Definition at line 352 of file bfxalu.cpp. { GC = new GDrawAsm; ERROR2IF((GC==NULL),FALSE,"Couldn't get a GDrawContext for the BfxALU"); if (!GC->Init()) { GC=NULL; ERROR2(FALSE,"Couldn't initialise GDrawContext for the BfxALU"); } identity.AX=identity.BY=1<<(FX+16);identity.CX=identity.CY=identity.AY=identity.BX=0; GC->SetupBitmap(256,256,32,NULL,TRUE); GC->SetMatrix(&identity); GC->SetAntialiasFlag(FALSE); GC->SelectPalette(0); GC->SetHalftoneOrigin(0,0); return TRUE; }

BOOL BfxALU::IsGreyscaleBitmap (  OILBitmap *  pOilBmp  )  [static]

Determines whether or not a bitmap is 32bpp. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: pKB  the bitmap to operate on [INPUTS] None  [OUTPUTS] Returns: TRUE if a 8bit GS bitmap else FALSE Errors: None Scope: Public See also: BfxALU::MakeGreyscale, BFXALU::MakeGreyscale32to8 This routine returns false if the bitmap is not a correctly formed 8 bpp bitmap. It does not return or set errors Definition at line 4278 of file bfxalu.cpp. { if ( (!pOilBmp) || (!pOilBmp->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap))) ) return FALSE; BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)pOilBmp)->BMInfo->bmiHeader); if ((pBMI->biBitCount!=8) || (pBMI->biClrUsed!=0x100)) return FALSE; DWORD * pPal = (DWORD *)(void *)(pBMI +1 /*ptr arith*/); for (DWORD x=0; x<0x100; x++) if ((pPal[x]&0x00ffffff) != (x|(x<<8)|(x<<16))) return FALSE; return TRUE; }

BOOL BfxALU::IsGreyscaleBitmap (  KernelBitmap *  pKB  )  [static]

Determines whether or not a bitmap is 32bpp. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: pKB  the bitmap to operate on [INPUTS] None  [OUTPUTS] Returns: TRUE if a 8bit GS bitmap else FALSE Errors: None Scope: Public See also: BfxALU::MakeGreyscale, BFXALU::MakeGreyscale32to8 This routine returns false if the bitmap is not a correctly formed 8 bpp bitmap. It does not return or set errors Definition at line 4251 of file bfxalu.cpp. { if ( (!pKB) || (!pKB->ActualBitmap) ) return FALSE; return IsGreyscaleBitmap(pKB->ActualBitmap); }

BOOL BfxALU::MAH_BodgeCopyBitmap (  INT32  Width, INT32  Height, INT32  Depth, LPBYTE  pSourceBits, LPBYTE  pDestBits )  [protected]

To copy the bitmap across to the destination but instead of doing a straight copy we copy it to a bitmap which is three times the width and to the middle section of this. We then pad the left hand side with the first left pixel. We then pad the right hand side with the right hand pixel. Assumes: Destination bitmap is three times the width of the source but is the same in all other aspects. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 20/09/96 Parameters: Width  - Width of bitmap [INPUTS] Height - Height of bitmap Depth - ColourDepth of bitmap pSourceBits - source data to use pDestBits - destination for the data None  [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not See also: MakeAccusoftHandle; Definition at line 3131 of file bfxalu.cpp. { #ifdef BODGE_ACCUSOFT_RESIZE UINT32 SourceScanline = DIBUtil::ScanlineSize(Width, Depth); UINT32 DestScanline = 1; if (Depth == 32) DestScanline = DIBUtil::ScanlineSize(Width * 3, 24); else DestScanline = DIBUtil::ScanlineSize(Width * 3, Depth); // We need to do it the hard way and copy it by hand // Repeat the first pixel in the extra bodged pixels on the left hand side // Copy the source bitmap to the centre section // Repeat the last pixel in the extra bodged pixels on the right hand side INT32 Bytes = 1; switch (Depth) { case 4: { // 2 pixels per byte // 4bpp so we must put the data into either the high or low nibble. // This will be dependent on whether we are on an odd or even pixel. // So test the LSBit of the current x, if set we will be odd. // Only move onto next byte every other pixel hence current x/2. Bytes = Width; for (INT32 i = 0; i < Height; i++ ) { // Probably not the most efficient way to copy the data but it is PROVEN! BYTE * pDBits = pDestBits; // Duplicate the left hand pixel into the first third BYTE LeftHandByte = ((*pSourceBits) & 0xF0) >> 4; for (INT32 j = 0; j < Width; j++ ) { LPBYTE pData = pDBits + j/2; if (j & 1) *(pData) = ((*(pData)) & 0xF0) | (LeftHandByte & 0x0F); // add into low nibble else *(pData) = ((*(pData)) & 0x0F) | ((LeftHandByte << 4) & 0xF0); // add into top nibble } BYTE Byte = 0; INT32 k = 0; for (; j < (2 * Width); j++ ) { // Get the source pixel LPBYTE pSourceData = pSourceBits + k/2; if (k & 1) Byte = ((*(pSourceData)) & 0x0F); // get low nibble else Byte = ((*(pSourceData)) & 0xF0) >> 4; // get top nibble // Put it in the correct destination pixel LPBYTE pData = pDBits + j/2; if (j & 1) *(pData) = ((*(pData)) & 0xF0) | (Byte & 0x0F); // add into low nibble else *(pData) = ((*(pData)) & 0x0F) | ((Byte << 4) & 0xF0); // add into top nibble k ++; } // Duplicate the right hand pixel for the last third LPBYTE pData = pDBits + Width/2; BYTE RightHandByte = 0; if (Width & 1) RightHandByte = ((*(pData)) & 0x0F); // get low nibble else RightHandByte = ((*(pData)) & 0xF0) >> 4; // get top nibble for (; j < (3 * Width); j++ ) { // Probably not the most efficient way but it is PROVEN! LPBYTE pData = pDBits + j/2; if (j & 1) { *(pData) = ((*(pData)) & 0xF0) | (RightHandByte & 0x0F); // add into low nibble } else *(pData) = ((*(pData)) & 0x0F) | ((RightHandByte << 4) & 0xF0); // add into top nibble } pDestBits += DestScanline; pSourceBits += SourceScanline; } break; } case 8: { // 1 byte per pixel Bytes = Width; for (INT32 i = 0; i < Height; i++ ) { BYTE * pDBits = pDestBits; // Duplicate the left hand pixel into the first third BYTE LeftHandByte = *pSourceBits; memset(pDBits, LeftHandByte, Bytes ); pDBits += Bytes; // Copy the main centre section memcpy(pDBits /*dest*/, pSourceBits, Bytes); pDBits += Bytes; // Duplicate the right hand pixel for the last third BYTE RightHandByte = *(pSourceBits + Bytes - 1); memset(pDBits, RightHandByte, Bytes ); pDestBits += DestScanline; pSourceBits += SourceScanline; } break; } case 32: case 24: { // 3 bytes per pixel Bytes = 3 * Width; BYTE LeftHandByte_R = 0; BYTE RightHandByte_R = 0; BYTE LeftHandByte_G = 0; BYTE RightHandByte_G = 0; BYTE LeftHandByte_B = 0; BYTE RightHandByte_B = 0; for (INT32 i = 0; i < Height; i++ ) { BYTE * pDBits = pDestBits; // Duplicate the left hand pixel into the first third LeftHandByte_R = *pSourceBits; LeftHandByte_G = *(pSourceBits + 1); LeftHandByte_B = *(pSourceBits + 2); for (INT32 j = 0; j < Width; j++ ) { *pDBits = LeftHandByte_R; pDBits ++; *pDBits = LeftHandByte_G; pDBits ++; *pDBits = LeftHandByte_B; pDBits ++; } // Copy the main centre section if (Depth != 32) { memcpy(pDBits /*dest*/, pSourceBits, Bytes); pDBits += Bytes; } else { LPBYTE pSBits = pSourceBits; for (INT32 j = 0; j < Width; j++ ) { *(pDBits) = *(pSBits); *(pDBits + 1) = *(pSBits + 1); *(pDBits + 2) = *(pSBits + 2); pDBits += 3; pSBits += 4; } } // Duplicate the right hand pixel for the last third if (Depth != 32) { RightHandByte_R = *(pSourceBits + Bytes - 3); RightHandByte_G = *(pSourceBits + Bytes - 2); RightHandByte_B = *(pSourceBits + Bytes - 1); } else { RightHandByte_R = *(pSourceBits + Bytes - 4); RightHandByte_G = *(pSourceBits + Bytes - 3); RightHandByte_B = *(pSourceBits + Bytes - 2); } for (j = 0; j < Width; j++ ) { *pDBits = RightHandByte_R; pDBits ++; *pDBits = RightHandByte_G; pDBits ++; *pDBits = RightHandByte_B; pDBits ++; } pDestBits += DestScanline; pSourceBits += SourceScanline; } break; } default: ERROR2(FALSE,"Bad colour depth when bodge copying"); } #endif return TRUE; }

BOOL BfxALU::MakeAccusoftHandle (  INT32 *  pHandle, BOOL  DoBodge = FALSE )  [protected, virtual]

gets items from list A new accusoft bitmap handle is created for the B reg Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: DoBodge  - tries to get round a bug in the Accusoft linear interpolation resize code [INPUTS] *pHandle  = Accusoft handle [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - This actually copies the bitmap. Note we'll have to fudge 32bit bmps somehow Definition at line 2960 of file bfxalu.cpp. { ERROR1IF((!(AccusoftFilters::pfnIMG_create_handle_keep)), FALSE, _R(IDN_FILTERNOTPRESENT)); ERROR2IF((!pHandle ),FALSE, "BfxALU handle parameter must be non-null"); ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); DWORD PaletteUsed = pBBMI->biClrUsed; ERROR2IF ((pBBMI->biSizeImage == 0) || (pBBMI->biCompression != BI_RGB) || (pBBMI->biHeight<0), FALSE, "A naughty DIB format has been used internally"); // Handle wierd palette stuff if (pBBMI->biBitCount > 8) { PaletteUsed = 0; } else { // 0 is MS for maximum //Mark Howitt, 31/10/97. Set the PaletteUsed to the Bpp to ensure Accusoft filters don`t crash when using less // than the maximum number of colours for any given Bpp. ERROR3IF(pBBMI->biBitCount==0,"There`s no depth to this picture! Cannot set Palette Used!"); switch(pBBMI->biBitCount) { case 1: PaletteUsed = 2; //Why bother? Just in case! break; case 2: PaletteUsed = 4; break; case 4: PaletteUsed = 16; break; case 8: PaletteUsed = 256; break; default: break; } } INT32 SizeImage = pBBMI->biSizeImage; INT32 Depth = 0; if (pBBMI->biBitCount == 32) Depth = 24; else Depth = pBBMI->biBitCount; #ifdef BODGE_ACCUSOFT_RESIZE if (DoBodge) { // Add some extra bodge pixels on the left hand side if (pBBMI->biBitCount == 32) SizeImage = DIBUtil::ScanlineSize(3 * pBBMI->biWidth, 24) * pBBMI->biHeight; else SizeImage = DIBUtil::ScanlineSize(3 * pBBMI->biWidth, Depth) * pBBMI->biHeight; } else if (pBBMI->biBitCount == 32) { UINT32 ScanLineSize = DIBUtil::ScanlineSize(pBBMI->biWidth, 24); SizeImage = ScanLineSize * pBBMI->biHeight; } #else if (pBBMI->biBitCount == 32) { UINT32 ScanLineSize = DIBUtil::ScanlineSize(pBBMI->biWidth, 24); SizeImage = ScanLineSize * pBBMI->biHeight; } #endif HGLOBAL HMem = GlobalAlloc(GMEM_MOVEABLE, sizeof(BITMAPINFOHEADER) + (sizeof(DWORD)*PaletteUsed) + SizeImage); ERROR1IF(!HMem, FALSE, _R(IDS_OUT_OF_MEMORY)); LPBYTE Mem = (LPBYTE) (void *) GlobalLock(HMem); ERROR1IF(!Mem, FALSE, _R(IDS_OUT_OF_MEMORY)); // wierd - we've only just got it! BITMAPINFOHEADER * pCBMI = (BITMAPINFOHEADER *) Mem; LPBYTE pPal = Mem + sizeof(BITMAPINFOHEADER); LPBYTE pBits = pPal + (sizeof(DWORD)*PaletteUsed); pCBMI->biSize = pBBMI->biSize; if (DoBodge) pCBMI->biWidth = pBBMI->biWidth * 3; else pCBMI->biWidth = pBBMI->biWidth; pCBMI->biHeight = pBBMI->biHeight; pCBMI->biPlanes = 1; pCBMI->biBitCount = (pBBMI->biBitCount != 32) ? (pBBMI->biBitCount) : 24; pCBMI->biCompression = BI_RGB; pCBMI->biSizeImage = SizeImage; pCBMI->biXPelsPerMeter = pBBMI->biXPelsPerMeter; pCBMI->biYPelsPerMeter = pBBMI->biYPelsPerMeter; if (PaletteUsed) { pCBMI->biClrUsed = PaletteUsed; pCBMI->biClrImportant = /*pBBMI->biClrImportant;*/PaletteUsed; } else { pCBMI->biClrUsed = 0; pCBMI->biClrImportant = 0; } // Copy the palette across if (PaletteUsed) memcpy(pPal /*dest*/, ((LPBYTE)(pBBMI)) + sizeof(BITMAPINFOHEADER), sizeof(DWORD) * PaletteUsed); #ifdef BODGE_ACCUSOFT_RESIZE // Copy the main bitmap data across if (DoBodge) { LPBYTE pSourceBits = ((CWxBitmap *)(B->ActualBitmap))->BMBytes; if (!MAH_BodgeCopyBitmap(pBBMI->biWidth, pBBMI->biHeight, pBBMI->biBitCount, pSourceBits, pBits)) { GlobalUnlock(HMem); GlobalFree(HMem); return FALSE; } } else #endif { if (pBBMI->biBitCount != 32) { memcpy(pBits /*dest*/, ((CWxBitmap *)(B->ActualBitmap))->BMBytes, pBBMI->biSizeImage); } else { GC->ConvertBitmap(pBBMI, ((CWxBitmap *)(B->ActualBitmap))->BMBytes, pCBMI, pBits, 8); } } if (pBBMI->biBitCount==1) FixMono(pBits, pBBMI->biSizeImage); INT32 result = AccusoftFilters::pfnIMG_create_handle_keep(pCBMI); if (result < 0) { GlobalUnlock(HMem); GlobalFree(HMem); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } *pHandle = result; return TRUE; }

BOOL BfxALU::MakeGreyscale (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: BfxALU::MakeGreyscale32to8, BFXALU::IsGreyscaleBitmap Definition at line 4142 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_color_gray(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_GREYSCALE)); }

BOOL BfxALU::MakeGreyscale32to8 (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: BfxALU::MakeGreyscale, BFXALU::IsGreyscaleBitmap This is an optimised routine for converting 32 bit greyscale rendered bitmaps to 8 bpp Definition at line 4186 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); *ppOutput = NewBitmap(B,0,0,8, NULL, _R(IDS_BFX_GREYSCALE)); if (!ppOutput) return FALSE; BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)((*ppOutput)->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF ((pBBMI->biSizeImage == 0) || (pBBMI->biCompression != BI_RGB) || (pBBMI->biHeight<0) || (pBBMI->biBitCount !=32) , FALSE, "Can't convert this DIB (may be it's not 32 bits)"); pABMI->biXPelsPerMeter = pBBMI->biXPelsPerMeter; pABMI->biYPelsPerMeter = pBBMI->biYPelsPerMeter; ERROR2IF ((pBBMI->biWidth != pABMI->biWidth)||(pBBMI->biHeight != pABMI->biHeight)||(pABMI->biClrUsed!=0x100), FALSE, "BfxALU MakeGreyscale32to8 size upset"); RGBQUAD * pSBits = (RGBQUAD *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); LPBYTE pDBits = (((CWxBitmap *)((*ppOutput)->ActualBitmap))->BMBytes); RGBQUAD * Pal = ((RGBQUAD *)(void *)(pABMI + 1/*ptr arith*/)); for (INT32 x=0;x<0x100;x++) { Pal[x].rgbRed=Pal[x].rgbGreen=Pal[x].rgbBlue=(BYTE)x; Pal[x].rgbReserved=0; } DWORD w=0; DWORD v=0; for (INT32 y=0;y<pBBMI->biHeight;y++) { for (INT32 x=0; x<pBBMI->biWidth; x++) { pDBits[v]=(2+pSBits[w].rgbRed+pSBits[w].rgbGreen+pSBits[w].rgbBlue)/3; w++; v++; } for (;v&3;v++) pDBits[v]=0; } ERROR3IF((w!=(pBBMI->biSizeImage>>2) || v!=pABMI->biSizeImage), "Alex messed up MakeGreyscale32to8 bitmap sizes"); return TRUE; }

BOOL BfxALU::MakeKernelBitmap (  INT32  Handle, KernelBitmap **  ppOutput, BOOL  Make32Bits = FALSE, String_256 *  pName = NULL, UINT32  ResID = 0, BOOL  DoBodge = FALSE )  [protected, virtual]

A new accusoft bitmap handle is created for the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: DoBodge  - tries to get round a bug in the Accusoft linear interpolation resize code [INPUTS] *pHandle  = Accusoft handle [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - This actually copies the bitmap. Note we'll have to fudge 32bit bmps somehow. NOTE: The BfxALU A register is corrupted IFF Make32Bits is set *** Definition at line 3420 of file bfxalu.cpp. { ERROR3IF((!ppOutput ), "BfxALU output parameter must be non-null"); INT32 width = 0; INT32 height = 0; INT32 bpp = 0; HANDLE MHandle = AccusoftFilters::pfnIMG_bitmap_info(Handle, &width, &height, &bpp); if (Make32Bits && bpp != 24) { INT32 result = AccusoftFilters::pfnIMG_delete_bitmap(Handle); ERROR2(FALSE, "Can't make a non-24 bit image into a 32 bit one guv"); } ERROR2IF(width ==0 || height == 0 || (bpp != 1 && bpp != 4 && bpp != 8 && bpp !=24 && bpp != 32), FALSE,"Bad bitmap height, width or colour depth in MakeKernelBitmap"); #ifdef BODGE_ACCUSOFT_RESIZE // if DoBodge set then we must strip our extra pixels from the left hand side and the right hand side // of the artificially wider bitmap. In fact three times wider than it should be. if (DoBodge) { width /= 3; } #endif BITMAPINFOHEADER * pBBMI = (LPBITMAPINFOHEADER) GlobalLock(MHandle); KernelBitmap * pKB = NewBitmap(NULL, width, height, Make32Bits ? 32 : bpp, pName, ResID); if (!pKB) { GlobalUnlock(MHandle); INT32 result = AccusoftFilters::pfnIMG_delete_bitmap(Handle); return FALSE; // Error already set } BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(pKB->ActualBitmap))->BMInfo->bmiHeader); // Dest if ( // if our created bitmap is not equal to the size of the accusoft one .... ((Make32Bits ? 24 : pABMI->biBitCount) != pBBMI->biBitCount) || ((!Make32Bits && !DoBodge) && pABMI->biSizeImage != pBBMI->biSizeImage) ) { GlobalUnlock(MHandle); delete pKB; INT32 result = AccusoftFilters::pfnIMG_delete_bitmap(Handle); ERROR2(FALSE,"Accusoft DLL lied about bpp / size"); } // Fix dodgy Accusoft Palette returns. See how they know what they are doing. I think not. if (bpp > 8) { pBBMI->biClrUsed = 0; pBBMI->biClrImportant = 0; } else { UINT32 UsedColours = 1 << bpp; #ifdef ACCUSOFT_HAS_BROKEN_NON_FULL_PALETTES // Accusoft Promote_8 from monochrome returns ClrUsed=2 but has a 256 entry colour table. Arrrggghhh! pBBMI->biClrUsed=pBBMI->biClrImportant=UsedColours; #endif if (pBBMI->biClrUsed == 0) pBBMI->biClrUsed = UsedColours; // 0 is MS speak for maximum if (pBBMI->biClrImportant == 0) pBBMI->biClrImportant = UsedColours; // 0 is MS speak for maximum if (UsedColours < pBBMI->biClrUsed) { TRACEUSER( "Alex", _T("These Accusoft boys really know what they're doing with Palettes - NOT\n")); pBBMI->biClrUsed = UsedColours; pBBMI->biClrImportant = UsedColours; } } // This is fabby Alex code. Just check out those void * rather than LPBYTE and DWORD instead of RGBQUAD void * pA = (void *)(((CWxBitmap *)(pKB->ActualBitmap))->BMBytes); //Dest void * pB = (void *)(((char *)(void *)(pBBMI)) + sizeof (BITMAPINFOHEADER) + (pBBMI->biClrUsed * sizeof (DWORD)) ); //Source // Now fix problems with our DIB format palettes (like we don't support optimised palettes for 24 bit stuff) if (pBBMI->biClrUsed > pABMI->biClrUsed) { pBBMI->biClrUsed = pABMI->biClrUsed; TRACEUSER( "Alex", _T("We've lost some palette information\n")); } if (pBBMI->biClrUsed < pBBMI->biClrImportant) pBBMI->biClrImportant = pBBMI->biClrUsed; if (!Make32Bits) { #ifdef BODGE_ACCUSOFT_RESIZE if (DoBodge) { // Copy the palette across if (pBBMI->biClrUsed > 0) { LPRGBQUAD pAPAL = &(((CWxBitmap *)(pKB->ActualBitmap))->BMInfo->bmiColors[0]); // Dest LPRGBQUAD pBPal = (LPRGBQUAD)(pBBMI + sizeof(BITMAPINFOHEADER)); // Source memcpy(pAPAL /*dest*/, pBPal, (pBBMI->biClrUsed * sizeof (RGBQUAD)) ); } // Make sure we copy any relevent information across to the destination bitmaps header. //pABMI->biWidth = width; pABMI->biClrUsed = pBBMI->biClrUsed; pABMI->biClrImportant = pBBMI->biClrImportant; if (!MKB_BodgeCopyBitmap(width, height, bpp,(LPBYTE)pB, (LPBYTE)pA)) { GlobalUnlock(MHandle); INT32 result = AccusoftFilters::pfnIMG_delete_bitmap(Handle); delete pKB;// We can't delete it - what can we do? *ppOutput = NULL; return FALSE; } } else #endif { // Copy the header and palette across memcpy(pABMI /*dest*/, pBBMI, sizeof(BITMAPINFOHEADER) + (pBBMI->biClrUsed * sizeof (DWORD)) ); // Copy the main bitmap data across memcpy(pA /*dest*/, pB, pABMI->biSizeImage); } } else { POINT tempPoints[3]; tempPoints[0].x = 0; tempPoints[0].y = 0; tempPoints[1].x = (INT32)(pBBMI->biWidth); tempPoints[1].y = 0; tempPoints[2].x = 0; tempPoints[2].y = (INT32)(pBBMI->biHeight); SetA(pKB); ZeroA(); GC->SetBitmapFill(pBBMI,(LPBYTE)pB, 0, tempPoints, 0, NULL, // palette NULL, NULL, NULL, NULL ); DoRect(); } pABMI->biXPelsPerMeter = pBBMI->biXPelsPerMeter; pABMI->biYPelsPerMeter = pBBMI->biYPelsPerMeter; //if (pBBMI->biBitCount==1) FixMono(pA, pBBMI->biSizeImage); GlobalUnlock(MHandle); if (ResetAccusoftDibsToRuns) { //AccusoftFilters::pfnIMG_dib_to_runs (Handle); ResetAccusoftDibsToRuns = FALSE; } INT32 result = AccusoftFilters::pfnIMG_delete_bitmap(Handle); if (result < 0) { delete pKB;// We can't delete it - what can we do? ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } *ppOutput = pKB; #ifdef _DEBUG // Check the memory is *really* gone and Accusoft isn't just mucking us around /*pBBMI = (LPBITMAPINFOHEADER) GlobalLock(MHandle); if (pBBMI) { TRACEUSER( "Alex", _T("Accusoft DLL failed to release memory\n")); GlobalUnlock(MHandle); GlobalFree(MHandle); }*/ #endif return TRUE; }

BOOL BfxALU::MarkBitByWord (  DWORD  BitMask, DWORD  TheWord )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: TheWord  = value to look for to mark [INPUTS] A  |= BitMask if B=TheWord [OUTPUTS] &= ~BitMask otherwise Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: BfxALU::MarkWordByBit, TraceControl::FindInitialArea Definition at line 1585 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); ERROR2IF((pBBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (pABMI->biSizeImage != pBBMI->biSizeImage), FALSE, "Incompatible bitmaps for MarkBitByWord"); DWORD * pA = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); DWORD * pB = (DWORD *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Size = (pABMI->biSizeImage)>>2; #ifdef FASTMARKBITBYWORD FastMarkBitByWord(pB, pA, Size, BitMask, TheWord); #else for (INT32 Pixel = 0; Pixel < Size; Pixel ++) if (pB[Pixel]==TheWord) pA[Pixel]|=BitMask; else pA[Pixel]&=~BitMask; #endif return TRUE; }

BOOL BfxALU::MarkColourThresholdError (  INT32  Value, DWORD  Colour, DWORD  MarkValue, DWORD  ClearValue, double *  pAError, double *  pBError, INT32 *  pTotalPixels, INT32 *  pMarkedPixels )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: Value  = the threshould [INPUTS] MarkValue = the value to mark positively affected pixels with ClearValue = the value to mark other pixels with Colour = the intended colour to use A  <- ( ((B-T)^2 >= Value ) && ((Colour-T)^2 < Value)) ? MarkValue : ClearValue [OUTPUTS] pAError = the total error (Colour-T) (or NULL not to fill in) pBError = the total error in B (or NULL not to fill in) TotalPixels = the total number of pixels (or NULL not to fill in) pMarkedPixels = the number of pixels marked (or NULL not to fill in) Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::MarkPositiveArea This is used by the tracer routines to find positively affected areas to mark. Definition at line 1391 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!T) || (T->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(T->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pTBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); ERROR2IF((pBBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF((pTBMI->biBitCount !=32), FALSE,"Bad BfxALU T reg"); ERROR2IF( ((pABMI->biSizeImage != pBBMI->biSizeImage) || (pABMI->biSizeImage != pTBMI->biSizeImage)), FALSE, "Incompatible bitmaps for MarkThresholdError"); // AluPix32 * pA = (AluPix32 *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); AluPix32 * pB = (AluPix32 *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); AluPix32 * pT = (AluPix32 *)(void *)(((CWxBitmap *)(T->ActualBitmap))->BMBytes); DWORD * pO = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); AluPix32 TheColour; *(DWORD *)(void *)(&TheColour)=Colour; // Yuck INT32 Size = (pABMI->biSizeImage)>>2; if (pTotalPixels) *pTotalPixels = Size; #ifdef FASTMARKCOLOURTHRESHOLD XLONG AError = 0; XLONG BError = 0; INT32 MarkedPixels = 0; FastMarkColourThreshold((DWORD *)(void *)pA, (DWORD *)(void *)pB, (DWORD *)(void *)pT, Size, Value, Colour, MarkValue, ClearValue, &AError, &BError, &MarkedPixels); if (pAError) *pAError = AError.MakeDouble(); if (pBError) *pBError = BError.MakeDouble(); if (pMarkedPixels) *pMarkedPixels = MarkedPixels; #else double AError = 0.0; double BError = 0.0; INT32 BE; INT32 AE; INT32 MarkedPixels=0; for (INT32 Pixel = 0; Pixel < Size; Pixel ++) { AE = ( IntegerSquare( ((INT32)(TheColour.R)) - ((INT32)(pT[Pixel].R))) + IntegerSquare( ((INT32)(TheColour.G)) - ((INT32)(pT[Pixel].G))) + IntegerSquare( ((INT32)(TheColour.B)) - ((INT32)(pT[Pixel].B))) ); BE = ( IntegerSquare( ((INT32)(pB[Pixel].R)) - ((INT32)(pT[Pixel].R))) + IntegerSquare( ((INT32)(pB[Pixel].G)) - ((INT32)(pT[Pixel].G))) + IntegerSquare( ((INT32)(pB[Pixel].B)) - ((INT32)(pT[Pixel].B))) ); AError += AE; BError += BE; pO[Pixel] = ((AE<Value) && (BE>=Value)) ? (MarkedPixels++,MarkValue) : ClearValue; } if (pAError) *pAError = AError; if (pBError) *pBError = BError; if (pMarkedPixels) *pMarkedPixels = MarkedPixels; #endif return TRUE; }

BOOL BfxALU::MarkGivenArea (  DWORD  MarkValue, DWORD  ClearValue, DWORD  RegionValue, BOOL *  FoundRegion, INT32 *  InitialX, INT32 *  InitialY, INT32 *  Area )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: MarkValue  = the value marked pixel have [INPUTS] ClearValue = the value cleared pixels have RegionValue = the value to mark pixels in the largest region witgh InitialX,Y = A coordinate in the region to be marked A  = RegionValue if pixel is in largest region, otherwise a different number [OUTPUTS] ClearValue if pixel is not marked otherwise a different value from the above two. pAError = the total error in A (or NULL not to fill in) pBError = the total error in B (or NULL not to fill in) TotalPixels = the total number of pixels (or NULL not to fill in) InitialX,Y = Initial point in region to be marked Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::FindInitialPoint, BfxALU::MarkRegions, BfxALU::BuildErrorRegionList This is used by the tracer routines work out the area to mark. Definition at line 1932 of file bfxalu.cpp. { INT32 Size; INT32 HighestChain; DWORD * pA; ERROR2IF((!InitialX)||(!InitialY),FALSE, "Why not pass in an InitialX & InitialY"); INT32 ix = *InitialX; INT32 iy = *InitialY; INT32 Width; // Our error checking done in MarkRegions if (!MarkRegions(MarkValue, ClearValue, FoundRegion, InitialX, InitialY, Area, &Size, &HighestChain, &Width, &pA)) return FALSE; HighestChain=ix+Width*iy; while (pA[HighestChain] < 0x80000000) HighestChain = pA[HighestChain]; // get top of pixel chain if (pA[HighestChain] == ClearValue) HighestChain=-1; if (InitialX) *InitialX = 0; if (InitialY) *InitialY = 0; if (Area) *Area = 0; if ( (*FoundRegion =/*assign*/ (HighestChain != -1) ) != FALSE ) { if (InitialX) *InitialX = HighestChain % Width; if (InitialY) *InitialY = HighestChain / Width; if (Area) *Area = pA[HighestChain] - 0x80000000; } if (!*FoundRegion) return TRUE; //No need for this poxy coding then #ifdef FASTMARKLARGESTAREA FastMarkLargestArea(pA, Size, MarkValue, ClearValue, RegionValue, HighestChain); #else INT32 OtherPixel; INT32 Pixel; for (Pixel = (Size-1); Pixel >= 0; Pixel--) { OtherPixel = Pixel; while (pA[OtherPixel] < 0x80000000) OtherPixel = pA[OtherPixel]; // get top of pixel chain if (OtherPixel==HighestChain) { pA[Pixel] = RegionValue; } else { if (pA[Pixel]!=ClearValue) #if 1 pA[Pixel] = MarkValue; #else pA[Pixel] = 0x7F020202 | (_lrotl((OtherPixel ^ 0xabcdef13),(OtherPixel % 31)) % 0xFFFFFF); #endif } } #endif return TRUE; }

BOOL BfxALU::MarkLargestArea (  DWORD  MarkValue, DWORD  ClearValue, DWORD  RegionValue, BOOL *  FoundRegion, INT32 *  InitialX, INT32 *  InitialY, INT32 *  Area )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: MarkValue  = the value marked pixel have [INPUTS] ClearValue = the value cleared pixels have RegionValue = the value to mark pixels in the largest region witgh A  = RegionValue if pixel is in largest region, otherwise a different number [OUTPUTS] ClearValue if pixel is not marked otherwise a different value from the above two. pAError = the total error in A (or NULL not to fill in) pBError = the total error in B (or NULL not to fill in) TotalPixels = the total number of pixels (or NULL not to fill in) Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::FindInitialPoint, BfxALU::MarkRegions, BfxALU::BuildErrorRegionList This is used by the tracer routines work out the area to mark. Definition at line 1864 of file bfxalu.cpp. { INT32 Size; INT32 HighestChain; DWORD * pA; // Our error checking done in MarkRegions if (!MarkRegions(MarkValue, ClearValue, FoundRegion, InitialX, InitialY, Area, &Size, &HighestChain, NULL, &pA)) return FALSE; if (!*FoundRegion) return TRUE; //No need for this poxy coding then #ifdef FASTMARKLARGESTAREA FastMarkLargestArea(pA, Size, MarkValue, ClearValue, RegionValue, HighestChain); #else INT32 OtherPixel; INT32 Pixel; for (Pixel = (Size-1); Pixel >= 0; Pixel--) { OtherPixel = Pixel; while (pA[OtherPixel] < 0x80000000) OtherPixel = pA[OtherPixel]; // get top of pixel chain if (OtherPixel==HighestChain) { pA[Pixel] = RegionValue; } else { if (pA[Pixel]!=ClearValue) #if 1 pA[Pixel] = MarkValue; #else pA[Pixel] = 0x7F020202 | (_lrotl((OtherPixel ^ 0xabcdef13),(OtherPixel % 31)) % 0xFFFFFF); #endif } } #endif return TRUE; }

BOOL BfxALU::MarkPositive (  INT32  Value, DWORD  MarkValue, DWORD  ClearValue, double *  pAError = NULL, double *  pBError = NULL, INT32 *  pTotalPixels = NULL, INT32 *  pMarkedPixels = NULL )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: Value  = the threshould [INPUTS] MarkValue = the value to mark positively affected pixels with ClearValue = the value to mark other pixels with A  <- ( ((B-T)^2 >= Value ) && ((A-T)^2 < Value)) ? MarkValue : ClearValue [OUTPUTS] pAError = the total error in A (or NULL not to fill in) pBError = the total error in B (or NULL not to fill in) TotalPixels = the total number of pixels (or NULL not to fill in) pMarkedPixels = the number of pixels marked (or NULL not to fill in) Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::MarkPositiveArea This is used by the tracer routines to find positively affected areas to mark. Definition at line 1493 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!T) || (T->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(T->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pTBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); ERROR2IF((pBBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF((pTBMI->biBitCount !=32), FALSE,"Bad BfxALU T reg"); ERROR2IF( ((pABMI->biSizeImage != pBBMI->biSizeImage) || (pABMI->biSizeImage != pTBMI->biSizeImage)), FALSE, "Incompatible bitmaps for MarkThresholdError"); AluPix32 * pA = (AluPix32 *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); AluPix32 * pB = (AluPix32 *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); AluPix32 * pT = (AluPix32 *)(void *)(((CWxBitmap *)(T->ActualBitmap))->BMBytes); DWORD * pO = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Size = (pABMI->biSizeImage)>>2; if (pTotalPixels) *pTotalPixels = Size; #ifdef FASTMARKPOSITIVE XLONG AError = 0; XLONG BError = 0; INT32 MarkedPixels = 0; FastMarkPositive((DWORD *)(void *)pA, (DWORD *)(void *)pB, (DWORD *)(void *)pT, Size, Value, MarkValue, ClearValue, &AError, &BError, &MarkedPixels); if (pAError) *pAError = AError.MakeDouble(); if (pBError) *pBError = BError.MakeDouble(); if (pMarkedPixels) *pMarkedPixels = MarkedPixels; #else double AError = 0.0; double BError = 0.0; INT32 BE; INT32 AE; INT32 MarkedPixels=0; for (INT32 Pixel = 0; Pixel < Size; Pixel ++) { AE = ( IntegerSquare( ((INT32)(pA[Pixel].R)) - ((INT32)(pT[Pixel].R))) + IntegerSquare( ((INT32)(pA[Pixel].G)) - ((INT32)(pT[Pixel].G))) + IntegerSquare( ((INT32)(pA[Pixel].B)) - ((INT32)(pT[Pixel].B))) ); BE = ( IntegerSquare( ((INT32)(pB[Pixel].R)) - ((INT32)(pT[Pixel].R))) + IntegerSquare( ((INT32)(pB[Pixel].G)) - ((INT32)(pT[Pixel].G))) + IntegerSquare( ((INT32)(pB[Pixel].B)) - ((INT32)(pT[Pixel].B))) ); AError += AE; BError += BE; pO[Pixel] = ((AE<Value) && (BE>=Value)) ? (MarkedPixels++,MarkValue) : ClearValue; } if (pAError) *pAError = AError; if (pBError) *pBError = BError; if (pMarkedPixels) *pMarkedPixels = MarkedPixels; #endif return TRUE; }

BOOL BfxALU::MarkRegions (  DWORD  MarkValue, DWORD  ClearValue, BOOL *  FoundRegion, INT32 *  InitialX, INT32 *  InitialY, INT32 *  Area, INT32 *  pSize, INT32 *  pHighestChain, INT32 *  pWidth, DWORD **  ppA )  [protected, virtual]

Definition at line 1761 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR2IF(!FoundRegion,FALSE,"Found Region flag is compulsorary"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); DWORD * pA = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); INT32 Size = (pABMI->biSizeImage)>>2; INT32 Width = pABMI->biWidth; INT32 x=0; INT32 y=0; INT32 HighestChainVal = 0; INT32 HighestChain = -1; #ifdef FASTMARKREGIONS FastMarkRegions(pA, Size, Width, MarkValue, ClearValue, &HighestChain, &HighestChainVal); #else INT32 Pixel; INT32 TopChain; INT32 OtherPixel; INT32 SwapTemp; for (Pixel = 0; Pixel < Size; Pixel ++) { if (pA[Pixel] != ClearValue) { pA[Pixel] = 0x80000001; // Mark as a single pixel chain TopChain = Pixel; // and this is it's top // OK, we've found a new pixel. First work out if it is connected to any other previously if (x!=0) MLATestPixel(Pixel-1); if (y!=0) { if (x!=Width-1) MLATestPixel(Pixel-Width+1); MLATestPixel(Pixel-Width); if (x!=0) MLATestPixel(Pixel-Width-1); } if (((INT32)(pA[TopChain]-0x80000000))>HighestChainVal) { HighestChainVal = (INT32)(pA[TopChain]-0x80000000); HighestChain = TopChain; } } if ((++x)==Width) { x=0; y++; } } #endif if (InitialX) *InitialX = 0; if (InitialY) *InitialY = 0; if (Area) *Area = HighestChainVal; if ( (*FoundRegion =/*assign*/ (HighestChain != -1) ) != FALSE ) { if (InitialX) *InitialX = HighestChain % Width; if (InitialY) *InitialY = HighestChain / Width; } if (pSize) *pSize = Size; if (pHighestChain) *pHighestChain = HighestChain; if (ppA) *ppA=pA; if (pWidth) *pWidth=Width; return TRUE; }

BOOL BfxALU::MarkThresholdError (  INT32  Value, DWORD  MarkValue, DWORD  ClearValue )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 18/1/95 Parameters: Value  = the threshold [INPUTS] MarkValue = the value to mark over the threshold pixels with ClearValue = the value to mark other pixels with A  <- ( (B-T)^2 >= Value ) ? MarkValue : ClearValue [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::MarkInitialArea This is used by the tracer routines to find an initial area to mark. Definition at line 1317 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!T) || (T->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(T->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pTBMI=&(((CWxBitmap *)(T->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); ERROR2IF((pBBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF((pTBMI->biBitCount !=32), FALSE,"Bad BfxALU T reg"); ERROR2IF( ((pABMI->biSizeImage != pBBMI->biSizeImage) || (pABMI->biSizeImage != pTBMI->biSizeImage)), FALSE, "Incompatible bitmaps for MarkThresholdError"); // AluPix32 * pA = (AluPix32 *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); AluPix32 * pB = (AluPix32 *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); AluPix32 * pT = (AluPix32 *)(void *)(((CWxBitmap *)(T->ActualBitmap))->BMBytes); DWORD * pO = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Size = (pABMI->biSizeImage)>>2; #ifdef FASTMARKTHRESHOLD XLONG BError = 0; INT32 MarkedPixels = 0; FastMarkThreshold((DWORD *)(void *)pA, (DWORD *)(void *)pB, (DWORD *)(void *)pT, Size, Value, MarkValue, ClearValue, &BError, &MarkedPixels); //if (pBError) *pBError = BError.MakeDouble(); //if (pMarkedPixels) *pMarkedPixels = MarkedPixels; #else for (INT32 Pixel = 0; Pixel < Size; Pixel ++) pO[Pixel] = (( IntegerSquare( ((INT32)(pB[Pixel].R)) - ((INT32)(pT[Pixel].R))) + IntegerSquare( ((INT32)(pB[Pixel].G)) - ((INT32)(pT[Pixel].G))) + IntegerSquare( ((INT32)(pB[Pixel].B)) - ((INT32)(pT[Pixel].B)))) >= Value ) ? MarkValue : ClearValue; #endif return TRUE; }

BOOL BfxALU::MarkWordByBit (  DWORD  BitMask, DWORD  MarkValue, DWORD  ClearValue )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: MarkValue  & ClearValue = the two workds with which to mark [INPUTS] A  = ((B & BitMask) ? MarkValue:ClearValue); [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: BfxALU::MarkWordByBit, TraceControl::FindInitialArea Definition at line 1681 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); ERROR2IF((pBBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (pABMI->biSizeImage != pBBMI->biSizeImage), FALSE, "Incompatible bitmaps for MarkWordByBit"); DWORD * pB = (DWORD *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); DWORD * pA = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Size = (pABMI->biSizeImage)>>2; #ifdef FASTMARKWORDBYBIT FastMarkWordByBit(pB, pA, Size, BitMask, MarkValue, ClearValue); #else for (INT32 Pixel = 0; Pixel < Size; Pixel ++) pA[Pixel] = (pB[Pixel] & BitMask) ? MarkValue : ClearValue; #endif return TRUE; }

BOOL BfxALU::MKB_BodgeCopyBitmap (  INT32  Width, INT32  Height, INT32  Depth, LPBYTE  pSourceBits, LPBYTE  pDestBits )  [protected]

The reverse of the MAH_BodgeCopyBitmap version. This copies the bitmap across to the destination but instead of doing a straight copy we copy the middle section from the source bitmap which should be three times the width we want to the destination bitmap which should be a third of the width we want. Assumes: Source bitmap is three times the width of the destination but is the same in all other aspects. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 20/09/96 Parameters: Width  - Width of bitmap [INPUTS] Height - Height of bitmap Depth - ColourDepth of bitmap pSourceBits - source data to use pDestBits - destination for the data None  [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not See also: MakeAccusoftHandle; MAH_BodgeCopyBitmap; Definition at line 3350 of file bfxalu.cpp. { #ifdef BODGE_ACCUSOFT_RESIZE // Copy back stripping the first bodge pixels from the start of each line UINT32 SourceScanline = DIBUtil::ScanlineSize(Width * 3, Depth); UINT32 DestScanline = DIBUtil::ScanlineSize(Width, Depth); // We need to do it the hard way and copy it by hand // Remove the repeated extra bodged pixels INT32 Bytes = 1; switch (Depth) { /* case 8: { // 1 pixel per byte Bytes = Width; // For each scanline copy the middle third, which is the original bitmap // back across to the destination for (INT32 i = 0; i < Height; i++ ) { */ //memcpy(pDestBits /*dest*/, pSourceBits + Bytes, DestScanline); /* pDestBits += DestScanline; pSourceBits += SourceScanline; } break; } */ case 24: { // Copy 8 * 3 pixels 1/3 of a pixel at a time Bytes = 3 * Width; // For each scanline copy the middle third, which is the original bitmap // back across to the destination for (INT32 i = 0; i < Height; i++ ) { memcpy(pDestBits /*dest*/, pSourceBits + Bytes, DestScanline); pDestBits += DestScanline; pSourceBits += SourceScanline; } break; } default: ERROR2(FALSE,"Bad colour depth when bodge copying"); } #endif return TRUE; }

KernelBitmap * BfxALU::NewBitmap (  KernelBitmap *  pBitmap, INT32  XAdjust = 0, INT32  YAdjust = 0, INT32  NewDepth = 0, String_256 *  pName = NULL, UINT32  ResID = 0 )  [virtual]

General purpose call to claim a new kernel bitmap. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: pBitmap  = pointer to the bitmap whose size to copy or NULL [INPUTS] XAdjust = Amount to alter X size by YAdjust = Amount to alter Y size by Depth = bpp of new bitmap or 0 for as pBitmap Claims  a new bitmap [OUTPUTS] Returns: Pointer to bitmap, or NULL on failure Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Note the new bitmap is uninitialized. I'll say that again. It's uninitialized. IE it contains potentially random bytes. Passing a null bitmap pointer is like passing a pointer to a 32bpp 0x0 bitmap, so kb=NewBitmap(NULL, 128, 128) creates a 128 pixelx128 pixel bitmap. kb2=NewBitmap(kb1, -1, -1, 8) creates a bitmap kb2 like kb1 but 8bpp and one pixel smaller. And so on. If a null pointer is returned, an error is set. Definition at line 443 of file bfxalu.cpp. { INT32 Width; INT32 Height; INT32 Depth; INT32 DPI; BOOL IsTemp=TRUE; ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); if (!pBitmap) { Width=0; Height=0; Depth=32; DPI=96; IsTemp=FALSE; } else { ERROR2IF((pBitmap->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(pBitmap->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BitmapInfo BMInfo; pBitmap->ActualBitmap->GetInfo(&BMInfo); Depth=BMInfo.PixelDepth; Width=BMInfo.PixelWidth; Height=BMInfo.PixelHeight; DPI=96; /*BMInfo.DPI; not there grrrr */ } Width+=XAdjust; Height+=YAdjust; if (NewDepth) Depth=NewDepth; // Don't do the following as the constructor doesn't error properly // Oh dear, we have to do it because OILBitmap::Create is protected. Grrr KernelBitmap * pNewBitmap = new KernelBitmap(Width,Height,Depth,DPI,IsTemp); // Note 'new' sets error for this class if (!pNewBitmap) return FALSE; if (!pNewBitmap->ActualBitmap) // the alloc failed and we must, unfortunately, assume the error is set right { delete pNewBitmap; // apparently this will work though I don't like it return FALSE; } // OILBitmap * pNewOILBitmap = OILBitmap::Create( Width, Height, Depth, DPI ); // if (!pNewOILBitmap) return FALSE; // error already set // KernelBitmap * pNewBitmap = new KernelBitmap(pNewOILBitmap); // Note 'new' sets error for this class // if (!pNewBitmap) // { // delete pNewOILBitmap; // return FALSE; // } ERROR2IF((pNewBitmap->ActualBitmap==NULL) || (((CWxBitmap *)(pNewBitmap->ActualBitmap))->BMInfo==NULL) || (((CWxBitmap *)(pNewBitmap->ActualBitmap))->BMBytes==NULL), FALSE,"BfxALU can't find OIL bitmap of the new bitmap"); if (pBitmap) { BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(pNewBitmap->ActualBitmap))->BMInfo->bmiHeader); // Copy the DPI accross pBBMI->biXPelsPerMeter = pABMI->biXPelsPerMeter; pBBMI->biYPelsPerMeter = pABMI->biYPelsPerMeter; if (Depth<=8) // If the bitmaps are the same depth we make a new palette { if (pBBMI->biClrUsed==pABMI->biClrUsed && pBBMI->biBitCount==pABMI->biBitCount) { // copy in palette if appropriate memcpy(pBBMI+1 /*ptr arith*/, pABMI+1 /*ptr arith*/, pBBMI->biClrUsed*sizeof(DWORD)); } } } String_256 BitmapName; if (pName) BitmapName=*pName; else { if (pBitmap) BitmapName=pBitmap->ActualBitmap->GetName(); else BitmapName=pNewBitmap->ActualBitmap->GetName(); } if ((ResID) && (BitmapName.Length()<128)) { String_256 Mask(_R(IDS_BFXALU_MASK_START)); // " (*" String_256 Mask2(_R(IDS_BFXALU_MASK_END)); // ")" TCHAR Fuzz = '*'; String_256 Processed(_R(IDS_BFX_PROCESSED)); String_256 Res(ResID); INT32 pos = BitmapName.Sub(Mask, 0, Fuzz); if (pos>=0) if (BitmapName.Sub(Mask2, pos, Fuzz)<0) pos=-1; if (pos>=0) BitmapName.Left(&BitmapName, pos); BitmapName += String_8(_R(IDS_BFXALU_PROCESSED_START)); // " ("; if (pos>=0) BitmapName+=Processed; BitmapName+=Res; BitmapName += String_8(_R(IDS_BFXALU_PROCESSED_END)); // ")"; } GetApplication()->GetGlobalBitmapList()->MakeNameUnique(&BitmapName); pNewBitmap->ActualBitmap->SetName(BitmapName); return pNewBitmap; }

BOOL BfxALU::Octree (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 4311 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_octree_color (AccusoftHandle, 8, NULL, 256); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_OCTREECOLOUR)); }

BOOL BfxALU::PartKAB (  DWORD  Value  )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- TA + (1-Value)B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1207 of file bfxalu.cpp. { return UseBK(ALUC_PART, Value); }

BOOL BfxALU::PartMulKAB (  DWORD  Value  )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- TAB + (1-Value)B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1228 of file bfxalu.cpp. { return UseBK(ALUC_PARTMUL, Value); }

BOOL BfxALU::PartMulTAB (   )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- TAB + (1-T)B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1123 of file bfxalu.cpp. { return UseBT(ALUC_PARTMUL); }

BOOL BfxALU::PartRevMulKAB (  DWORD  Value  )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- Value.(1-(1-A)(1-B)) + (1-Value)B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1249 of file bfxalu.cpp. { return UseBK(ALUC_PARTREVMUL, Value); }

BOOL BfxALU::PartRevMulTAB (   )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- T(1-(1-A)(1-B)) + (1-T)B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1144 of file bfxalu.cpp. { return UseBT(ALUC_PARTREVMUL); }

BOOL BfxALU::PartTAB (   )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- TA + (1-T)B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1102 of file bfxalu.cpp. { return UseBT(ALUC_PART); }

BOOL BfxALU::PlotB (   )  [virtual]

This routine sets up GDraw for A & B, and calls DoRect(). Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] Performs  an ALU operation A<-B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 1003 of file bfxalu.cpp. { DWORD Style=0; ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); if (!B) { ERROR2IF((!GC->SetTransparency(BColour,(enum TransparencyEnum) Style)),FALSE,"Bad BfxALU B reg"); } else { ERROR2IF((B->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); //ERROR2IF((pBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (!GC->SetBitmapFill(pBMI,(((CWxBitmap *)(B->ActualBitmap))->BMBytes), BStyle | (Style<<8), BPoints, 0, ((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiColors, (unsigned char *) BpTable, (unsigned char *) BpTable, (unsigned char *) BpTable, NULL )), FALSE,"GDraw didn't like BfxALU B reg"); } return DoRect(); }

BOOL BfxALU::PlotBLUT (  BfxALULUT *  LUT  )  [virtual]

This routine sets up GDraw for A & B, and calls DoRect(). Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] Performs  an ALU operation A<-B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 1052 of file bfxalu.cpp. { DWORD Style=12; ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF((GC==NULL),FALSE,"BfxALU::PlotBLUT() where's my LUT then?"); if (!B) { ERROR2IF((!GC->SetTransparency(BColour,(enum TransparencyEnum) Style)),FALSE,"Bad BfxALU B reg"); } else { ERROR2IF((B->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); //ERROR2IF((pBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (!GC->SetTransparencyLookupTable((CONST BYTE *) (LUT->Data))),FALSE,"Bad LUT"); ERROR2IF( (!GC->SetBitmapFill(pBMI,(((CWxBitmap *)(B->ActualBitmap))->BMBytes), BStyle | (Style<<8), BPoints, 0, ((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiColors, (unsigned char *) BpTable, (unsigned char *) BpTable, (unsigned char *) BpTable, NULL )), FALSE,"GDraw didn't like BfxALU B reg"); } return DoRect(); }

BOOL BfxALU::PopularityColour (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 4059 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_8(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_popularity_color(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_POPULARITYCOLOUR)); }

BOOL BfxALU::RemoveDither (  KernelBitmap **  ppOutput, INT32  Thresh, INT32  QuantCols, TraceMethod  Method )  [virtual]

Definition at line 4425 of file bfxalu.cpp. { TRACEUSER( "Alex", _T("RemoveDither called Method %d, Degree %d\n")); ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 OutputBPP=1; INT32 NumPasses=1; INT32 Width=0; INT32 Depth=0; INT32 Height=0; INT32 l; // INT32 __mtemp; if (!GetSize(B, &Width, &Height, &Depth)) return FALSE; DWORD * InputLine[5]; BYTE * ByteLine[5]; BYTE * OutputLine = NULL; for (l=0; l<5; l++) InputLine[l]=NULL; Thresh=(Thresh*Thresh*3); // must be +ve if (Thresh>255*255*3) Thresh=255*255*3; if (QuantCols<2) QuantCols=2; if ((Method==TRACEMETHOD_256COL) && (QuantCols<17)) QuantCols=17; if (QuantCols>255) QuantCols=255; INT32 TotalCols=QuantCols; *ppOutput=NULL; // The array of quantisation cells //QuantisationCell QuantMap[QUANT_SIZE][QUANT_SIZE][QUANT_SIZE]; QuantisationCell * pQuantMap=NULL; if ((pQuantMap=(QuantisationCell *)CCMalloc(sizeof(QuantisationCell)*QUANT_NUMBER))==NULL) { return FALSE; } // An array of pointers to cells which get sorted soon //QuantisationCell * QuantIndex[QUANT_SIZE][QUANT_SIZE][QUANT_SIZE]; //QuantisationCell * * QuantSort = &(QuantIndex[0][0][0]); QuantisationCell * * pQuantIndex = NULL; if ((pQuantIndex=(QuantisationCell * *)CCMalloc(sizeof(QuantisationCell *)*QUANT_NUMBER))==NULL) { CCFree(pQuantMap); return FALSE; } // Make this point to the 1st pointer so we can sort it. QuantisationCell * * QuantSort = pQuantIndex; ERROR3IF(QUANT_SIZE*QUANT_SIZE*QUANT_SIZE<256, "Too few quantisation steps"); switch(Method) { case TRACEMETHOD_MONO: OutputBPP=1; NumPasses=2; break; case TRACEMETHOD_GREYSCALE: OutputBPP=8; NumPasses=1; break; case TRACEMETHOD_256COL: { OutputBPP=8; NumPasses=2; for (INT32 i=0; i<QUANT_SIZE; i++) for (INT32 j=0; j<QUANT_SIZE; j++) for (INT32 k=0; k<QUANT_SIZE; k++) { (pQuantMap)QMEMBER(i,j,k).rsum=(pQuantMap)QMEMBER(i,j,k).gsum=(pQuantMap)QMEMBER(i,j,k).bsum=(pQuantMap)QMEMBER(i,j,k).pixels=0; (pQuantMap)QMEMBER(i,j,k).index=-1; (pQuantIndex)QMEMBER(i,j,k)=&(pQuantMap)QMEMBER(i,j,k); } } break; case TRACEMETHOD_TRUECOL: OutputBPP=32; NumPasses=1; break; default: ERROR2(FALSE,"BfxALU::RemoveDither doesn't understand trace method"); break; } KernelBitmap * pKB = NewBitmap(B, 0, 0, OutputBPP, NULL, _R(IDS_BFX_REMOVEDITHER)); if (!pKB) { CCFree(pQuantMap); CCFree(pQuantIndex); return FALSE; // error already set } if (OutputBPP==1 && Depth==1) { DWORD * SPalette= (DWORD*)(void*)(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiColors); if ((SPalette[0] & 0x00ffffff)==0 && (SPalette[1] & 0x00ffffff)==0x00ffffff) { // Forsooth! It is a true mono bitmap. // We know a song about that: // memcpy memcpy, its so much quicker // mono bitmaps handled so much slicker // don't bother trying to remove their noise // as they don't have any (not by our definition anywoise) // (OK, enough of that). memcpy(/*dest*/(((CWxBitmap *)(pKB->ActualBitmap))->BMBytes), /*src*/(((CWxBitmap *)(B->ActualBitmap))->BMBytes), (((CWxBitmap *)(pKB->ActualBitmap))->BMInfo->bmiHeader.biSizeImage)); RGBQUAD * Palette= (((CWxBitmap *)(pKB->ActualBitmap))->BMInfo->bmiColors); Palette[0].rgbRed=Palette[0].rgbBlue=Palette[0].rgbGreen=0; Palette[1].rgbRed=Palette[1].rgbBlue=Palette[1].rgbGreen=255; *ppOutput=pKB; CCFree(pQuantMap); CCFree(pQuantIndex); return TRUE; } } INT32 x; INT32 y; /* INT32 NoiseMatrix[5][5]={ { 32, 128, 192, 128, 32 }, { 128, 256, 256, 256, 128 }, { 192, 256, 256, 256, 192 }, { 128, 256, 256, 256, 128 }, { 32, 128, 192, 128, 32 }}; INT32 NoiseMatrix[5][5]={ { 1, 2, 3, 2, 1 }, { 2, 4, 4, 4, 2 }, { 3, 4, 4, 4, 3 }, { 2, 4, 4, 4, 2 }, { 1, 2, 3, 2, 1 }}; // Sum=68 */ INT32 NoiseMatrix[5][5]={ { 1, 4, 6, 4, 1 }, { 4, 8, 8, 8, 4 }, { 6, 8, 8, 8, 6 }, { 4, 8, 8, 8, 4 }, { 1, 4, 6, 4, 1 }}; INT32 * NoiseMatrixP[5]; INT32 Distrib[256]; INT32 Points=0; INT32 n; for (n=0; n<256; n++) Distrib[n]=0; if (Method==TRACEMETHOD_GREYSCALE) { double QuantPoints[255]; double QuantDist=256.0/(QuantCols-1); double q=-0.5*QuantDist; for (n=0; n<QuantCols; n++) { QuantPoints[n]=q; q+=QuantDist; } INT32 cp=0; for (n=0; n<256; n++) { while ((cp<QuantCols) && (n>QuantPoints[cp])) cp++; Distrib[n]=(INT32)(QuantDist*(cp-1)); if (Distrib[n]<0) Distrib[n]=0; if (Distrib[n]>255) Distrib[n]=255; } } OutputLine=(BYTE *) CCMalloc(Width<<2); if (!OutputLine) { CCFree(pQuantMap); CCFree(pQuantIndex); delete pKB; return FALSE; } for (x=0; x<(Width<<2); x++) OutputLine[x]=0; for (l=0; l<5; l++) { if ((InputLine[l]=(DWORD *)/*assign*/CCMalloc((Width+4)<<2))==NULL) { for (l=0; l<5; l++) if (InputLine[l]) CCFree(InputLine[l]); CCFree(OutputLine); delete pKB; CCFree(pQuantMap); CCFree(pQuantIndex); return FALSE; }; ByteLine[l]=(BYTE *)InputLine[l]; NoiseMatrixP[l]=&(NoiseMatrix[l][0]); } for (INT32 Pass=0; Pass<NumPasses; Pass++) { // First of all we must convert a new block to 32 bpp for (y=0; y<Height; y++) { // Shuffle the existing lines down // L4 shifts into L3 // .. // L1 shifts into L0 // // L0 is forgotten and its memory space is used by the new L4 DWORD * L0=InputLine[0]; for (l=0; l<5; l++) { InputLine[l]=(l==4)?L0:InputLine[l+1]; } // at y=0 we must fill in all lines, otherwise just the new line (line 4) for (l=(y==0)?0:4; l<5; l++) { INT32 sy=y+l-2; if (sy<0) sy=0; if (sy>=Height) sy=Height-1; ConvertScanLineToDWORD(B,sy,&(InputLine[l][2])); InputLine[l][0]=InputLine[l][1]=InputLine[l][2]; // duplicate 1st pixel InputLine[l][Width+3]=InputLine[l][Width+2]=InputLine[l][Width+1]; // duplicate last pixel } for (l=0; l<5; l++) ByteLine[l]=(BYTE *)InputLine[l]; INT32 r; INT32 g; INT32 b; // First create the output scanline BYTE * pOutput=OutputLine; if (Depth==1) { // This is a great optimisation for mono source where the pixels will always be completely different // (and thus be unaffected as they'll be over the threshold) or identical (and won't affect things // as they are identical). Thus we might as well just memcpy the line memcpy(OutputLine, &(ByteLine[2][2<<2]), Width<<2); } else { #ifdef FASTREMOVEDITHER FastRemoveDither(ByteLine, NoiseMatrixP, (DWORD *) OutputLine, Width, Thresh, (Method==TRACEMETHOD_GREYSCALE || Method==TRACEMETHOD_MONO)?1:0); #else SlowRemoveDither(ByteLine, NoiseMatrix, OutputLine, Width, Thresh, (Method==TRACEMETHOD_GREYSCALE || Method==TRACEMETHOD_MONO)); #endif } // Now write it back void * VImage = (((CWxBitmap *)(pKB->ActualBitmap))->BMBytes); switch (Method) { case TRACEMETHOD_GREYSCALE: { BYTE * Dest = &(((BYTE *) VImage)[((Width+3)&~3)*y]); for (x=0; x<Width; x++) { *(Dest++)=(BYTE)(DWORD)Distrib[*pOutput]; pOutput+=4; } } break; case TRACEMETHOD_MONO: { if (!Pass) // Mono - 1st pass modify distribution curve { for (x=0; x<Width; x++) { r=(INT32)(DWORD)(*pOutput); pOutput+=4; Distrib[r]++; Points++; } } else { BYTE * Dest = (&(((BYTE *) VImage)[(((Width+31)&~31)>>3)*y]))-1/*as we preinc*/; for (x=0; x<Width; x++) { if (!(x&7)) *(++Dest)=0; *Dest |= Distrib[(INT32)(DWORD)(*pOutput)] >> (x&7); pOutput+=4; } } } break; case TRACEMETHOD_TRUECOL: { memcpy(&(((DWORD *) VImage)[Width*y]), pOutput, Width<<2); } break; case TRACEMETHOD_256COL: { if (!Pass) { for (x=0; x<Width; x++) { b=(INT32)(DWORD)*(pOutput++); g=(INT32)(DWORD)*(pOutput++); r=(INT32)(DWORD)*(pOutput++); pOutput++; INT32 qr=(r+QUANT_ROUND)>>QUANT_SHIFT; INT32 qg=(g+QUANT_ROUND)>>QUANT_SHIFT; INT32 qb=(b+QUANT_ROUND)>>QUANT_SHIFT; QuantisationCell * pQuantCell=&(pQuantMap)QMEMBER(qr,qg,qb); pQuantCell->pixels++; pQuantCell->rsum+=r; pQuantCell->gsum+=g; pQuantCell->bsum+=b; } } else { BYTE * Dest = &(((BYTE *) VImage)[((Width+3)&~3)*y]); for (x=0; x<Width; x++) { b=(INT32)(DWORD)*(pOutput++); g=(INT32)(DWORD)*(pOutput++); r=(INT32)(DWORD)*(pOutput++); pOutput++; INT32 qr=(r+QUANT_ROUND)>>QUANT_SHIFT; INT32 qg=(g+QUANT_ROUND)>>QUANT_SHIFT; INT32 qb=(b+QUANT_ROUND)>>QUANT_SHIFT; QuantisationCell * pQuantCell=&(pQuantMap)QMEMBER(qr,qg,qb); INT32 Index = pQuantCell->index; if (Index<0) { // better colourtrans it then INT32 rsum = pQuantCell->rsum; INT32 gsum = pQuantCell->gsum; INT32 bsum = pQuantCell->bsum; INT32 MinD=0x7fffffff; Index=0; for (INT32 m=0; m<TotalCols; m++) { // Find the colour difference INT32 d=IntegerSquare(QuantSort[m]->rsum - rsum) + IntegerSquare(QuantSort[m]->gsum - gsum) + IntegerSquare(QuantSort[m]->bsum - bsum); if (d<MinD) { // Note the cube with the smallest difference MinD=d; Index=m; } } // write it back in so we dont have to do it again pQuantCell->index=Index; } ERROR3IF(((DWORD)Index)>255, "Wierd index value"); *Dest++=(BYTE)(DWORD)Index; } } } break; default: { ERROR3("We shouldn't get here..."); } break; } // End of case BOOL Continue=TRUE; if ((y & 15)==0) Continue=ContinueSlowJob((100*y/Height+100*Pass)/NumPasses); if (!Continue) { ERROR1RAW(_R(IDE_BFX_ABORT)); for (l=0; l<5; l++) if (InputLine[l]) CCFree(InputLine[l]); CCFree(OutputLine); delete pKB; CCFree(pQuantMap); CCFree(pQuantIndex); return FALSE; } } // End of y loop switch (Method) { case TRACEMETHOD_MONO: if (!Pass) { RGBQUAD * Palette= (((CWxBitmap *)(pKB->ActualBitmap))->BMInfo->bmiColors); INT32 Sum=0; for (INT32 n=0; n<256; n++) { BOOL Thresh=(Sum>Points/2)|(n==255); Sum+=Distrib[n]; Distrib[n]=Thresh?0x80:0; } Palette[0].rgbRed=Palette[0].rgbBlue=Palette[0].rgbGreen=0; Palette[1].rgbRed=Palette[1].rgbBlue=Palette[1].rgbGreen=255; } break; case TRACEMETHOD_256COL: if (!Pass) { // First bodge the issue so the gun maxima values always appear, which ensures // we can represent a full contrast range. This probably isn't necessary as we're not // dithering it but heh, we might as well keep white as white etc. RGBQUAD * Palette= (((CWxBitmap *)(pKB->ActualBitmap))->BMInfo->bmiColors); INT32 totalpixels=Width * Height; INT32 pixmax=totalpixels * INT32(0xff); INT32 r; for (r=0; r<QUANT_SIZE; r+=QUANT_SIZE-1) for (INT32 g=0; g<QUANT_SIZE; g+=QUANT_SIZE-1) for (INT32 b=0; b<QUANT_SIZE; b+=QUANT_SIZE-1) { QuantisationCell * pQuantCell=&(pQuantMap)QMEMBER(r,g,b); pQuantCell->rsum=r?pixmax:0; pQuantCell->gsum=g?pixmax:0; pQuantCell->bsum=b?pixmax:0; pQuantCell->pixels=totalpixels; } // And now for some greyscales // This avoids inverse-Acorn colourtrans problems for (r=1; r<QUANT_SIZE-1/*even*/; r+=2) { QuantisationCell * pQuantCell=&(pQuantMap)QMEMBER(r,r,r); pQuantCell->rsum=pQuantCell->gsum=pQuantCell->bsum= (r<<QUANT_SHIFT) * (pQuantCell->pixels=/*assign*/totalpixels); } // Now sort the index qsort((void *)(QuantSort),QUANT_SIZE*QUANT_SIZE*QUANT_SIZE,sizeof(QuantisationCell *), &BfxALUQuantisationRoutine); TotalCols=0; INT32 n; // blank the palette for (n=0; n<256; n++) Palette[n].rgbRed=Palette[n].rgbBlue=Palette[n].rgbGreen=Palette[n].rgbReserved=0; // Now calculate the real av RGB values for each subcube for (n=0; (n<QUANT_SIZE*QUANT_SIZE*QUANT_SIZE) ; n++ ) if (QuantSort[n]->pixels>0) { INT32 r=(QuantSort[n]->rsum+(INT32)(QuantSort[n]->pixels>>1))/QuantSort[n]->pixels; INT32 g=(QuantSort[n]->gsum+(INT32)(QuantSort[n]->pixels>>1))/QuantSort[n]->pixels; INT32 b=(QuantSort[n]->bsum+(INT32)(QuantSort[n]->pixels>>1))/QuantSort[n]->pixels; if (r<0) r=0; // Clip if (r>255) r=255; if (g<0) g=0; // Clip if (g>255) g=255; if (b<0) b=0; // Clip if (b>255) b=255; QuantSort[n]->rsum = r; QuantSort[n]->gsum = g; QuantSort[n]->bsum = b; ERROR3IF((n>0) && (QuantSort[n-1]->pixels<QuantSort[n]->pixels), "urm, they aren't in order..."); } // Label the most important subcubes and fill in the palette for (n=0; (n<QuantCols) && (QuantSort[n]->pixels>0); n++) { QuantSort[n]->index=n; TotalCols=n+1; Palette[n].rgbRed=(BYTE)(DWORD)(QuantSort[n]->rsum); Palette[n].rgbBlue=(BYTE)(DWORD)(QuantSort[n]->bsum); Palette[n].rgbGreen=(BYTE)(DWORD)(QuantSort[n]->gsum); } // Now find the nearest matches for the other colours in the colour cube ERROR3IF(!TotalCols, "OK, how come this image had no colours in it *at all*"); } break; case TRACEMETHOD_GREYSCALE: { RGBQUAD * Palette= (((CWxBitmap *)(pKB->ActualBitmap))->BMInfo->bmiColors); for (INT32 c=0; c<256; c++) Palette[c].rgbRed=Palette[c].rgbBlue=Palette[c].rgbGreen=(BYTE)(DWORD)c; } break; default: break; } } for (l=0; l<5; l++) if (InputLine[l]) CCFree(InputLine[l]); CCFree(OutputLine); *ppOutput=pKB; CCFree(pQuantMap); CCFree(pQuantIndex); return TRUE; }

BOOL BfxALU::Resize (  KernelBitmap **  ppOutput, INT32  Width, INT32  Height, BOOL  LinearInterpolation )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: Brightness  & Contast (-127 to +127) [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 5125 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); // Accusoft have a bug on their linear interpolation code which puts a grey line down // the left hand side of the image, so we must bodge it!!!!! BOOL DoBodge = FALSE; INT32 bpp = B->GetBPP(); #ifdef BODGE_ACCUSOFT_RESIZE if (LinearInterpolation && (bpp == 4 || bpp == 8 || bpp == 24 || bpp == 32)) DoBodge = TRUE; #endif INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle, DoBodge)) return FALSE; INT32 result = 0; if (LinearInterpolation) { // Accusoft require a 24bpp bitmap for linear interpolation // If less than or equal 8bpp // if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <=8 ) SCARY!!!!! INT32 NewWidth = Width; #ifdef BODGE_ACCUSOFT_RESIZE // If doing the bodge to get around the Accusoft 24bpp linear interpolation problem, then // we make the bitmap 3 times as wide as it should be to hide the grey pixels on the left // hand side when we remove this extra space after the inerpolation has happened. // We therefore need to make the resize 3 times the width it should be. if (DoBodge) NewWidth *= 3; #endif if (bpp <= 8) { result = AccusoftFilters::pfnIMG_promote_24(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } result = AccusoftFilters::pfnIMG_resize_bitmap_interp(AccusoftHandle, (INT32) NewWidth, (INT32) Height); } else { // Do a straight resize result = AccusoftFilters::pfnIMG_resize_bitmap(AccusoftHandle, (INT32) Width, (INT32) Height); } if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_RESIZE), DoBodge); }

BOOL BfxALU::Rotate180 (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created which is the flipped version of the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3714 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; INT32 result = AccusoftFilters::pfnIMG_rotate_bitmap(AccusoftHandle, 18000); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_ROTATE180)); }

BOOL BfxALU::Rotate270 (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created which is the flipped version of the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3746 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; INT32 result = AccusoftFilters::pfnIMG_rotate_bitmap(AccusoftHandle, 27000); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_ROTATE270)); }

BOOL BfxALU::Rotate90 (  KernelBitmap **  ppOutput  )  [virtual]

A new bitmap is created which is the flipped version of the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: None  [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 3682 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; INT32 result = AccusoftFilters::pfnIMG_rotate_bitmap(AccusoftHandle, 9000); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), _R(IDS_BFX_ROTATE90)); }

BOOL BfxALU::ScanBit (  DWORD  BitMask, INT32 *  X, INT32 *  Y, INT32 *  pPixel, BOOL *  Found, BOOL  CheckConnected = FALSE )  [virtual]

Arithemtic operation to search A for the next pixel s.t. (A & BitMask) !=0. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: BitMask  = the bit mask to search for [INPUTS] X = the start X position or NULL Y = the start Y position or NULL pPixel = the start pixel position (takes priority over X & Y) or NULL CheckConnected = TRUE to check at least one connected bit is also set *X  = the end X position or 0 if none found [OUTPUTS] Y = the end Y position or 0 if none found pPixel = the end pixel position or 0 if none found Found = TRUE if found a pixel such that (A & BitMask) is non zero Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::FindInitialArea Definition at line 2112 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pABMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pABMI->biBitCount !=32), FALSE,"Bad BfxALU A reg"); DWORD * pA = (DWORD *)(void *)(((CWxBitmap *)(A->ActualBitmap))->BMBytes); INT32 Width = pABMI->biWidth; INT32 Size = (pABMI->biSizeImage)>>2; INT32 Pixel = 0; BOOL Connected = TRUE; if (pPixel) Pixel=*pPixel; else if (X && Y) Pixel=(*X)+(*Y)*Width; INT32 tx; INT32 ty; do { #ifdef FASTSCANBIT if (Pixel<Size) FastScanBit(pA, Size, BitMask, &Pixel); #else while (Pixel<Size && !(pA[Pixel] & BitMask)) Pixel++; #endif if (Pixel>=Size) { if (X) *X=0; if (Y) *Y=0; if (pPixel) *pPixel=0; if (Found) *Found=FALSE; return TRUE; } tx=Pixel % Width; ty=Pixel / Width; if (pPixel) *pPixel=Pixel; if (X) *X=tx; if (Y) *Y=ty; if (Found) *Found=TRUE; Connected = !CheckConnected; if ((!Connected) && (tx!=Width-1)) Connected = ((pA[Pixel+1] & BitMask) !=0); if ((!Connected) && (Pixel+Width<Size)) Connected = ((pA[Pixel+Width] & BitMask) !=0); if ((!Connected) && (tx!=Width-1) && (Pixel+Width+1<Size)) Connected = ((pA[Pixel+Width+1] & BitMask) !=0); if ((!Connected) && (tx!=0) && (Pixel+Width-1<Size)) Connected = ((pA[Pixel+Width-1] & BitMask) !=0); if (!Connected) Pixel++; } while (!Connected); return TRUE; }

BOOL BfxALU::ScanThreshold (  INT32  Value, INT32 *  X, INT32 *  Y, INT32 *  pPixel, BOOL *  Found, BOOL  CheckConnected = FALSE )  [virtual]

Arithemtic operation to search A for the next pixel s.t. (A & BitMask) !=0. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: Value  = the threshold to look for [INPUTS] X = the start X position or NULL Y = the start Y position or NULL pPixel = the start pixel position (takes priority over X & Y) or NULL CheckConnected = TRUE to check at least one connected bit is also set *X  = the end X position or 0 if none found [OUTPUTS] Y = the end Y position or 0 if none found pPixel = the end pixel position or 0 if none found Found = TRUE if found a pixel such that (A & BitMask) is non zero Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: TraceControl::FindInitialArea Definition at line 2191 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!B) || (B->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); ERROR2IF( ((!T) || (T->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(T->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); BITMAPINFOHEADER * pTBMI=&(((CWxBitmap *)(T->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pBBMI->biBitCount != pTBMI->biBitCount), FALSE,"Bad BfxALU B reg"); ERROR2IF( (pTBMI->biSizeImage != pBBMI->biSizeImage), FALSE, "Incompatible bitmaps for ScanThreshold"); switch (pTBMI->biBitCount) { case 32: { AluPix32 * pB = (AluPix32 *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); AluPix32 * pT = (AluPix32 *)(void *)(((CWxBitmap *)(T->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Width = pBBMI->biWidth; INT32 Size = (pBBMI->biSizeImage)>>2; INT32 Pixel = 0; BOOL Connected = TRUE; if (pPixel) Pixel=*pPixel; else if (X && Y) Pixel=(*X)+(*Y)*Width; INT32 tx; INT32 ty; INT32 tp; #define __scanthresh(p) (( IntegerSquare( ((INT32)(pB[p].R)) - ((INT32)(pT[p].R))) \ + IntegerSquare( ((INT32)(pB[p].G)) - ((INT32)(pT[p].G))) \ + IntegerSquare( ((INT32)(pB[p].B)) - ((INT32)(pT[p].B)))) >= Value ) do { #ifdef FASTSCANTHRESHOLD if (Pixel<Size) FastScanThreshold((DWORD *)(void *)pB, (DWORD *)(void *)pT, Size, Value, &Pixel); #else while (Pixel<Size && !__scanthresh(Pixel)) Pixel++; #endif if (Pixel>=Size) { if (X) *X=0; if (Y) *Y=0; if (pPixel) *pPixel=0; if (Found) *Found=FALSE; return TRUE; } tx=Pixel % Width; ty=Pixel / Width; if (pPixel) *pPixel=Pixel; if (X) *X=tx; if (Y) *Y=ty; if (Found) *Found=TRUE; if ((Connected = /*assign*/ !CheckConnected) != FALSE) return TRUE; if ((!Connected) && (tx!=Width-1)) {tp=Pixel+1;Connected = __scanthresh(tp);} if ((!Connected) && (Pixel+Width<Size)) {tp=Pixel+Width;Connected = __scanthresh(tp);} if ((!Connected) && (tx!=Width-1) && (Pixel+Width+1<Size)) {tp=Pixel+Width+1;Connected = __scanthresh(tp);} if ((!Connected) && (tx!=0) && (Pixel+Width-1<Size)) {tp=Pixel+Width-1;Connected = __scanthresh(tp);} if (!Connected) Pixel++; } while (!Connected); return TRUE; } case 8: { BYTE * pB = (BYTE *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); BYTE * pT = (BYTE *)(void *)(((CWxBitmap *)(T->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Width = pBBMI->biWidth; INT32 Size = pBBMI->biSizeImage; INT32 Pixel = 0; BOOL Connected = TRUE; INT32 WidthR = (Width+3) & ~3; if (pPixel) Pixel=*pPixel; else if (X && Y) Pixel=(*X)+(*Y)*WidthR; INT32 tx = Pixel % WidthR; INT32 ty = Pixel / WidthR; INT32 tp; #define __scanthresh8(p) (pB[p]!=pT[p]) do { #ifdef FASTSCANTHRESHOLD8 if (Pixel<Size) FastScanThreshold8((DWORD *)(void *)pB, (DWORD *)(void *)pT, Size, Value, &Pixel, Width, WidthR, &tx, &ty); #else while (Pixel<Size && (tx>=Width || !__scanthresh8(Pixel))) { Pixel++; if ((++tx)>=WidthR) { ty++; tx=0; } } #endif if (Pixel>=Size) { if (X) *X=0; if (Y) *Y=0; if (pPixel) *pPixel=0; if (Found) *Found=FALSE; return TRUE; } if (pPixel) *pPixel=Pixel; if (X) *X=tx; if (Y) *Y=ty; if (Found) *Found=TRUE; if ((Connected = /*assign*/ !CheckConnected) != FALSE) return TRUE; if ((!Connected) && (tx!=Width-1)) {tp=Pixel+1;Connected = __scanthresh8(tp);} if ((!Connected) && (Pixel+WidthR<Size)) {tp=Pixel+WidthR;Connected = __scanthresh8(tp);} if ((!Connected) && (tx!=Width-1) && (Pixel+WidthR+1<Size)) {tp=Pixel+WidthR+1;Connected = __scanthresh8(tp);} if ((!Connected) && (tx!=0) && (Pixel+WidthR-1<Size)) {tp=Pixel+WidthR-1;Connected = __scanthresh8(tp);} if (!Connected) { Pixel++; if ((++tx)>=WidthR) { ty++; tx=0; } } } while (!Connected); return TRUE; } case 1: { BYTE * pB = (BYTE *)(void *)(((CWxBitmap *)(B->ActualBitmap))->BMBytes); BYTE * pT = (BYTE *)(void *)(((CWxBitmap *)(T->ActualBitmap))->BMBytes); ERROR3IF((sizeof(DWORD) != sizeof(AluPix32)), "OK who's broken AluPix32 not to be 32 bits"); INT32 Width = pBBMI->biWidth; INT32 Size = pBBMI->biSizeImage<<3; INT32 Pixel = 0; BOOL Connected = TRUE; INT32 WidthR = (Width+31) & ~31; if (pPixel) Pixel=*pPixel; else if (X && Y) Pixel=(*X)+(*Y)*WidthR; INT32 tx = Pixel % WidthR; INT32 ty = Pixel / WidthR; INT32 tp; #define __scanthresh1(p) (((pB[p>>3]^pT[p>>3]) & (0x80>>(p&7))) !=0) do { #ifdef FASTSCANTHRESHOLD1 if (Pixel<Size) FastScanThreshold1((DWORD *)(void *)pB, (DWORD *)(void *)pT, Size, Value, &Pixel); #else while (Pixel<Size && (tx>=Width || !__scanthresh1(Pixel))) { Pixel++; if ((++tx)>=WidthR) { ty++; tx=0; } } #endif if (Pixel>=Size) { if (X) *X=0; if (Y) *Y=0; if (pPixel) *pPixel=0; if (Found) *Found=FALSE; return TRUE; } if (pPixel) *pPixel=Pixel; if (X) *X=tx; if (Y) *Y=ty; if (Found) *Found=TRUE; if ((Connected = /*assign*/ !CheckConnected) != FALSE) return TRUE; if ((!Connected) && (tx!=Width-1)) {tp=Pixel+1;Connected = __scanthresh1(tp);} if ((!Connected) && (Pixel+WidthR<Size)) {tp=Pixel+WidthR;Connected = __scanthresh1(tp);} if ((!Connected) && (tx!=Width-1) && (Pixel+WidthR+1<Size)) {tp=Pixel+WidthR+1;Connected = __scanthresh1(tp);} if ((!Connected) && (tx!=0) && (Pixel+WidthR-1<Size)) {tp=Pixel+WidthR-1;Connected = __scanthresh1(tp);} if (!Connected) { Pixel++; if ((++tx)>=WidthR) { ty++; tx=0; } } } while (!Connected); return TRUE; } default: break; } ERROR2(FALSE, "BfxALU::ScanThreshold doesn't understand that BPP"); return TRUE; // shouldn't get here }

BOOL BfxALU::SetA (  KernelBitmap *  pBitmap = NULL  )  [virtual]

GDraw needs a bitmap to plot to & from, this is the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: pBitmap  = pointer to the bitmap to use as an accumulator [INPUTS] Sets  up GDraw to use the kernel bitmap as an accumulator [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - This call sets up the accumulator register of the ALU to be the kernel bitmap passed in. All adds, subtracts etc. are done on this register. pBitmap may be NULL to stop using this bitmap Definition at line 576 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); if (!pBitmap) { GC->SetupBitmap(256,256,32,NULL,TRUE); GC->SetMatrix(&identity); A=NULL; return(TRUE); } else { ERROR2IF((pBitmap->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(pBitmap->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); // ERROR2IF((((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiHeader.biBitCount !=32), FALSE, // "Bad BfxALU accumulator"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF( (!GC->SetupBitmap(pBMI->biWidth,pBMI->biHeight,pBMI->biBitCount, ((CWxBitmap *)(pBitmap->ActualBitmap))->BMBytes)), FALSE,"GDraw didn't like BfxALU accumulator"); GC->SetMatrix(&identity); A=pBitmap; return(TRUE); } }

BOOL BfxALU::SetB (  DWORD  Colour  )  [virtual]

GDraw needs a bitmap to plot to & from, this is the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: Colour  is the colour word we're using [INPUTS] Sets  up GDraw to use the kernel bitmap as B reg [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - This call sets up the B register of the ALU to be the kernel bitmap passed in. pBitmap may be null to stop using this bitmap Definition at line 673 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); B=NULL; BColour=Colour; return TRUE; }

BOOL BfxALU::SetB (  KernelBitmap *  pBitmap = NULL, INT32  XOffset = 0, INT32  YOffset = 0, const BYTE *  pTable = NULL, DWORD  Style = 0 )  [virtual]

GDraw needs a bitmap to plot to & from, this is the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: pBitmap  = pointer to the bitmap to use as B reg [INPUTS] X/YOffset = offsets in pixels pTable = a lookup table to use on the RGB channels Style = Tiling style Sets  up GDraw to use the kernel bitmap as B reg [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - This call sets up the B register of the ALU to be the kernel bitmap passed in. pBitmap may be null to stop using this bitmap Definition at line 627 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); if (!pBitmap) { B=NULL; BColour=0; return(TRUE); } else { ERROR2IF((pBitmap->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(pBitmap->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiHeader); //ERROR2IF((pBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); BPoints[0].x = XOffset; BPoints[0].y = YOffset; BPoints[1].x = XOffset+(INT32)(pBMI->biWidth); BPoints[1].y = YOffset; BPoints[2].x = XOffset; BPoints[2].y = YOffset+(INT32)(pBMI->biHeight); B=pBitmap; BpTable=pTable; BStyle=Style; return(TRUE); } }

BOOL BfxALU::SetT (  DWORD  Value  )  [virtual]

GDraw needs a bitmap to plot to & from, this is the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: Value  is the value we're passing in [INPUTS] Sets  up GDraw to use the kernel bitmap as T reg [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - This call sets up the T register of the ALU to be the kernel bitmap passed in. pBitmap may be null to stop using this bitmap Definition at line 753 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); T = NULL; TValue = Value; return TRUE; }

BOOL BfxALU::SetT (  KernelBitmap *  pBitmap = NULL, INT32  XOffset = 0, INT32  YOffset = 0, const BYTE *  pTable = NULL, DWORD  Style = 0 )  [virtual]

GDraw needs a bitmap to plot to & from, this is the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: pBitmap  = pointer to the bitmap to use as T reg [INPUTS] X/YOffset = offsets in pixels pTable = a lookup table to use on the RGB channels Style = Tiling style Sets  up GDraw to use the kernel bitmap as T reg [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - This call sets up the T register of the ALU to be the kernel bitmap passed in. pBitmap may be null to stop using this bitmap Definition at line 706 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); if (!pBitmap) { T=NULL; TValue=0; return(TRUE); } else { ERROR2IF((pBitmap->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(pBitmap->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(pBitmap->ActualBitmap))->BMInfo->bmiHeader); // Some operations now allow 32 bit 'T' regs though they aren't used for transparency // ERROR2IF((pBMI->biBitCount !=8), FALSE,"Bad BfxALU T reg"); TPoints[0].x = XOffset; TPoints[0].y = YOffset; TPoints[1].x = XOffset+(INT32)(pBMI->biWidth); TPoints[1].y = YOffset; TPoints[2].x = XOffset; TPoints[2].y = YOffset+(INT32)(pBMI->biHeight); T=pBitmap; TpTable=pTable; TStyle=Style; return(TRUE); } }

BOOL BfxALU::SharpenBlur (  KernelBitmap **  ppOutput, INT32  Degree, INT32  Times )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: Degree  = degree of sharpening (+ve) or blurring (-ve) [INPUTS] Times = number of times to apply *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 4355 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <=8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_24(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } if (Times>20) Times=20; for (INT32 i=1; i<=Times; i++) { INT32 result = AccusoftFilters::pfnIMG_sharpen_bitmap(AccusoftHandle, (INT32) Degree); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), (Degree>0)?_R(IDS_BFX_SHARPEN):_R(IDS_BFX_BLUR)); }

void BfxALU::SlowRemoveDither (  BYTE *  ByteLine[5], INT32  NoiseMatrix[5][5], BYTE *  OutputLine, INT32  Width, INT32  Thresh, BOOL  Mono )  [protected]

Removes dither (slowly). Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/04/95 Parameters: ByteLine  - a ptr to 5 ptrs to extended scanlines of 32 bit source data [INPUTS] NoiseMatrix - the variable convolution matrix Width = the (unextended) scanline width. Th input scanline must be extended by 2 pixels each side Thresh = the noise cutoff threshold Mono = true to make the output single channel BYTE  * OutputLine - the 32 bit scanline to be filled in [OUTPUTS] Returns: None Errors: Error 3 for algorithmic failures Scope: Protected See also: BfxALU::RemoveDither, FastRemoveDither Definition at line 4944 of file bfxalu.cpp. { for (INT32 x=0; x<Width; x++) { INT32 r=0; INT32 g=0; INT32 b=0; INT32 s=0; INT32 CB=(INT32)(ByteLine[2][2*4]); INT32 CG=(INT32)(ByteLine[2][2*4+1]); INT32 CR=(INT32)(ByteLine[2][2*4+2]); for (INT32 dy=0; dy<=4; dy++) { for (INT32 dx=0; dx<=4; dx++) { INT32 v=NoiseMatrix[dx][dy]; INT32 LB=(INT32)(DWORD)(*(ByteLine[dy]++)); INT32 LG=(INT32)(DWORD)(*(ByteLine[dy]++)); INT32 LR=(INT32)(DWORD)(*(ByteLine[dy]++)); INT32 dr=LR-CR; INT32 dg=LG-CG; INT32 db=LB-CB; if (((dr*dr)+(dg*dg)+(db*db))<=Thresh) { s+=v; r+=v*LR; g+=v*LG; b+=v*LB; } ByteLine[dy]++; // past reserved byte } ByteLine[dy]-=16; // we've advanced it 5 and we only wanted to advance it 1. } if (s) // should always be true as centre always has value { if (Mono) { r=r+g+b; // Sum RGB s*=3; // Divide by 3x more r+=s>>1; // Add rounding factor r=r/s; // Find result if (r<0) r=0; // Clip if (r>255) r=255; } else { r+=s>>1; g+=s>>1; b+=s>>1; r=r/s; g=g/s; b=b/s; if (r<0) r=0; // Clip if (r>255) r=255; if (g<0) g=0; // Clip if (g>255) g=255; if (b<0) b=0; // Clip if (b>255) b=255; } } else { ERROR3("BfxALU::SlowRemoveDither should never get here!"); } *(OutputLine++)=(BYTE)(DWORD)b; *(OutputLine++)=(BYTE)(DWORD)g; *(OutputLine++)=(BYTE)(DWORD)r; OutputLine++; // skip reserved byte } return; }

BOOL BfxALU::SpecialEffect (  KernelBitmap **  ppOutput, double *  Matrix, BfxSpecialEffect  Type )  [virtual]

A new bitmap is created as per function name. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/95 Parameters: Brightness  & Contast (-127 to +127) [INPUTS] *ppOutput  = a pointer to the output bitmap [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Public See also: - Definition at line 5041 of file bfxalu.cpp. { ERROR2IF((!ppOutput),FALSE, "BfxALU output parameter must be non-null"); ERROR2IF((!Matrix) && (Type == BFX_SFX_USER), FALSE, "Must pass a matrix for BFX_SFX_USER"); char matrix[9]; if (Type==BFX_SFX_USER) for (INT32 i=0; i<=8; i++) matrix[i]=(char)(INT32)Matrix[i]; INT32 AccusoftHandle = -1; if (!MakeAccusoftHandle(&AccusoftHandle)) return FALSE; if ( (((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader).biBitCount <=8 ) { INT32 result = AccusoftFilters::pfnIMG_promote_24(AccusoftHandle); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } } INT32 result = AccusoftFilters::pfnIMG_process_bitmap(AccusoftHandle, (INT32) Type, matrix); if (result < 0) { AccusoftFilters::pfnIMG_delete_bitmap(AccusoftHandle); ERROR1(FALSE, _R(IDE_ACCUSOFT_ERROR) - result); } UINT32 res = _R(IDS_BFX_EFFECTNAME0); switch (Type) { case BFX_SFX_USER: res=_R(IDS_BFX_EFFECTNAME0); break; case BFX_SFX_ISOLATEPOINTS: res=_R(IDS_BFX_EFFECTNAME1); break; case BFX_SFX_EDGE: res=_R(IDS_BFX_EFFECTNAME2); break; case BFX_SFX_HEDGE: res=_R(IDS_BFX_EFFECTNAME3); break; case BFX_SFX_VEDGE: res=_R(IDS_BFX_EFFECTNAME4); break; case BFX_SFX_P45EDGE: res=_R(IDS_BFX_EFFECTNAME5); break; case BFX_SFX_N45EDGE: res=_R(IDS_BFX_EFFECTNAME6); break; case BFX_SFX_LAPLACIAN: res=_R(IDS_BFX_EFFECTNAME7); break; case BFX_SFX_DIALATION: res=_R(IDS_BFX_EFFECTNAME8); break; case BFX_SFX_ROBERTS: res=_R(IDS_BFX_EFFECTNAME9); break; default: res=_R(IDS_BFX_EFFECTNAME0); break; } return MakeKernelBitmap(AccusoftHandle, ppOutput, FALSE, &(B->ActualBitmap->GetName()), res); }

BOOL BfxALU::SubKAB (  DWORD  Value  )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- A - Value.B [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1291 of file bfxalu.cpp. { return UseBK(ALUC_SUB, Value); }

BOOL BfxALU::SubTAB (   )  [virtual]

Arithemtic operation to do the above. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: None  [INPUTS] A  <- A - TB [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 & 3 from called routines Scope: Public See also: - Definition at line 1186 of file bfxalu.cpp. { return UseBT(ALUC_SUB); }

void BfxALU::TestGD (   )  [virtual]

Definition at line 373 of file bfxalu.cpp. { identity.AX=identity.BY=1<<(FX+16);identity.CX=identity.CY=identity.AY=identity.BX=0; GC->SetupBitmap(256,256,32,NULL,TRUE); GC->SetMatrix(&identity); GC->SetAntialiasFlag(FALSE); // should cause a context swap or 2 GC->SelectPalette(0); GC->SetHalftoneOrigin(0,0); }

BOOL BfxALU::UseBK (  DWORD  TransparencyStyle, DWORD  Value )  [protected, virtual]

This routine sets up GDraw for A & B, and calls DoRect(). Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: TransparencyStyle  = the transparency method to use [INPUTS] Value = Value of T Performs  an ALU operation using B & Value with a given transparency type [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - Definition at line 952 of file bfxalu.cpp. { DWORD Style; ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); Style = (TransparencyStyle+4)+(Value<<8); if (!B) { ERROR2IF((!GC->SetTransparency(BColour | TValue,(enum TransparencyEnum) Style)),FALSE,"Bad BfxALU BT reg"); } else { ERROR2IF((B->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); //ERROR2IF((pBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (!GC->SetBitmapFill(pBMI,(((CWxBitmap *)(B->ActualBitmap))->BMBytes), BStyle | (Style<<8), BPoints, 0, ((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiColors, (unsigned char *) BpTable, (unsigned char *) BpTable, (unsigned char *) BpTable, NULL )), FALSE,"GDraw didn't like BfxALU B reg"); } return DoRect(); }

BOOL BfxALU::UseBT (  DWORD  TransparencyStyle = 0  )  [protected, virtual]

This routine sets up GDraw for A & B, and calls DoRect(). Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: TransparencyStyle  = the transparency method to use [INPUTS] Performs  an ALU operation using B & T with a given transparency type [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - Definition at line 849 of file bfxalu.cpp. { DWORD Style; ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); if (T) Style = TransparencyStyle+7; else Style = (TransparencyStyle+4)+(TValue<<8); if ((!B) && (!T)) // Flat B, Flat T { ERROR2IF((!GC->SetTransparency(BColour | TValue,(enum TransparencyEnum) Style)),FALSE,"Bad BfxALU BT reg"); } if ((B) && (!T)) // Bitmap B, Flat T { ERROR2IF((B->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); //ERROR2IF((pBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (!GC->SetBitmapFill(pBMI,(((CWxBitmap *)(B->ActualBitmap))->BMBytes), BStyle | (Style<<8), BPoints, 0, ((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiColors, (unsigned char *) BpTable, (unsigned char *) BpTable, (unsigned char *) BpTable, NULL )), FALSE,"GDraw didn't like BfxALU B reg"); } if ((!B) && (T)) // Ftat B, Bitmap T { ERROR2IF((!GC->SetTransparency(BColour,(enum TransparencyEnum) Style)),FALSE,"Bad BfxALU BT reg"); ERROR2IF((T->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(T->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(T->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pBMI->biBitCount !=8), FALSE,"Bad BfxALU T reg"); ERROR2IF( (!GC->SetTransparentBitmapFill(pBMI,(((CWxBitmap *)(T->ActualBitmap))->BMBytes), TStyle | (Style<<8), TPoints, 0 )), FALSE,"GDraw didn't like BfxALU T reg"); } if ((B) && (T)) // Bitmap B, Bitmap T { ERROR2IF((B->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(B->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiHeader); //ERROR2IF((pBMI->biBitCount !=32), FALSE,"Bad BfxALU B reg"); ERROR2IF( (!GC->SetBitmapFill(pBMI,(((CWxBitmap *)(B->ActualBitmap))->BMBytes), BStyle | (Style<<8), BPoints, 0, ((CWxBitmap *)(B->ActualBitmap))->BMInfo->bmiColors, (unsigned char *) BpTable, (unsigned char *) BpTable, (unsigned char *) BpTable, NULL )), FALSE,"GDraw didn't like BfxALU B reg"); ERROR2IF((T->ActualBitmap==NULL),FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(T->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); pBMI=&(((CWxBitmap *)(T->ActualBitmap))->BMInfo->bmiHeader); ERROR2IF((pBMI->biBitCount !=8), FALSE,"Bad BfxALU T reg"); ERROR2IF( (!GC->SetTransparentBitmapFill(pBMI,(((CWxBitmap *)(T->ActualBitmap))->BMBytes), TStyle | (Style<<8), TPoints, 0 )), FALSE,"GDraw didn't like BfxALU T reg"); } return DoRect(); }

BOOL BfxALU::ZeroA (  DWORD  FillValue = 0  )  [virtual]

Zeros the accumulator. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/94 Parameters: FillValue  - Value to fill with [INPUTS] Accumulator  altered [OUTPUTS] Returns: TRUE if succeeded, FALSE & error set if not Errors: Error 2 if init hasn't been called or GDraw fails Error 3 if windows and some other Oil layer are stangely mixed... Scope: Protected See also: - Definition at line 815 of file bfxalu.cpp. { ERROR2IF((GC==NULL),FALSE,"BfxALU::Init not called / failed"); ERROR2IF( ((!A) || (A->ActualBitmap==NULL)) ,FALSE,"BfxALU can't find OIL bitmap"); ERROR3IF( (!(A->ActualBitmap->IsKindOf(CC_RUNTIME_CLASS(CWxBitmap)) )),"BfxALU Oil layer inconsistency"); BITMAPINFOHEADER * pBMI=&(((CWxBitmap *)(A->ActualBitmap))->BMInfo->bmiHeader); memset(((CWxBitmap *)(A->ActualBitmap))->BMBytes, FillValue ,pBMI->biSizeImage); #if 0 RECT Rect={/*L*/0,/*T*/pBMI->biHeight,/*R*/pBMI->biWidth,/*B*/0}; GC->SetColour((COLORREF) 0x00000000); GC->SetTransparency((COLORREF) 0x00000000,(enum TransparencyEnum) 0); ERROR2IF((!GC->FillRectangle(&Rect)),FALSE,"BfxALU GDraw_FillRectangle failed"); #endif return(TRUE); }

---

Member Data Documentation

KernelBitmap* BfxALU::A [protected]

Definition at line 407 of file bfxalu.h.

KernelBitmap* BfxALU::B [protected]

Definition at line 408 of file bfxalu.h.

COLORREF BfxALU::BColour [protected]

Definition at line 414 of file bfxalu.h.

POINT BfxALU::BPoints[3] [protected]

Definition at line 411 of file bfxalu.h.

const BYTE* BfxALU::BpTable [protected]

Definition at line 417 of file bfxalu.h.

DWORD BfxALU::BStyle [protected]

Definition at line 420 of file bfxalu.h.

GDrawContext* BfxALU::GC [protected]

Definition at line 423 of file bfxalu.h.

GMATRIX BfxALU::identity [protected]

Definition at line 425 of file bfxalu.h.

BOOL BfxALU::ResetAccusoftDibsToRuns [protected]

Definition at line 427 of file bfxalu.h.

KernelBitmap* BfxALU::T [protected]

Definition at line 409 of file bfxalu.h.

POINT BfxALU::TPoints[3] [protected]

Definition at line 412 of file bfxalu.h.

const BYTE* BfxALU::TpTable [protected]

Definition at line 418 of file bfxalu.h.

DWORD BfxALU::TStyle [protected]

Definition at line 421 of file bfxalu.h.

DWORD BfxALU::TValue [protected]

Definition at line 415 of file bfxalu.h.

---

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

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

---