CWxBitmap Class Reference

The Windows implementation of the OILBitmap class. Based on a non-compressed DIB. Kernel code should not call on functions in this class except via the OILBitmap interface. More...

#include <oilbitmap.h>

Inheritance diagram for CWxBitmap:

List of all members.

Public Member Functions
	CWxBitmap ()
	Constructor.
	CWxBitmap (LPBITMAPINFO, LPBYTE)
	Constructor. This must NOT be called from Kernel code.
	~CWxBitmap ()
	Destructor. Frees up Windows resources for the bitmap.
virtual INT32	operator== (const OILBitmap &)
	Checks to see if one bitmap is the same as another.
void	CacheGeometry ()
	Sets up the cached info in the header so the plot routines will work fast.
virtual BOOL	GetInfo (BitmapInfo *Info, RenderRegion *pRegion=NULL)
	Kernel code can call this to obtain information about the bitmap in a platform- independent way. This function is implemented differently on different OIL layers.
virtual UINT32	GetWidth ()
	Retrieve information on this bitmap.
virtual UINT32	GetHeight ()
	Retrieve information on this bitmap.
virtual UINT32	GetBPP (RenderRegion *pRegion=NULL)
	Finds the colour resolution of this bitmap (or, if PRegion is specified, the colour resolution at which this bitmap should be output).
virtual UINT32	GetNumPaletteEntries ()
	Retrieve information on this bitmap.
virtual ADDR	GetBitmapBits ()
virtual UINT32	GetScanlineSize ()
	To determine the memory allocation needed to hold a single scanline of this bitmap. This is a convenient interface onto DIBUtil::ScanlineSize.
virtual BOOL	ExportBitmap (RenderRegion *pRegion)
virtual BOOL	ExportBitmapPalette (RenderRegion *pRegion)
	Exports this bitmap's palette to the given RenderRegion.
virtual BOOL	ExportBitmapData (RenderRegion *pRegion)
	Exports this bitmap's image data to the given RenderRegion.
virtual BOOL	ExportSeparatedData (RenderRegion *pRegion, BYTE *SepTables)
	Exports this bitmap's image data to the given RenderRegion, colour separating to an 8bpp image as it does so.
virtual BOOL	ExportSeparatedPalette (RenderRegion *pRegion)
	Exports a greyscale 8bpp palette suitable for use by the bitmaps output by ExportSeparatedData.
virtual BOOL	GetScanline32bpp (UINT32 YPos, BOOL UsePalette, Pixel32bpp *Scanline)
	Copies a scanline out of this bitmap into the given 32bpp buffer. The buffer must be no less than CWxBitmap::GetWidth() entries wide.
virtual wxImage *	MakewxImage (UINT32 ImageWidth=0, UINT32 ImageHeight=0, BOOL UsePalette=TRUE)
	Makes a wxBitmap, slowly.
virtual OILBitmap *	MakeCopy ()
	To make an exact duplicate of this bitmap.
virtual void	ColourSeparate32to32 (ColourPlate *pPlate, BYTE *SepTables)
	Converts the bitmap in-place from full colour 32 bpp RGB to the relevant separation returning the result as 32 bpp with correct colours for the specified plate.
virtual OILBitmap *	MakeSeparatedCopy (ColourPlate *pPlate, BYTE *SepTables)
	To make an colour separated copy of this bitmap.
virtual INT32	GetRecommendedWidth ()
	Finds the recommended width of the bitmap.
virtual INT32	GetRecommendedHeight ()
	Finds the recommended height of the bitmap.
virtual void	SetRecommendedWidth (INT32)
	Sets the recommended width of the bitmap.
virtual void	SetRecommendedHeight (INT32)
	Sets the recommended height of the bitmap.
virtual BOOL	SetTransparencyIndex (INT32)
	Finds the Transparent index colour of a bitmap if one exists.
virtual BOOL	GetTransparencyIndex (INT32 *)
	Finds the Transparent index colour of a bitmap if one exists.
virtual BOOL	IsTransparent ()
	Determines if a bitmap is not totally opaque.
virtual BOOL	WritePalette (BaseCamelotFilter *pFilter)
	Function used when exporting an 8bpp JPEG into the web file and we need to squirt the palette information into the record ready for reuse when the file is loaded back in.
virtual BOOL	Convert24To8 (RGBTRIPLE *pPalette, UINT32 NumberOfPaletteEntries)
	Converts the OILbitmap from its present 24bpp form into an 8bpp form which should closely match the one that was exported.
virtual BOOL	ImportBitmap (CCLexFile *pFile, BaseBitmapFilter *pBitmapFilter, BaseCamelotFilter *pFilter, BOOL IsCompressed)
	Imports a bitmap object using the import filter provided. It is used by the web/native filters to pull out a bitmap definition from inside a bitmap definition record. IsCompressed is only used for BMP/BMPZIP type bitmaps at present. Assumes: pFile has already been opened up for reading pFilter has been set up for reading the data e.g. progress bar.
virtual BOOL	ImportBitmap (Filter *, const BitmapInfo *, INT32)
	Import a bitmap object using the given bitmap specification and the import filter provided.
virtual BOOL	LoadBitmap (UINT32 BitmapResourceID)
	Loads a bitmap from the resources.
virtual BOOL	CreateFromwxBitmap (wxBitmap *pBitmap)
virtual BOOL	CreateFromwxImage (wxImage *pImage)
virtual BOOL	GetPaletteUsage (INT32 *)
	Find out how many times each palette entry is used in the bitmap. This is currently used when rendering paletted images to PostScript.
virtual BOOL	PrepareMask (INT32 PaletteEntry)
virtual BOOL	GetScanlineMaskBits (INT32 ScanlineY, LPBYTE ScanlineBuf)
	Given a palette.
virtual BOOL	DestroyMask ()
virtual BOOL	ExportContonePalette (RenderRegion *)
	Exports this bitmap's contone palette to the given RenderRegion.
virtual void	PlotPixel (INT32 x, INT32 y, Pixel32bpp NewValue)
	Plots a 32bpp pixel to a deep bitmap (24, or 32bpp).
virtual void	PlotPixel (INT32 x, INT32 y, PixelGreyscale NewValue)
	Plots an 8bpp (0..255) pixel to any type of bitmap The pixel is taken to be a greyscale, and is truncated or expanded as appropriate to fit the greyscale value into the destination bitmap pixel format.
virtual Pixel32bpp	ReadPixel32bpp (INT32 x, INT32 y, BOOL UsePalette=TRUE)
	reads a pixel
virtual INT32	ReturnPaletteIndexUsed (INT32 x, INT32 y)
	When the user clicks in, or moves the mouse over a pixel in one of the preview images, this function is called to work out the actual palette index of the colour used.
virtual PixelGreyscale	ReadPixelGreyscale (INT32 x, INT32 y)
	reads a pixel
virtual void	DeleteData (BOOL bResetToDefault=TRUE)
	Deletes the actual bitmap data.
virtual BOOL	HasBeenDeleted ()
	Returns whether or not the actual bitmap data has been deleted.
void	ExtractBitsAndInfo (LPBYTE *, LPBITMAPINFO *)
	To extract the bitmap data for use elsewhere, sets them to null so that the CWxBitmap object can be deleted.
virtual void	GenerateGreyscaleTable ()
virtual BOOL	IsBrowserPalette ()
	To see if the palette attached to this bitmap is browser compatible. It runs through the colours in a browser palette and checks to see if they are all present. The ordering is not checked and so the palette may be different from the one that we actually use.
virtual BOOL	ArePalettesTheSame (const LPLOGPALETTE pLogPalette, const INT32 TransColour=-1)
	To see if the palette attached to this bitmap is browser compatible. It runs through the colours in a browser palette and checks to see if they are all present. The ordering is not checked and so the palette may be different from the one that we actually use. Doesn't check the flags byte, just the RGB bytes.
virtual UINT32	GetHorizontalDPI ()
	Retrieve information on this bitmap.
virtual UINT32	GetVerticalDPI ()
	Retrieve information on this bitmap.
virtual void	CopyFullyTransparentFrom (OILBitmap *pBitmap)
virtual LPBITMAPINFO	GetBitmapInfo ()
	To get at the BITMAPINFO palette that this bitmap may have.
virtual LPRGBQUAD	GetPaletteForBitmap ()
	To get at the RGBQUAD palette that this bitmap may have.
virtual LPBITMAPINFOHEADER	GetBitmapInfoHeader ()
	To get at the BITMAPINFOHEADER that this bitmap should have.
virtual void	ReplaceBitmap (LPBYTE pBytes, LPBITMAPINFO pInfo)
	To reset the bitmap stored in this CWxBitmap object.
Static Public Member Functions
static void	ColourSeparateScanline32to8 (ColourContext *CurrentColContext, BYTE *SepTables, BYTE *DestBuffer, Pixel32bpp *SrcBuffer, INT32 PixelWidth)
	Copies the scanline of 32bpp BGR values from SrcBuffer to DestBuffer, running the pixels through colour separation tables en route. NOTE that Src and Dest may point at the same buffer to convert in-place.
Public Attributes
INT32	ScanLineByteWidth
INT32	BitmapSize
LPBITMAPINFO	BMInfo
LPBYTE	BMBytes
Protected Member Functions
BOOL	ExportBitmapPaletteInternal (RenderRegion *pRegion, INT32 NumColours, RGBQUAD *pSrcCLUT)
	Exports the given palette data to the given RenderRegion Used as an internal shared function for ExportBitmapPalette and ExportContonePalette.
Friends
BOOL	OILBitmap::Init ()
void	OILBitmap::Deinit ()
OILBitmap *	OILBitmap::Create ()
OILBitmap *	OILBitmap::Create (UINT32, UINT32, UINT32, UINT32)

---

Detailed Description

The Windows implementation of the OILBitmap class. Based on a non-compressed DIB. Kernel code should not call on functions in this class except via the OILBitmap interface.

Author:

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

Date:

11/8/94

Definition at line 125 of file oilbitmap.h.

---

Constructor & Destructor Documentation

CWxBitmap::CWxBitmap (   )

Constructor. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: ?/9/94 Definition at line 347 of file oilbitmap.cpp. { BMInfo = NULL; BMBytes = NULL; // Set up things for plotting ScanLineByteWidth = 0; BitmapSize = 0; // in bytes CacheGeometry(); }

CWxBitmap::CWxBitmap (  LPBITMAPINFO  Info, LPBYTE  Bytes )

Constructor. This must NOT be called from Kernel code. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: ?/9/94 Input: Windows bitmap pointers to an existing bitmap. Sets up the CWxBitmap to contain said bitmap. Definition at line 371 of file oilbitmap.cpp. { BMInfo = Info; BMBytes = Bytes; ScanLineByteWidth = 0; BitmapSize = 0; // in bytes CacheGeometry(); }

CWxBitmap::~CWxBitmap (   )

Destructor. Frees up Windows resources for the bitmap. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: ?/9/94 Definition at line 394 of file oilbitmap.cpp. { if (!HasBeenDeleted()) { if (BMInfo != NULL && BMBytes != NULL) { FreeDIB( BMInfo, BMBytes ); BMInfo = NULL; BMBytes = NULL; } } if (m_pGreyscaleTable) delete m_pGreyscaleTable; }

---

Member Function Documentation

BOOL CWxBitmap::ArePalettesTheSame (  const LPLOGPALETTE  pLogPalette, const INT32  TransColour = -1 )  [virtual]

To see if the palette attached to this bitmap is browser compatible. It runs through the colours in a browser palette and checks to see if they are all present. The ordering is not checked and so the palette may be different from the one that we actually use. Doesn't check the flags byte, just the RGB bytes. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 03/07/97 Parameters: pLogPalette  A log palette to check the palette against [INPUTS] TransColour The transparent colour in the palette Returns: True if the bitmap has the same palette as the LOG palette. Implements OILBitmap. Definition at line 4160 of file oilbitmap.cpp. { ERROR2IF(pLogPalette == NULL,FALSE,"ArePalettesTheSame Bad LOGPALETTE param"); // Not interested in deep bitmaps UINT32 bpp = GetBPP(); if (bpp != 8) return FALSE; RebuildXPEBitmap(); // Check the palette of this bitmap against this browser palette LPRGBQUAD pPalette = GetPaletteForBitmap(); if (pPalette == NULL) return FALSE; UINT32 PaletteEntries = GetNumPaletteEntries(); if (PaletteEntries != pLogPalette->palNumEntries) return FALSE; // Check this against our browser palette BOOL PaletteOk = TRUE; for (INT32 i = 0; i < pLogPalette->palNumEntries; i++) { // If it is the transparent colour then the entry must be white if (i == TransColour) { if (pPalette[i].rgbRed != 0xFF && pPalette[i].rgbGreen != 0xFF && pPalette[i].rgbBlue != 0xFF) { PaletteOk = FALSE; break; } } else if (pPalette[i].rgbRed != pLogPalette->palPalEntry[i].peRed && pPalette[i].rgbGreen != pLogPalette->palPalEntry[i].peGreen && pPalette[i].rgbBlue != pLogPalette->palPalEntry[i].peBlue) { PaletteOk = FALSE; break; } } return PaletteOk; }

void CWxBitmap::CacheGeometry (   )

Sets up the cached info in the header so the plot routines will work fast. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 14/9/94 Parameters: None  [INPUTS] Caches  scanline widths etc in the CWxBitmap [OUTPUTS] Returns: Nothing Errors: - See also: - Definition at line 3489 of file oilbitmap.cpp. { if (BMInfo) { // For now we need to restrict the size of the bitmaps // Hopefully a KernelBitmap member along the lines of PostProcessNewBitmap(pDocument) // will be provided at some stage to do something better // For now restrict it to the length of the shorter A0 side // The minimum size is the number of pixels as millipoints // This can probably done mathematically as well LPBITMAPINFOHEADER pHeader = &(BMInfo->bmiHeader); if (pHeader->biXPelsPerMeter != 0 || pHeader->biYPelsPerMeter != 0) { const double MaxSize = 0.84; const double MaxWidth = MaxSize; const double Width = pHeader->biWidth; const double MinWidth = Width / M_MP_VAL; const double XDensity = pHeader->biXPelsPerMeter; const double RealWidth = Width / XDensity; INT32 XRecommended = (INT32)(96 * (M_MP_VAL / IN_MP_VAL)); const double MaxHeight = MaxSize; const double Height = pHeader->biHeight; const double MinHeight = Height / M_MP_VAL; const double YDensity = pHeader->biYPelsPerMeter; const double RealHeight = Height / YDensity; INT32 YRecommended = (INT32)(96 * (M_MP_VAL / IN_MP_VAL)); const double AspectRatio = XDensity / YDensity; BOOL bIsTooBig = FALSE; BOOL bIsTooSmall = FALSE; // Check the width isn't too small or large if (pHeader->biXPelsPerMeter != 0) { if (RealWidth > MaxWidth) { XRecommended = (INT32)(pHeader->biWidth / MaxWidth); bIsTooBig = TRUE; } else if (RealWidth < MinWidth) { XRecommended = (INT32)(pHeader->biWidth / MinWidth); bIsTooSmall = TRUE; } } // Check the height is neither too large nor too small, but just right if (pHeader->biXPelsPerMeter != 0) { if (RealHeight > MaxHeight) { YRecommended = (INT32)(pHeader->biHeight / MaxHeight); bIsTooBig = TRUE; } else if (RealHeight < MinHeight) { YRecommended = (INT32)(pHeader->biHeight / MinHeight); bIsTooSmall = TRUE; } } // This is gorgeous... // If it's being awkward pick a density if (bIsTooBig || bIsTooSmall) { if ((bIsTooBig && bIsTooSmall) || AspectRatio != 1.0) { // It's being really awkward so forget it and use the default pHeader->biXPelsPerMeter = 0; pHeader->biYPelsPerMeter = 0; } // From here on we know the original densities were the same. // We'll pick the density that gives us the closest to the desired size else if ((bIsTooBig && XRecommended > YRecommended) || (bIsTooSmall && XRecommended < YRecommended)) { pHeader->biXPelsPerMeter = XRecommended; pHeader->biYPelsPerMeter = XRecommended; } else { pHeader->biXPelsPerMeter = YRecommended; pHeader->biYPelsPerMeter = YRecommended; } } } ScanLineByteWidth = DIBUtil::ScanlineSize( pHeader->biWidth, pHeader->biBitCount ); BitmapSize = ScanLineByteWidth*(pHeader->biHeight); // in bytes } else { ScanLineByteWidth = 0; BitmapSize = 0; } }

void CWxBitmap::ColourSeparate32to32 (  ColourPlate *  pPlate, BYTE *  SepTables )  [virtual]

Converts the bitmap in-place from full colour 32 bpp RGB to the relevant separation returning the result as 32 bpp with correct colours for the specified plate. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> (from ColourSeparateScanline32to8) Date: 02/03/2004 Parameters: OutputContext  - The context to get the separation plate from [INPUTS] SepTables - points to the separation tables Definition at line 2395 of file oilbitmap.cpp. { ERROR3IF(SepTables == NULL, "No separation tables!?"); ERROR3IF(pPlate == NULL, "The separation ColourPlate has gone missing!"); RebuildXPEBitmap(); ERROR3IF(GetBPP() != 32, "Bitmap not 32bpp!"); DWORD NumPixels = GetWidth() * GetHeight(); BGRT* pPixel = (BGRT*)GetBitmapBits(); // --- A wee macro to find the Maximum of R,G,B, and place it into a variable called // Temp, which we define right now in function scope so it's always available // (It's undefined at the end of this function) BYTE Temp; #define TEMPMAX(R,G,B) \ { \ Temp = ((R) > (G)) ? (R) : (G); \ Temp = (Temp > (B)) ? Temp : (B); \ } // --- Izzy, Wizzy, let's get busy DWORD i; // Loop Index BYTE Ink; // Temporary variable for storing the ink value in BYTE *UCR = SepTables + 768 + 255; // UCR is the 4th table, but this points at the // END of the table for optimisation - precalcs (255 - Temp) ColourPlateType Plate = pPlate->GetType(); ColourPlateType OutputPlate = pPlate->IsMonochrome() ? COLOURPLATE_KEY : Plate; BOOL bNegate = pPlate->IsNegative(); BYTE *LUT = NULL; switch (Plate) { case COLOURPLATE_CYAN: LUT = SepTables + 0; // Cyan table is the 1st table break; case COLOURPLATE_MAGENTA: LUT = SepTables + 256; // Magenta table is the 2nd table break; case COLOURPLATE_YELLOW: LUT = SepTables + 512; // Yellow table is the 3rd table break; default: LUT = SepTables + 1024; // Black generation is the 5th table break; } PORTNOTE("cms", "Disabled XaraCMS") #ifndef EXCLUDE_FROM_XARALX BOOL PrintRGBBlackAsKey = XaraCMS::PrintRGBBlackAsKey; #else BOOL PrintRGBBlackAsKey = TRUE; #endif for (i = 0; i < NumPixels; i++) { // It's colour, so get the maximum of R,G,B into Temp TEMPMAX(pPixel[i].Red, pPixel[i].Green, pPixel[i].Blue); if (!PrintRGBBlackAsKey || Temp > 0) { switch (Plate) { case COLOURPLATE_CYAN: Ink = 255 - pPixel[i].Red; // Cyan ink is (255 - Red) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; case COLOURPLATE_MAGENTA: Ink = 255 - pPixel[i].Green; // Magenta ink is (255 - Green) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; case COLOURPLATE_YELLOW: Ink = 255 - pPixel[i].Blue; // Yellow ink is (255 - Blue) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; default: Ink = 255 - Temp; // Black ink is (255 - Temp) break; } Ink = LUT[Ink]; } else { Ink = (Plate == COLOURPLATE_KEY) ? 255 : 0; } if (bNegate) Ink = 255 - Ink; switch (OutputPlate) { case COLOURPLATE_CYAN: pPixel[i].Red = 255 - Ink; pPixel[i].Green = 255; pPixel[i].Blue = 255; break; case COLOURPLATE_MAGENTA: pPixel[i].Red = 255; pPixel[i].Green = 255 - Ink; pPixel[i].Blue = 255; break; case COLOURPLATE_YELLOW: pPixel[i].Red = 255; pPixel[i].Green = 255; pPixel[i].Blue = 255 - Ink; break; default: pPixel[i].Red = 255 - Ink; pPixel[i].Green = 255 - Ink; pPixel[i].Blue = 255 - Ink; break; } } // And finally, vape our helper macro #undef TEMPMAX }

void CWxBitmap::ColourSeparateScanline32to8 (  ColourContext *  OutputContext, BYTE *  SepTables, BYTE *  DestBuffer, Pixel32bpp *  SrcBuffer, INT32  PixelWidth )  [static]

Copies the scanline of 32bpp BGR values from SrcBuffer to DestBuffer, running the pixels through colour separation tables en route. NOTE that Src and Dest may point at the same buffer to convert in-place. Parameters: DestBuffer  - points to a destination 24bpp RGB scanline buffer [INPUTS] SrcBuffer - points to a source 24bpp RGB scanline buffer PixelWidth - The number of pixels to copy from Src to Dest The output pixels are produced in 8bpp greyscale (0=black, 255=white) format, and will occupy only the first PixelWidth bytes of the Dest buffer. If you're not colour-separating, then you should replace this function call with a simple memcpy or equivalent. Notes: ONLY handles Pixel32bpp scanlines, and expects that SepTables points at the separation tables. The CMYK separation plates could have been written generically, but I have separated out the cases in order to squeeze a bit of speed out of the inner pixel conversion loop. Definition at line 2260 of file oilbitmap.cpp. { ERROR3IF(DestBuffer == NULL || SrcBuffer == NULL || PixelWidth < 1, "Illegal params"); ERROR3IF(SepTables == NULL, "No separation tables!?"); ERROR3IF(OutputContext == NULL || OutputContext->GetColourPlate() == NULL, "The separation ColourPlate has gone missing!"); //RebuildXPEBitmap(); // --- A wee macro to find the Maximum of R,G,B, and place it into a variable called // Temp, which we define right now in function scope so it's always available // (It's undefined at the end of this function) BYTE Temp; #define TEMPMAX(R,G,B) \ { \ Temp = ((R) > (G)) ? (R) : (G); \ Temp = (Temp > (B)) ? Temp : (B); \ } // --- Izzy, Wizzy, let's get busy INT32 i; // Loop Index BYTE Ink; // Temporary variable for storing the ink value in BYTE *UCR = SepTables + 768 + 255; // UCR is the 4th table, but this points at the // END of the table for optimisation - precalcs (255 - Temp) ColourPlateType Plate = OutputContext->GetColourPlate()->GetType(); BOOL bNegate = OutputContext->GetColourPlate()->IsNegative(); BYTE *LUT = NULL; switch (Plate) { case COLOURPLATE_SPOT: for (i = 0; i < PixelWidth; i++) DestBuffer[i] = 255; return; break; case COLOURPLATE_CYAN: LUT = SepTables + 0; // Cyan table is the 1st table break; case COLOURPLATE_MAGENTA: LUT = SepTables + 256; // Magenta table is the 2nd table break; case COLOURPLATE_YELLOW: LUT = SepTables + 512; // Yellow table is the 3rd table break; default: LUT = SepTables + 1024; // Black generation is the 5th table break; } PORTNOTE("cms", "Disabled XaraCMS") #ifndef EXCLUDE_FROM_XARALX BOOL PrintRGBBlackAsKey = XaraCMS::PrintRGBBlackAsKey; #else BOOL PrintRGBBlackAsKey = TRUE; #endif for (i = 0; i < PixelWidth; i++) { // It's colour, so get the maximum of R,G,B into Temp TEMPMAX(SrcBuffer[i].Red, SrcBuffer[i].Green, SrcBuffer[i].Blue); if (!PrintRGBBlackAsKey || Temp > 0) { switch (Plate) { case COLOURPLATE_CYAN: Ink = 255 - SrcBuffer[i].Red; // Cyan ink is (255 - Red) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; case COLOURPLATE_MAGENTA: Ink = 255 - SrcBuffer[i].Green; // Magenta ink is (255 - Green) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; case COLOURPLATE_YELLOW: Ink = 255 - SrcBuffer[i].Blue; // Yellow ink is (255 - Blue) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; default: Ink = 255 - Temp; // Black ink is (255 - Temp) break; } Ink = LUT[Ink]; } else { Ink = (Plate == COLOURPLATE_KEY) ? 255 : 0; } if (bNegate) DestBuffer[i] = Ink; else DestBuffer[i] = 255 - Ink; } // And finally, vape our helper macro #undef TEMPMAX }

BOOL CWxBitmap::Convert24To8 (  RGBTRIPLE *  pPalette, UINT32  NumberOfPaletteEntries )  [virtual]

Converts the OILbitmap from its present 24bpp form into an 8bpp form which should closely match the one that was exported. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/9/96 Parameters: pPalette  - pointer to the palette in RGBTIPLE format to use when converting [INPUTS] NumberOfPaletteEntries - entries in this palette -  [OUTPUTS] Returns: True if worked ok, False otherwise Assumes that the bitmap is newly loaded in and hence can easily be deleted. Implements OILBitmap. Definition at line 2793 of file oilbitmap.cpp. { ERROR2IF(pPalette == NULL,FALSE,"KernelBitmap::Convert24To8 null pFilter"); ERROR2IF(NumberOfPaletteEntries == 0,FALSE,"KernelBitmap::Convert24To8 NumberOfPaletteEntries = 0"); RebuildXPEBitmap(); BOOL ok = TRUE; TRACEUSER("Neville", wxT("CWxBitmap::Convert24To8 NumberOfPaletteEntries = %d\n"),NumberOfPaletteEntries); LPBITMAPINFO pDestBMInfo = NULL; LPBYTE pDestBMBytes = NULL; // Ask the DIB convert class to do the conversion for us ok = DIBUtil::Convert24to8( BMInfo, BMBytes, &pDestBMInfo, &pDestBMBytes, pPalette, NumberOfPaletteEntries); if (ok) { // Free up the 24bpp version FreeDIB( BMInfo, BMBytes ); // Hot swap it for the 8bpp version BMInfo = pDestBMInfo; BMBytes = pDestBMBytes; pDestBMInfo = NULL; pDestBMBytes = NULL; ScanLineByteWidth = 0; BitmapSize = 0; // in bytes CacheGeometry(); } if (pDestBMInfo != NULL) { delete pDestBMInfo; } if (pDestBMBytes != NULL) { delete pDestBMBytes; } return ok; }

void CWxBitmap::CopyFullyTransparentFrom (  OILBitmap *  pBitmap  )  [virtual]

Implements OILBitmap. Definition at line 4274 of file oilbitmap.cpp. { if (GetWidth() != pBitmap->GetWidth() || GetHeight() != pBitmap->GetHeight() || GetBPP() != 32 || pBitmap->GetBPP() != 32) { ERROR3("Incompatible bitmaps passed to CopyFullyTransparentFrom"); return; } // Pointers to the pixel we are dealing with UINT32* pMask = (UINT32*)(pBitmap->GetBitmapBits()); UINT32* pDest = (UINT32*)GetBitmapBits(); // Loop through all the pixels for (UINT32 j=0; j < pBitmap->GetHeight(); j++) { for (UINT32 i=0; i < pBitmap->GetWidth(); i++) { // If this bit is background then set the corresponding pixel // in the output bitmap to fully transparent black if (*pMask == 0xFF000000) *pDest = 0xFF000000; // Move to the next pixel pMask++; pDest++; } } }

BOOL CWxBitmap::CreateFromwxBitmap (  wxBitmap *  pBitmap  )  [virtual]

Definition at line 3741 of file oilbitmap.cpp. { wxImage i = pBitmap->ConvertToImage(); return CreateFromwxImage(&i); }

BOOL CWxBitmap::CreateFromwxImage (  wxImage *  pImage  )  [virtual]

Definition at line 3747 of file oilbitmap.cpp. { LPBITMAPINFO bmInfo; LPBYTE bmBytes; bmInfo = AllocDIB( pImage->GetWidth(), pImage->GetHeight(), 32, &bmBytes ); if (!bmInfo || !bmBytes) return FALSE; BMInfo=bmInfo; BMBytes=bmBytes; INT32 dpi=96; double xppm = ((double)dpi * 10000.0)/254.0; bmInfo->bmiHeader.biXPelsPerMeter = (INT32)(xppm + 0.5); bmInfo->bmiHeader.biYPelsPerMeter = bmInfo->bmiHeader.biXPelsPerMeter; CacheGeometry(); unsigned char * pData=pImage->GetData(); unsigned char * pAlpha=NULL; if (pImage->HasAlpha()) pAlpha=pImage->GetAlpha(); // Reasonably rapid conversion to internal format for (UINT32 YPos = 0; YPos < GetHeight(); YPos++) { // DIBs are the wrong way up BYTE *ScanlineStart = BMBytes + ((GetHeight()-YPos-1) * ScanLineByteWidth); INT32 off=0; for (UINT32 XPos = 0; XPos < GetWidth(); XPos++) { ScanlineStart[off++] = pData[2]; //Red ScanlineStart[off++] = pData[1]; //Green ScanlineStart[off++] = pData[0]; //Blue pData+=(UINT_PTR)3; ScanlineStart[off++] = pAlpha?(255-*(pAlpha++)):0; // Alpha } } return TRUE; }

void CWxBitmap::DeleteData (  BOOL  bResetToDefault = TRUE  )  [virtual]

Deletes the actual bitmap data. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/96 Implements OILBitmap. Definition at line 3926 of file oilbitmap.cpp. { // ERROR2IF(this == OILBitmap::Default, FALSE, "Someone is trying to delete the default bitmap data"); FreeDIB( BMInfo, BMBytes ); BMInfo = NULL; BMBytes = NULL; if (bResetToDefault) { BMInfo = ((CWxBitmap*)OILBitmap::Default)->BMInfo; BMBytes = ((CWxBitmap*)OILBitmap::Default)->BMBytes; ScanLineByteWidth = ((CWxBitmap*)OILBitmap::Default)->ScanLineByteWidth; BitmapSize = ((CWxBitmap*)OILBitmap::Default)->BitmapSize; DestroyGreyscaleVersion(); DestroyContonePalette(); } return; }

BOOL CWxBitmap::DestroyMask (   )  [virtual]

Implements OILBitmap. Definition at line 3910 of file oilbitmap.cpp. { return FALSE; }

BOOL CWxBitmap::ExportBitmap (  RenderRegion *  pRegion  )  [virtual]

Implements OILBitmap. Definition at line 1152 of file oilbitmap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) RebuildXPEBitmap(); // Check the render region type if (pRegion->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSRenderRegion))) { // It's Camelot EPS - export the bitmap. if (!ExportBitmapPalette(pRegion)) // Error! return FALSE; if (!ExportBitmapData(pRegion)) // Error! return FALSE; } PORTNOTE("cmx", "Disabled CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX else if (pRegion->IsKindOf(CC_RUNTIME_CLASS(CMXRenderRegion))) { // CMX render region... get the DC CMXExportDC *pDC = (CMXExportDC *) pRegion->GetRenderDC(); // start the bitmap list thinguy if(!pDC->StartRIFFList(cmxRIFFLIST_ImageDesc)) return FALSE; // start the bitmap info section if(!pDC->StartSection(CMXExportDC::CMXSECTION_IMAGINFO)) return FALSE; // tag... if(!pDC->StartTag(cmxTAG_DescrSection_Image_ImageInfo)) return FALSE; // non-palette flag BOOL NoPal = FALSE; if(BMInfo->bmiHeader.biBitCount >= 24) NoPal = TRUE; // 32 bit pixel flag -- needs to be squished into 24 bitness // and our bitmap size value BOOL eBitmapSize = BitmapSize; BOOL Is32Bit = FALSE; if(BMInfo->bmiHeader.biBitCount == 32) { Is32Bit = TRUE; // calculate a new eBitmapSize eBitmapSize = GetWidth() * 3; if((eBitmapSize & 0x3) != 0) eBitmapSize = (eBitmapSize + 4) & ~0x3; // word align to 4 byte boundary eBitmapSize *= GetHeight(); } // write header cmxImageInfo ii; cmxImageHeader ih; cmxRIMAGEHeader rh; cmxRIMAGEPaletteHeader ph; DWORD BitmapHeaderSize = sizeof(rh) + (NoPal?0:(sizeof(ph) + sizeof(cmxRIMAGEPaletteEntry) * BMInfo->bmiHeader.biClrUsed)); ii.Type = cmxIMAGETYPE_RIMAGE; ii.Compression = 1; // dunno what that'll do. Probably'll work. ii.Size = sizeof(ih) + BitmapHeaderSize + eBitmapSize; ii.CompressedSize = sizeof(ih) + BitmapHeaderSize + eBitmapSize; pDC->WriteData(&ii, sizeof(ii)); // end tag if(!pDC->EndTag() || !pDC->WriteMinEndTag()) return FALSE; // end the bitmap info section if(!pDC->EndSection()) return FALSE; // start the bitmap data section if(!pDC->StartSection(CMXExportDC::CMXSECTION_IMAGDATA)) return FALSE; // write the header -- we have to do the tag ourselves as it's got a // 32 bit length value CMXFutureLength TagLen; if(pDC->IsThirtyTwoBit()) { pDC->WriteByte(cmxTAG_DescrSection_Image_ImageData); DWORD len = 0; pDC->WriteData(&len, sizeof(len)); TagLen.Init(pDC, - (INT32)sizeof(len), sizeof(len)); TagLen.SetLengthStartPos(pDC, - (INT32)(sizeof(len) + sizeof(BYTE))); } // do the image header ih.ImageType[0] = 'R'; ih.ImageType[1] = 'I'; ih.Size = eBitmapSize + sizeof(ih) + BitmapHeaderSize; ih.Reserved[0] = 0; ih.Reserved[1] = 0; ih.OffsetToPixels = sizeof(ih) + BitmapHeaderSize; if(!pDC->WriteData(&ih, sizeof(ih))) return FALSE; // make the bitmap header rh.Type = NoPal?cmxR_IMG_RGB:cmxR_IMG_PAL; rh.ComprType = 1; // this probably means it's got no compression, but you never know rh.Width = GetWidth(); rh.Height = GetHeight(); rh.Planes = 1; // probably right rh.BitsPerPlane = NoPal?24:BMInfo->bmiHeader.biBitCount; rh.BytesPerLine = (rh.Width * rh.BitsPerPlane) / 8; if((rh.BytesPerLine & 0x3) != 0) rh.BytesPerLine = (rh.BytesPerLine + 4) & ~0x3; // word align to 4 byte boundary rh.BufSize = eBitmapSize; rh.ComprBufSize = 0; // probably as we're not compressing rh.XPelsPerKM = rh.YPelsPerKM = 0x3d400; // random value nicked from a corel CMX file rh.PaletteOffset = NoPal?0:sizeof(rh); // starts immediatly after this rh.DataOffset = BitmapHeaderSize; //after the palette rh.StartBufOffset = 0; // no idea what this does rh.AlphaOffset = 0; // nope, haven't got one of those mate rh.MaskOffset = 0; // nor one of those if(rh.BitsPerPlane == 4 && !pDC->IsThirtyTwoBit()) { rh.Type = cmxR_IMG_PAL4; } // write the bitmap header if(!pDC->WriteData(&rh, sizeof(rh))) return FALSE; if(!NoPal) { // is this contoned? CMXRenderRegion *pR = (CMXRenderRegion *)pRegion; RGBQUAD *pPal = pR->GetAreExportingContoneBitmap() ?m_pContonePalette:BMInfo->bmiColors; // write the palette ph.Type = cmxR_PALETTE_RGB; ph.NumEntries = (WORD)BMInfo->bmiHeader.biClrUsed; if(!pDC->WriteData(&ph, sizeof(ph))) return FALSE; // palette entries for(DWORD l = 0; l < BMInfo->bmiHeader.biClrUsed; l++) { ERROR3IF(sizeof(cmxRIMAGEPaletteEntry) != 3, "wrong size of entry"); cmxRIMAGEPaletteEntry pi; pi.b = pPal[l].rgbBlue; pi.g = pPal[l].rgbGreen; pi.r = pPal[l].rgbRed; if(!pDC->WriteData(&pi, sizeof(pi))) return FALSE; } } // should do it, I suppose. // write the bitmap data if(!Is32Bit) { // this isn't 32 bit pixels, so just slap everything to the file if(!pDC->WriteData(BMBytes, BitmapSize)) return FALSE; } else { // corel doesn't support 32 bit pixels, so we have to go through // the image data reducing it to 24 bit. Oh well. BYTE Buffer[CMXREDUCEBPPBUFFERSIZE * 3]; INT32 BufLoc = 0; INT32 PixelsToGo = GetWidth() * GetHeight(); INT32 PixelsToGoInLine = GetWidth(); BYTE *Pixels = (BYTE *)BMBytes; INT32 Bytes = 0; while(PixelsToGo > 0) { // bung a pixel in the buffer Buffer[BufLoc++] = *(Pixels++); Buffer[BufLoc++] = *(Pixels++); Buffer[BufLoc++] = *(Pixels++); Pixels++; Bytes += 3; // decrement counts PixelsToGo--; PixelsToGoInLine--; // check to see if we're at the end of the line if(PixelsToGoInLine <= 0) { // check to see if we need to word align here... if((Bytes & 0x3) != 0) { INT32 Need = ((Bytes + 4) & ~0x3) - Bytes; for(INT32 l = 0; l < Need; l++) { Buffer[BufLoc++] = 0; Bytes++; } } PixelsToGoInLine = GetWidth(); // reset counter } // test to see if we've done enough if(BufLoc >= ((CMXREDUCEBPPBUFFERSIZE * 3) - 8)) // enough for another pixel or so { // write it to the file pDC->WriteData(Buffer, BufLoc); // reset counter BufLoc = 0; } } // write anything left to the file pDC->WriteData(Buffer, BufLoc); } // write the length if(pDC->IsThirtyTwoBit()) TagLen.Write(pDC); // end tag... if(!pDC->WriteMinEndTag()) return FALSE; // end the bitmap data section if(!pDC->EndSection()) return FALSE; // end the bitmap list thingy if(!pDC->EndRIFFList()) return FALSE; return TRUE; } #endif #endif // If we got here, no errors occured. return TRUE; }

BOOL CWxBitmap::ExportBitmapData (  RenderRegion *  pRegion  )  [virtual]

Exports this bitmap's image data to the given RenderRegion. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: ? Parameters: pRegion  - The Postscript RenderRegion to export to. In fact, if this is [INPUTS] not IsKindOf(CamelotEPSRenderRegion), this function will do nothing and return TRUE. Returns: TRUE for success Notes: The RenderRegion is responsible for outputting all header/trailer info about the bitmap, and for calling ExportBitmapPalette or ExportContonePalette as appropriate, if necessary. Be very careful when fiddling with this code, because it affects postscript printing as well as all EPS export formats, including Xara v1.1 "native" EPS. When exporting to postscript, this function can only handle 1,2,4,8,24,32 bpp images. If you want to COLOUR SEPARATE the output, you should call ExportSeparatedData instead. (BTW, This code is quite hideous, but I have not changed it, because it is too easy to break Postscript, AI EPS, Artworks EPS, and/or Camelot EPS by doing so) See also: CWxBitmap::ExportSeparatedData; CamelotEPSRenderRegion::DrawParallelogramBitmap Implements OILBitmap. Definition at line 1741 of file oilbitmap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) RebuildXPEBitmap(); // Check the render region type if (pRegion->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSRenderRegion))) { // It's Camelot EPS - export the bitmap. KernelDC *pDC = (KernelDC *) CCDC::ConvertFromNativeDC(pRegion->GetRenderDC()); Filter *pFilter = pDC->GetParentFilter(); // Find out if it needs to be renderable BOOL Renderable = (IS_A(pRegion, CamelotEPSRenderRegion) || pRegion->IsPrinting()); // If it is renderable, find out if we can use Level 2 features. BOOL UseLevel2 = FALSE; if (Renderable) { // WEBSTER-ranbirr-12/11/96 #ifndef WEBSTER if (pRegion->IsPrinting()) { #ifndef STANDALONE // Get the print info for this job. CCPrintInfo *pInfo = CCPrintInfo::GetCurrent(); if (pInfo != NULL) { PrintControl *pPrCtrl = pInfo->GetPrintControl(); if (pPrCtrl->GetPSLevel() == PSLEVEL_2) // Printing to a level 2 device - party on! UseLevel2 = TRUE; } #else ERROR2(FALSE,"CWxBitmap::ExportBitmapData trying to print on Viewer version!"); #endif } else #endif //webster { // Use the EPS preference. if (EPSFilter::XSEPSExportPSType == 2) UseLevel2 = TRUE; } } // Export the bitmap pixel data itself. if (!Renderable) pDC->OutputToken(_T("%Camelot: Bitmap data")); pDC->OutputNewLine(); // Do each scanline... // // NB. We add 7 to make sure we round up to the next byte for fractional bytes, // otherwise we lose pixels at the end of scanlines for bitmaps with less // than 8bpp depth. INT32 Width = ((BMInfo->bmiHeader.biWidth * BMInfo->bmiHeader.biBitCount) + 7) / 8; INT32 Height = BMInfo->bmiHeader.biHeight; INT32 Ofs = 0; // If renderable, then don't pad the data (except to the next byte boundary). INT32 Padding = Renderable ? 1 : 4; // If we're printiand trying to output 32bpp, we'll output it as 24bpp BOOL Do32bpp = pRegion->IsPrinting() && (BMInfo->bmiHeader.biBitCount == 32); if (Do32bpp) Width = BMInfo->bmiHeader.biWidth * 3; // 32bpp is converted down to 24bpp // Swap RGB data as PostScript expects it in BGR format. BOOL SwapRGB = Renderable && (BMInfo->bmiHeader.biBitCount == 24); // Expand 4bpp images to 8bpp images as the Adobe SDK imaging library does // not seem to work on some printers with 4bpp images (e.g. Canon LBP4-PS). BOOL Expand4bpp = Renderable && (BMInfo->bmiHeader.biBitCount == 4); INT32 DataSize = Width; LPBYTE pAllocatedMem = NULL; // Memory we must remember to free on exit if (SwapRGB || Do32bpp) { // We need to swap the R and B components around as PostScript expects to get // data like this: BGRBGRBGR... // So we need a buffer in which to do this pAllocatedMem = (LPBYTE) CCMalloc(Width); if (pAllocatedMem == NULL) // No more memory! return FALSE; } else if (Expand4bpp) { // We need to expand the 4bpp data to 8bpp data. // So we need a buffer in which to do this DataSize = ((BMInfo->bmiHeader.biWidth * 8) + 7) / 8; pAllocatedMem = (LPBYTE) CCMalloc(DataSize); if (pAllocatedMem == NULL) // No more memory! return FALSE; // Double buffer size } LPBYTE pBuf = pAllocatedMem; // Scanline buffer pointer - may point into the source bitmap UINT32 ScanlineSize = DIBUtil::ScanlineSize(BMInfo->bmiHeader.biWidth, BMInfo->bmiHeader.biBitCount); // If we are going to do ASCII85, get ready for it. if (UseLevel2) { if (!pDC->StartASCII85Output(TRUE)) // TRUE => RLE please // Error return FALSE; } for (INT32 i = 0; i < Height; i++) { if (Do32bpp) { // Take a copy of this scanline, skipping the Alpha channels, and reverse the // RGB ordering so that PostScript can use the data directly. INT32 k = Ofs; for (INT32 j = 0; j < Width; j += 3) { pBuf[j] = BMBytes[k + 2]; pBuf[j + 1] = BMBytes[k + 1]; pBuf[j + 2] = BMBytes[k]; k += 4; } } else if (SwapRGB) { // Take a copy of this scanline and reverse the RGB ordering so that // PostScript can use the data directly. for (INT32 j = 0; j < Width; j += 3) { pBuf[j] = BMBytes[Ofs + j + 2]; pBuf[j + 1] = BMBytes[Ofs + j + 1]; pBuf[j + 2] = BMBytes[Ofs + j]; } } else if (Expand4bpp) { // Take a copy of this 4bpp scanline and expand it to 8bpp. INT32 k = 0; for (INT32 j = 0; j < Width; j++) { pBuf[k++] = (BMBytes[Ofs + j] & 0xF0) >> 4; pBuf[k++] = BMBytes[Ofs + j] & 0xF; } } else // Just point to raw data pBuf = BMBytes + Ofs; // Write the data out, possibly encoded in ASCII85 INT32 nBytes; if (UseLevel2) // No padding needed for renderable PostScript/EPS. nBytes = pDC->OutputASCII85(pBuf, DataSize); else // Normal ASCII Hex output (or binary in Native files). nBytes = pDC->OutputRawBinary(pBuf, DataSize, Padding); if (nBytes == -1) { // Error - prob out of disc space if (pAllocatedMem != NULL) CCFree(pAllocatedMem); return FALSE; } // Update progress display if (pFilter != NULL) pFilter->UpdateExportedNodeCount(1); // Do next line Ofs += ScanlineSize; } if (UseLevel2) { if (!pDC->EndASCII85Output()) // Error return FALSE; } // Free the temp buffer if necessary. if (pAllocatedMem != NULL) CCFree(pAllocatedMem); } #endif // If we got here, no errors occured. return TRUE; }

BOOL CWxBitmap::ExportBitmapPalette (  RenderRegion *  pRegion  )  [virtual]

Exports this bitmap's palette to the given RenderRegion. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: ? Returns: TRUE for success Notes: This function outputs the data in 2 different ways, depending on whether it thinks the RenderRegion is for Renderable postscript or not. This function now handles colour separation and correction on export, by using the RenderRegion's RenderView to find an appropriate RGB output colour context to do the colour output for it. See also: CWxBitmap::ExportBitmapPaletteInternal Implements OILBitmap. Definition at line 1550 of file oilbitmap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) RebuildXPEBitmap(); // Check the render region type if (!pRegion->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSRenderRegion))) { ERROR3("ExportBitmapPalette called by non-CamelotEPSRenderRegion class"); return(TRUE); } // Sanity check. Note that we allow deep bitmaps here, as this function exports nothing // when the bitmap has no palette, including deep images. ERROR3IF((BMInfo->bmiHeader.biBitCount != 1) && (BMInfo->bmiHeader.biBitCount != 4) && (BMInfo->bmiHeader.biBitCount != 8) && (BMInfo->bmiHeader.biBitCount != 24) && (BMInfo->bmiHeader.biBitCount != 32), "Bad bitmap depth in ExportBitmap!"); // If it's a depp bitmap or it has no palette, then we return TRUE immediately if (BMInfo->bmiHeader.biBitCount > 8 || BMInfo->bmiHeader.biClrUsed < 1) return(TRUE); // Find out if it needs to be renderable (proper Adobe EPS) BOOL Renderable = (IS_A(pRegion, CamelotEPSRenderRegion) || pRegion->IsPrinting()); if (Renderable) // Renderable postscript, so output in proper Adobe format return(ExportBitmapPaletteInternal(pRegion, BMInfo->bmiHeader.biClrUsed, BMInfo->bmiColors)); // Not renderable (it's CamelotEPS), so we can output the bitmap as raw binary KernelDC *pDC = (KernelDC *) CCDC::ConvertFromNativeDC(pRegion->GetRenderDC()); pDC->OutputToken(_T("%Camelot: Bitmap palette")); pDC->OutputRawBinary((BYTE *) BMInfo->bmiColors, BMInfo->bmiHeader.biClrUsed * sizeof(RGBQUAD)); pDC->OutputNewLine(); #endif // If we got here, no errors occured. return TRUE; }

BOOL CWxBitmap::ExportBitmapPaletteInternal (  RenderRegion *  pRegion, INT32  NumColours, RGBQUAD *  pSrcCLUT )  [protected]

Exports the given palette data to the given RenderRegion Used as an internal shared function for ExportBitmapPalette and ExportContonePalette. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Moved Tim code into this shared subroutine) Date: 1/7/96 (Original code date unknown) Returns: TRUE for success The palette is exported twice - first as a greyscale CLUT, then as a colour CLUT. Notes: This function now handles colour separation and correction on export, by using the RenderRegion's RenderView to find an appropriate RGB output colour context to do the colour output for it. IF (pSrcCLUT == ContonePalette), then a GLOBAL DEFAULT colour context is used, so that the contone palette is NOT colour separated. It is expected that you will build and discard the contone palette very close to the ExportContonePalette call, so that it will be pre- separated for the current output context. Definition at line 1429 of file oilbitmap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) RebuildXPEBitmap(); // Sanity check ERROR3IF((BMInfo->bmiHeader.biBitCount != 1) && (BMInfo->bmiHeader.biBitCount != 4) && (BMInfo->bmiHeader.biBitCount != 8) && (BMInfo->bmiHeader.biBitCount != 24) && (BMInfo->bmiHeader.biBitCount != 32), "Bad bitmap depth in ExportBitmap!"); ERROR3IF(pRegion == NULL || pSrcCLUT == NULL, "Illegal NULL params"); const INT32 ClutSize = 256; // Allocate an array in which we can construct the clut. LPBYTE pCLUT = (LPBYTE) CCMalloc(ClutSize * 3); if (pCLUT == NULL) { // Out of memory ERROR3("No memory"); return FALSE; } // Find the output DC KernelDC *pDC = (KernelDC *) CCDC::ConvertFromNativeDC(pRegion->GetRenderDC()); // First, clear all entries to black memset(pCLUT, 0, ClutSize); // Find an RGB colour context to colour-separate the colours for us (if it's necessary) // (Note: If we're exporting the ContonePalette, then we assume that it is pre-separated, // and just get a simple (non-separating) RGB context instead, to avoid double-separating ColourContextRGBT *ccRGB = NULL; if (pSrcCLUT == m_pContonePalette) ccRGB = (ColourContextRGBT *) ColourManager::GetColourContext(COLOURMODEL_RGBT); else ccRGB = (ColourContextRGBT *) pRegion->GetRenderView()->GetColourContext(COLOURMODEL_RGBT); ERROR2IF(ccRGB == NULL, FALSE, "Can't get a ColourContextRGBT for EPS bitmap export"); DocColour TempCol; // BLOCK { ColourRGBT RGB; // Build the greyscale CLUT first. for (INT32 i = 0; i < NumColours; i++) { TempCol.SetRGBValue(pSrcCLUT[i].rgbRed, pSrcCLUT[i].rgbGreen, pSrcCLUT[i].rgbBlue); ccRGB->ConvertColour(&TempCol, (ColourGeneric *) &RGB); double Grey = (RGB.Red.MakeDouble() * 0.305) + (RGB.Green.MakeDouble() * 0.586) + (RGB.Blue.MakeDouble() * 0.109); pCLUT[i] = (BYTE) (Grey * 255.0); } } // Greyscale palette complete - output it as a hex string pDC->OutputNewLine(); pDC->OutputToken(_T("<")); pDC->OutputRawBinary(pCLUT, ClutSize); pDC->OutputToken(_T(">")); pDC->OutputNewLine(); // Ok, now do the colour palette. // First, clear all entries to black memset(pCLUT, 0, ClutSize * 3); // BLOCK { PColourRGBT RGB; for (INT32 i = 0; i < NumColours; i++) { TempCol.SetRGBValue(pSrcCLUT[i].rgbRed, pSrcCLUT[i].rgbGreen, pSrcCLUT[i].rgbBlue); ccRGB->ConvertColour(&TempCol, (ColourPacked *) &RGB); pCLUT[i * 3 + 0] = RGB.Red; pCLUT[i * 3 + 1] = RGB.Green; pCLUT[i * 3 + 2] = RGB.Blue; } } // RGB palette complete - output it as a hex string pDC->OutputNewLine(); pDC->OutputToken(_T("<")); pDC->OutputRawBinary(pCLUT, ClutSize * 3); pDC->OutputToken(_T(">")); pDC->OutputNewLine(); // Clean up CCFree(pCLUT); #endif // If we got here, no errors occured. return TRUE; }

BOOL CWxBitmap::ExportContonePalette (  RenderRegion *  pRegion  )  [virtual]

Exports this bitmap's contone palette to the given RenderRegion. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: ? Returns: TRUE for success You must have called BuildContonePalette before calling this function! Notes: This funmction does NOT colour separate the contone palette. However, the colour is correctly separated when you call BuildContonePalette, so it is imperative that you build the contone palette immediately prior to export, and discard it immediately afterward (i.e. don't rely on a cached version of the contone palette). See also: OILBitmap::BuildContonePalette; CWxBitmap::ExportBitmapPaletteInternal Implements OILBitmap. Definition at line 1690 of file oilbitmap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) RebuildXPEBitmap(); ERROR2IF(m_pContonePalette == NULL, FALSE, "No contone palette to export!"); // If it's Camelot EPS, then export the bitmap if (pRegion->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSRenderRegion))) return(ExportBitmapPaletteInternal(pRegion, BMInfo->bmiHeader.biClrUsed, m_pContonePalette)); #endif // All ok return TRUE; }

BOOL CWxBitmap::ExportSeparatedData (  RenderRegion *  pRegion, BYTE *  SepTables )  [virtual]

Exports this bitmap's image data to the given RenderRegion, colour separating to an 8bpp image as it does so. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Parameters: pRegion  - The Postscript RenderRegion to export to. In fact, if this is [INPUTS] not IsKindOf(CamelotEPSRenderRegion), this function will do nothing and return TRUE. SepTables - See ExportBitmapData. This function should ONLY be called with a valid SepTabls pointer, from ExportBitmapData. Returns: TRUE for success This function is the colour-separating analogue of ExportBitmapData. It is only (currently) used when printing to postscript. Notes: Separated bitmap data is ALWAYS in the form of a greyscale 8 bits per pixel This function can handle any input bitmap depth (1/4/8/24/32) which CWxBitmap::ReadPixel supports. This function may only be called when: SepTables != NULL pRegion->GetRenderView()->GetColourPlate()->GetType() is a separation plate (C/M/Y/K or Spot). Implementation: We use ReadScanline32bpp to get the bitmap data in a generic 32bpp format, then pass a generic colour separation engine over it to generate a generic 8bpp greyscale separated bitmap. We could be more efficient for low bpp bitmaps, but this would just introduce more special-cases, and more chance of it not working in some circumstances. See also: CWxBitmap::ExportBitmapData Implements OILBitmap. Definition at line 1986 of file oilbitmap.cpp. { #ifndef STANDALONE ERROR3IF(pRegion == NULL || SepTables == NULL, "Illegal NULL params"); if (!pRegion->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSRenderRegion))) { ERROR3("Not a CamelotEPSRenderRegion derived RenderRegion - bitmap not exported"); return(TRUE); // Return success - don't shaft the whole print just for one bitmap } RebuildXPEBitmap(); KernelDC *pDC = (KernelDC *) CCDC::ConvertFromNativeDC(pRegion->GetRenderDC()); Filter *pFilter = pDC->GetParentFilter(); // If it is renderable, find out if we can use Level 2 features. BOOL UseLevel2 = FALSE; BOOL Renderable = (IS_A(pRegion, CamelotEPSRenderRegion) || pRegion->IsPrinting()); if (Renderable) { // WEBSTER-ranbirr-12/11/96 #ifndef WEBSTER if (pRegion->IsPrinting()) { // Get the print info for this job. CCPrintInfo *pInfo = CCPrintInfo::GetCurrent(); if (pInfo != NULL) { PrintControl *pPrCtrl = pInfo->GetPrintControl(); UseLevel2 = (pPrCtrl->GetPSLevel() == PSLEVEL_2); } } else #endif //webster UseLevel2 = (EPSFilter::XSEPSExportPSType == 2); // Use the EPS preference. } // Export the bitmap pixel data itself. if (!Renderable) pDC->OutputToken(_T("%Camelot: Bitmap data")); pDC->OutputNewLine(); // Get some useful constants... // const INT32 BitsPerPixel = BMInfo->bmiHeader.biBitCount; const INT32 PixelWidth = BMInfo->bmiHeader.biWidth; const INT32 PixelHeight = BMInfo->bmiHeader.biHeight; const INT32 ByteWidth = PixelWidth; // If we have to change the scanlines in any way, we'll use a temporary scanline buffer // which can hold a full scanline of 8bpp pixels BYTE *pOutputBuffer = (BYTE *) CCMalloc(ByteWidth); if (pOutputBuffer == NULL) { ERROR3("Scanline buffer allocation failed"); return(FALSE); } Pixel32bpp *pInputBuffer = (Pixel32bpp *) CCMalloc(PixelWidth * sizeof(Pixel32bpp)); if (pInputBuffer == NULL) { ERROR3("No memory for 32bpp separation scanline"); return(FALSE); } // If we are going to do ASCII85, get ready for it. if (UseLevel2 && !pDC->StartASCII85Output(TRUE)) // TRUE => RLE please { ERROR3("StartASCII85Output failed"); return(FALSE); } // If separating, find a colour context for the separation to use ColourContext *OutputContext = NULL; if (SepTables != NULL) { ERROR3IF(pRegion->GetRenderView() == NULL, "Darn"); OutputContext = pRegion->GetRenderView()->GetColourContext(COLOURMODEL_RGBT); ERROR3IF(OutputContext == NULL, "Double Darn"); } INT32 nBytes; for (INT32 y = 0; y < PixelHeight; y++) { GetScanline32bpp(y, TRUE, pInputBuffer); ColourSeparateScanline32to8(OutputContext, SepTables, pOutputBuffer, pInputBuffer, PixelWidth); // Write the data out, possibly encoded in ASCII85 if (UseLevel2) nBytes = pDC->OutputASCII85(pOutputBuffer, ByteWidth); else nBytes = pDC->OutputRawBinary(pOutputBuffer, ByteWidth, (Renderable) ? 1 : 4); if (nBytes == -1) { ERROR3("EPS output failed - Out of disc space?"); CCFree(pOutputBuffer); return(FALSE); } // Update progress display if (pFilter != NULL) pFilter->UpdateExportedNodeCount(1); } CCFree(pInputBuffer); CCFree(pOutputBuffer); if (UseLevel2 && !pDC->EndASCII85Output()) { ERROR3("EndASCII85Output failed"); return(FALSE); } return(TRUE); #else ERROR2(FALSE,"CWxBitmap::SeparateBitmapData being called in Viewer version!"); #endif }

BOOL CWxBitmap::ExportSeparatedPalette (  RenderRegion *  pRegion  )  [virtual]

Exports a greyscale 8bpp palette suitable for use by the bitmaps output by ExportSeparatedData. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 2/7/96 Parameters: pRegion  - The render region to export to [INPUTS] Returns: TRUE for success Notes: This function is very specialised, for handling the output of a palette for an 8bpp greyscale seaparation plate of a bitmap to be output with OutputSeparatedData. See CamelotEPSRenderRegion::DrawParallelogramBitmap for the only code which should be calling this function. Returns: Errors: Many ERROR3's - this bitmap must be deep, we must be printing, there must be a valid ColourPlate for separating the output. See also: CWxBitmap::ExportBitmapPalette; CWxBitmap::ExportSeparatedData Implements OILBitmap. Definition at line 1621 of file oilbitmap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(pRegion == NULL, "Illegal NULL params"); if (!pRegion->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSRenderRegion))) { ERROR3("ExportBitmapPalette called by non-CamelotEPSRenderRegion class"); return(TRUE); } // Sanity checks ERROR3IF(!pRegion->IsPrinting(), "ExportSeparatedBitmapPalette called when not printing?"); ERROR3IF(pRegion->GetRenderView() == NULL, "No render view"); ERROR3IF(pRegion->GetRenderView()->GetColourPlate() == NULL, "Not colour separating in ExportSeparatedBitmapPalette"); RebuildXPEBitmap(); KernelDC *pDC = (KernelDC *) CCDC::ConvertFromNativeDC(pRegion->GetRenderDC()); BYTE pCLUT[256 * 3]; INT32 i; // Do a greyscale intensity CLUT for (i = 0; i < 256; i++) pCLUT[i] = i; pDC->OutputNewLine(); pDC->OutputToken(_T("<")); pDC->OutputRawBinary(pCLUT, 256); pDC->OutputToken(_T(">")); pDC->OutputNewLine(); // And do a 24bit RGB CLUT for (i = 0; i < 256*3; i+=3) pCLUT[i] = pCLUT[i+1] = pCLUT[i+2] = i/3; pDC->OutputNewLine(); pDC->OutputToken(_T("<")); pDC->OutputRawBinary(pCLUT, 256 * 3); pDC->OutputToken(_T(">")); pDC->OutputNewLine(); #endif return(TRUE); }

void CWxBitmap::ExtractBitsAndInfo (  LPBYTE *  ppBytes, LPBITMAPINFO *  ppInfo )

To extract the bitmap data for use elsewhere, sets them to null so that the CWxBitmap object can be deleted. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/8/2000 Parameters: the  bytes and bitmapinfo of this bitmap [OUTPUTS] Returns: - Definition at line 4221 of file oilbitmap.cpp. { RebuildXPEBitmap(); *ppBytes = BMBytes; *ppInfo = BMInfo; BMBytes = NULL; BMInfo = NULL; }

void CWxBitmap::GenerateGreyscaleTable (   )  [virtual]

Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/96 Implements OILBitmap. Definition at line 3983 of file oilbitmap.cpp. { RebuildXPEBitmap(); // if (GetBPP() != 8) if (GetBPP()>8) return; UINT32 bpp = GetBPP() ; if (m_pGreyscaleTable != NULL) return; m_pGreyscaleTable = new BYTE[1<<bpp]; if (m_pGreyscaleTable == NULL) return; for (INT32 i=0; i<1<<bpp; i++) { double R = BMInfo->bmiColors[i].rgbRed; double G = BMInfo->bmiColors[i].rgbGreen; double B = BMInfo->bmiColors[i].rgbBlue; m_pGreyscaleTable[i] = BYTE((R * 0.305) + (G * 0.586) + (B * 0.109)); // TRACEUSER( "Will", _T("Intensity[%d] = %d\n"), i, m_pGreyscaleTable[i]); } }

virtual ADDR CWxBitmap::GetBitmapBits (   )  [inline, virtual]

Implements OILBitmap. Definition at line 149 of file oilbitmap.h. { return (ADDR)BMBytes; }

LPBITMAPINFO CWxBitmap::GetBitmapInfo (   )  [virtual]

To get at the BITMAPINFO palette that this bitmap may have. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 03/07/97 Returns: The BITMAPINFO for this bitmap or null. BITMAPINFO consists of:- BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[1]; Implements OILBitmap. Definition at line 4083 of file oilbitmap.cpp. { RebuildXPEBitmap(); return BMInfo; }

LPBITMAPINFOHEADER CWxBitmap::GetBitmapInfoHeader (   )  [virtual]

To get at the BITMAPINFOHEADER that this bitmap should have. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 03/07/97 Returns: The bitmap header for this bitmap or null. BITMAPINFO consists of:- BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[1]; Implements OILBitmap. Definition at line 4133 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo == NULL) return NULL; // Return the BITMAPINFOHEADER for this bitmap return &BMInfo->bmiHeader; }

UINT32 CWxBitmap::GetBPP (  RenderRegion *  pRegion = NULL  )  [virtual]

Finds the colour resolution of this bitmap (or, if PRegion is specified, the colour resolution at which this bitmap should be output). Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: pRegion  - NULL to get the real BPP of this bitmap [INPUTS] else points to the render region which will be rendering the bitmap - if the region is colour-separating, then the returned BPP will be set to the actual export BPP that will/should be used (i.e. deep colour bitmaps are generally colour separated to an 8bpp greyscale bitmap) Returns: The number of Bits per pixel of this bitmap Errors: - See also: - Implements OILBitmap. Definition at line 637 of file oilbitmap.cpp. { RebuildXPEBitmap(); // Currently, we colour-separate to the same number of BPP as the source bitmap, // so we always return the same value. if (BMInfo == NULL) return 0; return BMInfo->bmiHeader.biBitCount; }

UINT32 CWxBitmap::GetHeight (  void   )  [virtual]

Retrieve information on this bitmap. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Returns: The Pixel Height of this bitmap See also: CWxBitmap::GetInfo Implements OILBitmap. Definition at line 552 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo == NULL) return(0); return(BMInfo->bmiHeader.biHeight); }

UINT32 CWxBitmap::GetHorizontalDPI (   )  [virtual]

Retrieve information on this bitmap. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/97 Returns: The Horizontal DPI of this bitmap See also: CWxBitmap::GetInfo Implements OILBitmap. Definition at line 573 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo == NULL) return 96; INT32 PelW = BMInfo->bmiHeader.biXPelsPerMeter; if (PelW <= 0) PelW = DEFAULT_PIXEL_SIZE; UINT32 dpi = (UINT32)((((double)PelW * 254.0)/10000.0) + 0.5); // round up the result return dpi; }

BOOL CWxBitmap::GetInfo (  BitmapInfo *  Info, RenderRegion *  pRegion = NULL )  [virtual]

Kernel code can call this to obtain information about the bitmap in a platform- independent way. This function is implemented differently on different OIL layers. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: ?/9/94 Parameters: pRegion  - NULL to get the real BPP of this bitmap [INPUTS] else points to the render region which will be rendering the bitmap - if the region is colour-separating, then the returned BPP will be set to the actual export BPP that will/should be used (i.e. deep colour bitmaps are generally colour separated to an 8bpp greyscale bitmap) Output: *Info gets updated. Returns: TRUE if worked, FALSE if failed (e.g. no attached bitmap). If you only need width/height/bpp/paletteentries, then see SeeAlso Returns: Errors: SetError NOT called. Scope: Public See also: CWxBitmap::GetWidth; CWxBitmap::GetHeight; CWxBitmap::GetBPP; CWxBitmap::GetNumPaletteEntries Implements OILBitmap. Definition at line 452 of file oilbitmap.cpp. { ERROR3IF(Info == NULL, "Illegal NULL param"); RebuildXPEBitmap(); if (BMInfo && BMBytes && !m_bNeedsXPERebuild) { Info->PixelWidth = GetWidth(); Info->PixelHeight = GetHeight(); Info->PixelDepth = GetBPP(pRegion); Info->NumPaletteEntries = GetNumPaletteEntries(); INT32 PelW = BMInfo->bmiHeader.biXPelsPerMeter; if (PelW==0) PelW = DEFAULT_PIXEL_SIZE; INT32 PelH = BMInfo->bmiHeader.biYPelsPerMeter; if (PelH==0) PelH = DEFAULT_PIXEL_SIZE; if ( (PelW<0) || (PelH<0) ) { ERROR3("Bad pixel size"); return FALSE; } // Karim 27/07/2000 // If PelW and PelH is 3780, then we take that to mean 96 pix-per-inch, // which equates to 750 mp-per-pix. // This means that if (PelW == 3780 && PelH == 3780) { Info->RecommendedWidth = Info->PixelWidth * 750; Info->RecommendedHeight = Info->PixelHeight * 750; } // otherwise, use our non-special-case calculations. else { //Info->RecommendedWidth = Mul32Div32( Width, MILLIS_PER_METRE, PelW ); //Info->RecommendedHeight= Mul32Div32( Height, MILLIS_PER_METRE, PelH ); // Try and round the value up or down rather than always rounding down which // gives problem on repeated loading/saving and potentially on the dpi calculation double RecWidth = ((double)Info->PixelWidth * M_MP_VAL)/(double)PelW; double RecHeight = ((double)Info->PixelHeight * M_MP_VAL)/(double)PelH; Info->RecommendedWidth = (INT32)(RecWidth + 0.5); Info->RecommendedHeight= (INT32)(RecHeight + 0.5); } // this figure should probably include the BMInfo structure, but its size // is not easily obtained Info->MemoryUsed = BMInfo->bmiHeader.biSizeImage; return TRUE; } return FALSE; }

UINT32 CWxBitmap::GetNumPaletteEntries (   )  [virtual]

Retrieve information on this bitmap. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Returns: The number of palette entries used by this bitmap If this is a deep-colour bitmap (not paletted) will return 0 If this is a non-paletted (greyscale) bitmap, will return 0 See also: CWxBitmap::GetInfo Implements OILBitmap. Definition at line 1087 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo != NULL && BMInfo->bmiHeader.biBitCount <= 8) { // 8 bpp or less - can have a palette return(BMInfo->bmiHeader.biClrUsed); } // We've got a problem, or it has no palette - return 0 return(0); }

LPRGBQUAD CWxBitmap::GetPaletteForBitmap (   )  [virtual]

To get at the RGBQUAD palette that this bitmap may have. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 03/07/97 Returns: The palette for this bitmap or null. BITMAPINFO consists of:- BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[1]; Implements OILBitmap. Definition at line 4104 of file oilbitmap.cpp. { // Not interested in deep bitmaps if (GetBPP() > 8) return NULL; RebuildXPEBitmap(); if (BMInfo == NULL) return NULL; // Return the palette from the BITMAPINFO structure return &(BMInfo->bmiColors[0]); }

BOOL CWxBitmap::GetPaletteUsage (  INT32 *  UsageBuf  )  [virtual]

Find out how many times each palette entry is used in the bitmap. This is currently used when rendering paletted images to PostScript. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/95 Parameters: pUsageBuf  - array of longs big enough to hold the usage stats of the [OUTPUTS] palette for this bitmap. Returns: TRUE if ok; FALSE if an error occured (e.g. this is not a paletted bitmap!) Errors: Not a paletted bitmap. See also: CWxBitmap::GetScanlineMask Implements OILBitmap. Definition at line 3809 of file oilbitmap.cpp. { ERROR3("CWxBitmap::GetPaletteUsage is unimplemented"); return(FALSE); /* I can't see ANYTHING in this code which is even remotely likely to work! --- // Make sure this is a paletted image if ((BMInfo->bmiHeader.biBitCount < 4) || (BMInfo->bmiHeader.biBitCount > 8) || (BMInfo->bmiHeader.biClrUsed == 0)) { // This bitmap does not have a palette! return FALSE; } CacheGeometry(); if (BytesPerPixelShift !=-1) return FALSE; if ((BytesPerPixelShift < 0) || (BytesPerPixelShift > 2)) return FALSE; const UINT32 Width = BMInfo->bmiHeader.biWidth; const UINT32 Height = BMInfo->bmiHeader.biHeight; INT32 Index = 0; // Special case for 4bpp bitmaps BOOL Is4bpp = (BMInfo->bmiHeader.biBitCount == 4); for (UINT32 x = 0; x < Width; x++) { for (UINT32 y = 0; y > Height; y++) { INT32 p = (y * ScanLineByteWidth) + (x << BytesPerPixelShift); if (p < BitmapSize) { if (Is4bpp) { } else { switch (BytesPerPixelShift) { case 0: Index = (INT32)(*( ((LPBYTE)(BMBytes + p))) <<24 ); break; case 1: Index = (INT32)(*( ((LPWORD)(BMBytes + p))) <<16 ); break; case 2: Index = (INT32)(*( ((LPDWORD)(BMBytes + p))) ); break; } } UsageBuf[Index]++; } } } ENSURE(FALSE,"CWxBitmap::ReadPixel memory address out of range"); return(0); */ }

INT32 CWxBitmap::GetRecommendedHeight (   )  [virtual]

Finds the recommended height of the bitmap. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Returns: The current recommended height of the bitmap in Millipoints Implements OILBitmap. Definition at line 950 of file oilbitmap.cpp. { RebuildXPEBitmap(); const UINT32 Height = BMInfo->bmiHeader.biHeight; INT32 PelH = BMInfo->bmiHeader.biYPelsPerMeter; if (PelH==0) PelH = DEFAULT_PIXEL_SIZE; if ( (PelH<0) ) { ERROR3IF(TRUE, "Bad pixel size"); return FALSE; } double RecHeight = ((double)Height * M_MP_VAL)/(double)PelH; return (INT32)(RecHeight + 0.5); }

INT32 CWxBitmap::GetRecommendedWidth (   )  [virtual]

Finds the recommended width of the bitmap. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Returns: The current recommended width of the bitmap in Millipoints Implements OILBitmap. Definition at line 919 of file oilbitmap.cpp. { RebuildXPEBitmap(); const UINT32 Width = BMInfo->bmiHeader.biWidth; INT32 PelW = BMInfo->bmiHeader.biXPelsPerMeter; if (PelW==0) PelW = DEFAULT_PIXEL_SIZE; if ( (PelW<0) ) { ERROR3IF(TRUE, "Bad pixel size"); return 0; } double RecWidth = ((double)Width * M_MP_VAL)/(double)PelW; return (INT32)(RecWidth + 0.5); }

BOOL CWxBitmap::GetScanline32bpp (  UINT32  YPos, BOOL  UsePalette, Pixel32bpp *  Scanline )  [virtual]

Copies a scanline out of this bitmap into the given 32bpp buffer. The buffer must be no less than CWxBitmap::GetWidth() entries wide. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/96 Parameters: YPos  - The y position of the scanline in the bitmap [INPUTS] UsePalette -Ignored for deep bitmaps For <=8bpp bitmaps, if this value is: FALSE, the bitmap's palette will be ignored, and the actual pixel (palette index) value will be returned as a greyscale RGB value TRUE, the pixel index value will be used to retrieve the 24bpp palette entry for the pixel, if a palette is available. Scanline  - will be filled in with 32bpp pixel values on return [OUTPUTS] Returns: TRUE for success The scanline will be converted up from 1, 4, 8, 24, or 32bpp into the generic Pixel32bpp format. Notes: This function basically just calls ReadPixel for all pixels in the scanline See also: CWxBitmap::ReadPixel32bpp Implements OILBitmap. Definition at line 2140 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(YPos < 0 || YPos > GetHeight(), "Illegal Y position"); ERROR3IF(Scanline == NULL, "Illegal NULL param"); for (UINT32 XPos = 0; XPos < GetWidth(); XPos++) Scanline[XPos] = ReadPixel32bpp(XPos, YPos, UsePalette); return(TRUE); }

BOOL CWxBitmap::GetScanlineMaskBits (  INT32  ScanlineY, LPBYTE  ScanlineBuf )  [virtual]

Given a palette. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/95 Parameters: PaletteEntry  - which entry to build a mask for. [INPUTS] ScanlineY - the scanline to get the mask for. (0 => bottom line of bitmap) ScanlineBuf  - where to put the 1bpp mask - this should be large enough to [OUTPUTS] hold one scanline's worth of mask. Returns: TRUE if successful; FALSE if not (e.g. this is not a paletted bitmap). Errors: Not a paletted bitmap See also: CWxBitmap::GetPaletteUsage Implements OILBitmap. Definition at line 3905 of file oilbitmap.cpp. { return TRUE; }

UINT32 CWxBitmap::GetScanlineSize (   )  [virtual]

To determine the memory allocation needed to hold a single scanline of this bitmap. This is a convenient interface onto DIBUtil::ScanlineSize. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Returns: The size, in BYTES, of a scanline from this bitmap, including any padding bytes that may be necessary to achieve platform-dependant formatting of scanlines. (e.g. in Windows, scanlines are padded out to a word boundary) i.e. it returns the byte offset from the start of one scanline to the start of the next scanline. See also: DIBUtil::ScanlineSize Implements OILBitmap. Definition at line 1122 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo == NULL) return(0); return(DIBUtil::ScanlineSize(GetWidth(), GetBPP())); }

BOOL CWxBitmap::GetTransparencyIndex (  INT32 *  pIndex  )  [virtual]

Finds the Transparent index colour of a bitmap if one exists. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/6/96 Returns: TRUE if the Index was set, FALSE if there is no transparent index Implements OILBitmap. Definition at line 713 of file oilbitmap.cpp. { ERROR3IF(pIndex == NULL, "GetTransparencyIndex called with NULL index pointer"); if (pIndex == NULL) return FALSE; RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL, "GetTransparencyIndex called when BMInfo is NULL"); if (BMInfo == NULL) return FALSE; INT32 NumCols = 0; switch (GetBPP()) { case 1: NumCols = 2; break; case 4: NumCols = 16; break; case 8: NumCols = 256; break; default: ERROR3("Bad colour depth in GetTransparencyIndex"); break; } RGBQUAD* pCols = BMInfo->bmiColors; *pIndex = -1; // Look through the Colour table for an entry that has the T channel set to 255 for (INT32 i=0; i<NumCols; i++) { if (pCols[i].rgbReserved == 0xFF) { *pIndex = i; // break; } } return ((*pIndex) >= 0); }

UINT32 CWxBitmap::GetVerticalDPI (   )  [virtual]

Retrieve information on this bitmap. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/97 Returns: The Vertical DPI of this bitmap See also: CWxBitmap::GetInfo Implements OILBitmap. Definition at line 599 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo == NULL) return(0); INT32 PelH = BMInfo->bmiHeader.biYPelsPerMeter; if (PelH <= 0) PelH = DEFAULT_PIXEL_SIZE; UINT32 dpi = (UINT32)((((double)PelH * 254.0)/10000.0) + 0.5); // round up the result return dpi; }

UINT32 CWxBitmap::GetWidth (  void   )  [virtual]

Retrieve information on this bitmap. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/96 Returns: The Pixel Width of this bitmap See also: CWxBitmap::GetInfo Implements OILBitmap. Definition at line 527 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo == NULL) return(0); return(BMInfo->bmiHeader.biWidth); }

BOOL CWxBitmap::HasBeenDeleted (   )  [virtual]

Returns whether or not the actual bitmap data has been deleted. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/96 Implements OILBitmap. Definition at line 3960 of file oilbitmap.cpp. { if (this == OILBitmap::Default) return FALSE; // Can't delete the default bitmap ERROR3IF(OILBitmap::Default == NULL, "The default bitmap is NULL"); if (OILBitmap::Default == NULL) return TRUE; // If we are using the default bitmap data, then we must have been deleted return (BMBytes == ((CWxBitmap*)OILBitmap::Default)->BMBytes); }

BOOL CWxBitmap::ImportBitmap (  Filter *  pFilter, const BitmapInfo *  pInfo, INT32  BitmapType )  [virtual]

Import a bitmap object using the given bitmap specification and the import filter provided. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/94 Parameters: pFilter  - the filter object to import with. [INPUTS] pInfo - details of the bitmap to import, or NULL if this should be obtained from the file. BitmapType - the type of bitmap data in the file. This is usually 0, and exists as a way of supporting platform-dependent bitmap arrangements on different platforms. Returns: TRUE if the bitmap was imported ok; FALSE if not. Errors: Out of memory, error in file data. See also: CWxBitmap::ExportBitmap Implements OILBitmap. Definition at line 2907 of file oilbitmap.cpp. { // Check to see what the specified filter type is and take the appropriate action // If a bitmap type of filter (derived off BaseBitmapFilter) e.g. BMPFilter or // AccusoftFilters then pInfo will be NULL and we just need to load the bitmap in // using the specified filter. if (pFilter->IsKindOf(CC_RUNTIME_CLASS(BaseBitmapFilter))) { BaseBitmapFilter* pBitmapFilter = (BaseBitmapFilter*)pFilter; // Try to import bitmap using the required bitmap filter class. // Tell it to import into this CWxBitmap. if (pBitmapFilter->ReadFromFile(this)) { CacheGeometry(); return TRUE; } else return FALSE; } if (!pFilter->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSFilter))) { ENSURE(FALSE, "Trying to import a bitmap with a non-Camelot EPS filter"); return FALSE; } // Sanity checks ENSURE((pInfo->PixelDepth == 1) || (pInfo->PixelDepth == 4) || (pInfo->PixelDepth == 8) || (pInfo->PixelDepth == 24) || (pInfo->PixelDepth == 32), "Bad bitmap depth in ImportBitmap!"); if ((pInfo->NumPaletteEntries > 0) && (pInfo->PixelDepth > 8)) { ENSURE(FALSE, "We don't support palettes on bitmaps >8bpp!"); } // if (!IsUserName("Alex")) // { // ENSURE(BitmapType == 0, "Unknown bitmap type in CWxBitmap::ImportBitmap"); // if (BitmapType != 0) // return FALSE; // } CamelotEPSFilter *pEPSFilter = (CamelotEPSFilter *) pFilter; ENSURE((BMInfo == NULL) && (BMBytes == NULL), "Trying to import into an existing bitmap"); // Allocate memory for bitmap BMInfo = AllocDIB(pInfo->PixelWidth, pInfo->PixelHeight, pInfo->PixelDepth, &BMBytes, NULL); if (BMInfo == NULL) { // Out of memory ENSURE(FALSE, "Failed to allocate memory to import bitmap!"); return FALSE; } //BMInfo->bmiHeader.biXPelsPerMeter = Mul32Div32(pInfo->PixelWidth, MILLIS_PER_METRE, // pInfo->RecommendedWidth); //BMInfo->bmiHeader.biYPelsPerMeter = Mul32Div32(pInfo->PixelHeight, MILLIS_PER_METRE, // pInfo->RecommendedHeight); // Use the conversion value defined in units.h so that we are consistent // Also try and round up as well as down double xppm = ((double)pInfo->PixelWidth * M_MP_VAL)/ (double)(pInfo->RecommendedWidth); double yppm = ((double)pInfo->PixelHeight * M_MP_VAL)/ (double)(pInfo->RecommendedHeight); BMInfo->bmiHeader.biXPelsPerMeter = (INT32)(xppm + 0.5); BMInfo->bmiHeader.biYPelsPerMeter = (INT32)(yppm + 0.5); if ((BMInfo->bmiHeader.biXPelsPerMeter < 0) || (BMInfo->bmiHeader.biYPelsPerMeter < 0)) { ENSURE(FALSE, "Bad pixel size"); return FALSE; } // Header is done; read the palette data if we need to if (((pInfo->PixelDepth <= 8)) && (pInfo->NumPaletteEntries > 0)) { if (!pEPSFilter->ImportBinary((BYTE *) BMInfo->bmiColors, BMInfo->bmiHeader.biClrUsed * sizeof(RGBQUAD))) { // Error in hex data return FALSE; } } // Set the information up CacheGeometry(); // And read in the image data // if (IsUserName("Alex")) if (BitmapType !=0) return(TRUE); // Read in the Bitmap info if (pFilter->IsKindOf(CC_RUNTIME_CLASS(CamelotNativeEPSFilter))) { // Load it in scan line at a time please INT32 NumScanLines = pInfo->PixelHeight; for (INT32 i=0; i<NumScanLines; i++) { // read a scan line in if (!pEPSFilter->ImportBinary(BMBytes + (i*ScanLineByteWidth), ScanLineByteWidth)) return FALSE; } // all worked return TRUE; } else { // Load it all in, in one go. return pEPSFilter->ImportBinary(BMBytes, BMInfo->bmiHeader.biSizeImage); } // Should not get here really. return FALSE; }

BOOL CWxBitmap::ImportBitmap (  CCLexFile *  pFile, BaseBitmapFilter *  pBitmapFilter, BaseCamelotFilter *  pFilter, BOOL  IsCompressed )  [virtual]

Imports a bitmap object using the import filter provided. It is used by the web/native filters to pull out a bitmap definition from inside a bitmap definition record. IsCompressed is only used for BMP/BMPZIP type bitmaps at present. Assumes: pFile has already been opened up for reading pFilter has been set up for reading the data e.g. progress bar. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 20/06/96 Parameters: pFile  - the file to read the data from [INPUTS] pBitmapFilter - the bitmap filter object to import the bitmap with. pFilter - the BaseCamelotFilter which provides functions like progress update IsCompressed - Flag to say the bitmap is compressed or not. Returns: TRUE if the bitmap was imported ok; FALSE if not. Errors: Out of memory, error in file data. See also: CWxBitmap::ExportBitmap Implements OILBitmap. Definition at line 2865 of file oilbitmap.cpp. { ERROR2IF(pFile == NULL,FALSE,"CWxBitmap::ImportBitmap null pFile"); ERROR2IF(pBitmapFilter == NULL,FALSE,"CWxBitmap::ImportBitmap null pBitmapFilter"); ERROR2IF(pFilter == NULL,FALSE,"CWxBitmap::ImportBitmap null pFilter"); // Try to import bitmap using the required bitmap filter class. // Tell it to import into this CWxBitmap. if (pBitmapFilter->ReadFromFile(this, pFilter, pFile, IsCompressed)) { CacheGeometry(); return TRUE; } return FALSE; }

BOOL CWxBitmap::IsBrowserPalette (   )  [virtual]

To see if the palette attached to this bitmap is browser compatible. It runs through the colours in a browser palette and checks to see if they are all present. The ordering is not checked and so the palette may be different from the one that we actually use. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/06/97 Returns: True if the bitmap has a browser compatible palette. Implements OILBitmap. Definition at line 4023 of file oilbitmap.cpp. { // Not interested in deep bitmaps if (GetBPP() != 8) return FALSE; RebuildXPEBitmap(); UINT32 PaletteEntries = GetNumPaletteEntries(); if (PaletteEntries < 216) return FALSE; // Borrow the code from PaletteManager::MakePaletteBrowserCompatible TRACEUSER( "Neville", wxT("Checking 216 colours\n") ); BOOL found = FALSE; for (INT32 r = 0; r <= 100; r += 20) { for (INT32 g = 0; g <=100; g += 20) { for (INT32 b = 0; b <= 100; b += 20) { BYTE ra = BYTE((double(r)/100)*255.0); BYTE ga = BYTE((double(g)/100)*255.0); BYTE ba = BYTE((double(b)/100)*255.0); for (UINT32 i = 0; i < PaletteEntries && !found; i++) { found = BMInfo->bmiColors[i].rgbRed == ra && BMInfo->bmiColors[i].rgbGreen == ga && BMInfo->bmiColors[i].rgbBlue == ba; } if (!found) { TRACEUSER( "Neville", wxT("Colour not found - %d %d %d\n") ,r , g, b ); return FALSE; } } } } // reached here so found all 216 colours TRACEUSER( "Neville", wxT("216 colours check finished\n") ); return TRUE; }

BOOL CWxBitmap::IsTransparent (  void   )  [virtual]

Determines if a bitmap is not totally opaque. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 16/03/2004 Returns: TRUE if the bitmap has any non-opaque pixels Implements OILBitmap. Definition at line 774 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL, "IsTransparent called when BMInfo is NULL"); if (BMInfo == NULL) return(FALSE); if (GetBPP() <= 8) { INT32 TranspIndex; // If the bitmap doesn't have a transparency index then it is opaque if (!GetTransparencyIndex(&TranspIndex)) return(FALSE); switch (GetBPP()) { case 1: { BYTE* pBits = (BYTE*)(GetBitmapBits()); UINT32 FullBytes = GetWidth() >> 3; UINT32 Height = GetHeight(); UINT32 ScanLen = GetScanlineSize(); BYTE Mask = 0xFF >> (7-(GetWidth() - (FullBytes << 3))); if (TranspIndex == 0) { for (UINT32 y = 0; y < Height; y++) { UINT32 x; for (x = 0; x < FullBytes; x++) { if (pBits[x] != 0xFF) // If the 8 pixels are not all the opaque index return(TRUE); // then we are transparent } if (Mask) { if ((pBits[x] & Mask) != Mask) return(TRUE); } pBits += ScanLen; } } else { for (UINT32 y = 0; y < Height; y++) { UINT32 x; for( x = 0; x < FullBytes; x++) { if (pBits[x] != 0x00) // If the 8 pixels are not all the opaque index return(TRUE); // then we are transparent } if (Mask) { if ((pBits[x] & Mask) != 0x00) return(TRUE); } pBits += ScanLen; } } } break; case 4: { BYTE* pBits = (BYTE*)(GetBitmapBits()); UINT32 Width = GetWidth(); UINT32 ByteWidth = (Width + 1) >> 1; // The number of used bytes in scanline UINT32 Height = GetHeight(); UINT32 ScanLen = GetScanlineSize(); INT32 TranspIndexHigh = TranspIndex << 4; for (UINT32 y = 0; y < Height; y++) { UINT32 x; for( x = 0; x < ByteWidth; x++) { if ((pBits[x] & 0x0F) == TranspIndex) // If the pixel is the transparent colour return(TRUE); // then we are transparent if ((pBits[x] & 0xF0) == TranspIndexHigh) // If the pixel is the transparent colour return(TRUE); // then we are transparent } if (Width % 2 == 1) // If we have an odd pixel then test it { if ((pBits[x] & 0x0F) == TranspIndex) // If the pixel is the transparent colour return(TRUE); // then we are transparent } pBits += ScanLen; } } break; case 8: { BYTE* pBits = (BYTE*)(GetBitmapBits()); UINT32 Width = GetWidth(); UINT32 Height = GetHeight(); UINT32 ScanLen = GetScanlineSize(); for (UINT32 y = 0; y < Height; y++) { for (UINT32 x = 0; x < Width; x++) { if (pBits[x] == TranspIndex) // If the pixel is the transparent colour return(TRUE); // then we are transparent } pBits += ScanLen; } } break; default: ERROR3("Bad colour depth in IsTransparent"); break; } } else if (GetBPP() == 32) { // if we have any non-opaque pixels then we must be complex DWORD* pBits = (DWORD*)(GetBitmapBits()); UINT32 Width = GetWidth(); UINT32 Height = GetHeight(); DWORD* pEnd = pBits + (Width * Height); while (pBits < pEnd) { if (*pBits && 0xFF000000) // If the pixel is not completely opaque return(TRUE); // then we are transparent pBits++; } } return(FALSE); }

BOOL CWxBitmap::LoadBitmap (  UINT32  BitmapResourceID  )  [virtual]

Loads a bitmap from the resources. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Parameters: The  Resource ID of the bitmap to Load [INPUTS] Returns: TRUE, or FALSE (Loaded or Failed). Errors: - See also: - Implements OILBitmap. Definition at line 3732 of file oilbitmap.cpp. { wxBitmap * pBitmap=CamArtProvider::Get()->FindBitmap((ResourceID)BitmapResourceID); if (!pBitmap) return FALSE; return CreateFromwxBitmap(pBitmap); }

OILBitmap * CWxBitmap::MakeCopy (   )  [virtual]

To make an exact duplicate of this bitmap. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/3/2000 Returns: pointer to a copy of this bitmap, NULL if it fails Implements OILBitmap. Definition at line 1038 of file oilbitmap.cpp. { RebuildXPEBitmap(); // check to see that theres something to copy if (BMInfo == NULL || BMBytes == NULL) { ERROR3("This bitmap has no bits or info to copy!"); return NULL; } LPBYTE pNewBits = NULL; LPBITMAPINFO pNewInfo = NULL; // call our handy utility function which does the work DIBUtil::CopyEntireBitmap(BMInfo, BMBytes, &pNewInfo, &pNewBits); if (pNewInfo == NULL || pNewBits == NULL) { ERROR3("Failed to allocate bitmap structures"); return NULL; } CWxBitmap* pNewBitmap = new CWxBitmap(pNewInfo, pNewBits); if (pNewBitmap == NULL) { ERROR3("Failed to allocate new CWxBitmap"); FreeDIB(pNewInfo, pNewBits); } return pNewBitmap; }

OILBitmap * CWxBitmap::MakeSeparatedCopy (  ColourPlate *  pPlate, BYTE *  SepTables )  [virtual]

To make an colour separated copy of this bitmap. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 04/03/2004 Returns: pointer to a copy of this bitmap, NULL if it fails Definition at line 2547 of file oilbitmap.cpp. { ERROR3IF(SepTables == NULL, "No separation tables!?"); ERROR3IF(pPlate == NULL, "The separation ColourPlate has gone missing!"); if (SepTables == NULL || pPlate == NULL) return(NULL); RebuildXPEBitmap(); // check to see that theres something to copy if (BMInfo == NULL || BMBytes == NULL) { ERROR3("This bitmap has no bits or info to copy!"); return NULL; } LPBYTE pNewBits = NULL; LPBITMAPINFO pNewInfo = NULL; pNewInfo = AllocDIB(BMInfo->bmiHeader.biWidth, BMInfo->bmiHeader.biHeight, 32, &pNewBits); if (pNewInfo == NULL || pNewBits == NULL) { ERROR3("Failed to allocate bitmap structures"); return NULL; } Pixel32bpp *pScanline = (Pixel32bpp *) CCMalloc(BMInfo->bmiHeader.biWidth * sizeof(Pixel32bpp)); if (pScanline == NULL) return(NULL); BGRT* pPixel = (BGRT*)pNewBits; // --- A wee macro to find the Maximum of R,G,B, and place it into a variable called // Temp, which we define right now in function scope so it's always available // (It's undefined at the end of this function) BYTE Temp; #define TEMPMAX(R,G,B) \ { \ Temp = ((R) > (G)) ? (R) : (G); \ Temp = (Temp > (B)) ? Temp : (B); \ } // --- Izzy, Wizzy, let's get busy INT32 scan; INT32 i; // Loop Index BYTE Ink; // Temporary variable for storing the ink value in BYTE *UCR = SepTables + 768 + 255; // UCR is the 4th table, but this points at the // END of the table for optimisation - precalcs (255 - Temp) ColourPlateType Plate = pPlate->GetType(); ColourPlateType OutputPlate = pPlate->IsMonochrome() ? COLOURPLATE_KEY : Plate; BOOL bNegate = pPlate->IsNegative(); BYTE *LUT = NULL; switch (Plate) { case COLOURPLATE_CYAN: LUT = SepTables + 0; // Cyan table is the 1st table break; case COLOURPLATE_MAGENTA: LUT = SepTables + 256; // Magenta table is the 2nd table break; case COLOURPLATE_YELLOW: LUT = SepTables + 512; // Yellow table is the 3rd table break; default: LUT = SepTables + 1024; // Black generation is the 5th table break; } PORTNOTE("cms", "Disabled XaraCMS") #ifndef EXCLUDE_FROM_XARALX BOOL PrintRGBBlackAsKey = XaraCMS::PrintRGBBlackAsKey; #else BOOL PrintRGBBlackAsKey = TRUE; #endif for (scan = 0; scan < BMInfo->bmiHeader.biHeight; scan++) { GetScanline32bpp(scan, TRUE, pScanline); for (i = 0; i < BMInfo->bmiHeader.biWidth; i++) { // It's colour, so get the maximum of R,G,B into Temp TEMPMAX(pScanline[i].Red, pScanline[i].Green, pScanline[i].Blue); if (!PrintRGBBlackAsKey || Temp > 0) { switch (Plate) { case COLOURPLATE_CYAN: Ink = 255 - pScanline[i].Red; // Cyan ink is (255 - Red) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; case COLOURPLATE_MAGENTA: Ink = 255 - pScanline[i].Green; // Magenta ink is (255 - Green) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; case COLOURPLATE_YELLOW: Ink = 255 - pScanline[i].Blue; // Yellow ink is (255 - Blue) if (Ink>UCR[-Temp]) Ink -= UCR[-Temp]; else Ink=0; break; default: Ink = 255 - Temp; // Black ink is (255 - Temp) break; } Ink = LUT[Ink]; } else { Ink = (Plate == COLOURPLATE_KEY) ? 255 : 0; } if (bNegate) Ink = 255 - Ink; switch (OutputPlate) { case COLOURPLATE_CYAN: pPixel[i].Red = 255 - Ink; pPixel[i].Green = 255; pPixel[i].Blue = 255; break; case COLOURPLATE_MAGENTA: pPixel[i].Red = 255; pPixel[i].Green = 255 - Ink; pPixel[i].Blue = 255; break; case COLOURPLATE_YELLOW: pPixel[i].Red = 255; pPixel[i].Green = 255; pPixel[i].Blue = 255 - Ink; break; default: pPixel[i].Red = 255 - Ink; pPixel[i].Green = 255 - Ink; pPixel[i].Blue = 255 - Ink; break; } pPixel[i].Transparency = pScanline[i].Alpha; } pPixel += BMInfo->bmiHeader.biWidth; // Pointer arithmetic!!! } // And finally, vape our helper macro #undef TEMPMAX CWxBitmap* pNewBitmap = new CWxBitmap(pNewInfo, pNewBits); CCFree(pScanline); if (pNewBitmap == NULL) { ERROR3("Failed to allocate new CWxBitmap"); FreeDIB(pNewInfo, pNewBits); } return pNewBitmap; }

wxImage * CWxBitmap::MakewxImage (  UINT32  ImageWidth = 0, UINT32  ImageHeight = 0, BOOL  UsePalette = TRUE )  [virtual]

Makes a wxBitmap, slowly. Author: Alex Bligh Date: 26/04/2006 Parameters: ImageWidth  - Width of image to make (or zero for width of bitmap) [INPUTS] ImageHeight - Depth of image to make (or zero for depth of bitmap) UsePalette -Ignored for deep bitmaps For <=8bpp bitmaps, if this value is: FALSE, the bitmap's palette will be ignored, and the actual pixel (palette index) value will be returned as a greyscale RGB value TRUE, the pixel index value will be used to retrieve the 24bpp palette entry for the pixel, if a palette is available. None  [OUTPUTS] Returns: A pointer to a wxImage, or NULL for failure The scanline will be converted up from 1, 4, 8, 24, or 32bpp into the generic Pixel32bpp format. Notes: This function basically just calls ReadPixel for all pixels in the scanline See also: CWxBitmap::ReadPixel32bpp Definition at line 2183 of file oilbitmap.cpp. { if (!ImageWidth) ImageWidth=GetWidth(); if (!ImageHeight) ImageHeight=GetHeight(); wxImage * pImage = new wxImage(GetWidth(), GetHeight(), /*TYPENOTE: Correct*/ false); if (!pImage) return NULL; #if 0 pImage->SetAlpha(); if (!pImage->HasAlpha()) { delete pImage; return NULL; } #endif RebuildXPEBitmap(); double xstep = GetWidth()/ImageWidth; double ystep = GetHeight()/ImageHeight; double x=0; double y=0; for (UINT32 YPos = 0; YPos < ImageHeight; YPos++) { UINT32 YP=(UINT32)(y+0.5); x=0; for (UINT32 XPos = 0; XPos < ImageWidth; XPos++) { UINT32 XP=(UINT32)(x+0.5); Pixel32bpp p = ReadPixel32bpp(XP, YP, UsePalette); pImage->SetRGB(XPos, YPos, p.Red, p.Blue, p.Green); // pImage->SetAlpha(XPos, YPos, 255-p.Alpha); // wxImage alpha has 0 for fully transparent x+=xstep; } y+=ystep; } return(pImage); }

INT32 CWxBitmap::operator== (  const OILBitmap &  Other  )  [virtual]

Checks to see if one bitmap is the same as another. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Parameters: The  other bitmap to compare this one with [INPUTS] Returns: TRUE, or FALSE. Errors: - See also: - Implements OILBitmap. Definition at line 3605 of file oilbitmap.cpp. { CWxBitmap* OtherBmp = (CWxBitmap*)&Other; OtherBmp->RebuildXPEBitmap(); if (BMInfo == NULL || OtherBmp->BMInfo == NULL) return FALSE; // If either of the Info fields are NULL, then // they are either not the same, or we can't tell !! if (BMBytes == NULL || OtherBmp->BMBytes == NULL) return FALSE; // If either of the Bytes are NULL, then // they are either not the same, or we can't tell !! // Lets check the Bitmap Header first if (BMInfo->bmiHeader.biSizeImage != OtherBmp->BMInfo->bmiHeader.biSizeImage || BMInfo->bmiHeader.biWidth != OtherBmp->BMInfo->bmiHeader.biWidth || BMInfo->bmiHeader.biHeight != OtherBmp->BMInfo->bmiHeader.biHeight || BMInfo->bmiHeader.biBitCount != OtherBmp->BMInfo->bmiHeader.biBitCount || BMInfo->bmiHeader.biClrUsed != OtherBmp->BMInfo->bmiHeader.biClrUsed || BMInfo->bmiHeader.biXPelsPerMeter != OtherBmp->BMInfo->bmiHeader.biXPelsPerMeter || BMInfo->bmiHeader.biYPelsPerMeter != OtherBmp->BMInfo->bmiHeader.biYPelsPerMeter) { return FALSE; } // Well they looks similar, but the only way to be sure, is to compare the Bits !! // First lets check the Palettes if (BMInfo->bmiHeader.biBitCount <= 8) { INT32 NumCols = BMInfo->bmiHeader.biClrUsed; INT32* Pal = (INT32*)BMInfo->bmiColors; INT32* OtherPal = (INT32*)OtherBmp->BMInfo->bmiColors; // Is the palette the same ? if (memcmp(Pal, OtherPal, NumCols*4) != 0) return FALSE; } // Well the Palettes are the Same .... Lets check the actual data now. INT32 Width = BMInfo->bmiHeader.biWidth; INT32 Height = BMInfo->bmiHeader.biHeight; INT32 Bpp = BMInfo->bmiHeader.biBitCount; /* // Alas, this doesn't work. // go and compare 'em if ((BMInfo->bmiHeader.biSizeImage != OtherBmp->BMInfo->bmiHeader.biSizeImage) || (memcmp(BMBytes, OtherBmp->BMBytes, BMInfo->bmiHeader.biSizeImage)!=0)) return FALSE; // Blimey !! They're the Same !! return TRUE; */ // How many (whole) bytes are there in each scan line ? INT32 ScanLineBytes = (Width * Bpp) / 8; INT32 ExtraBits = 0; BYTE BitMask = 0; if (Bpp < 8) { // For less than 8 bpp the scanlines could // end on a sub-byte point ExtraBits = (Width * Bpp) - (ScanLineBytes * 8); // ie.(width * bpp) % 8 //BitMask = (1<<ExtraBits) - 1; const BYTE BitMaskArray[8] = {0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE}; ERROR3IF (ExtraBits < 0 || ExtraBits > 7, "CWxBitmap::operator== - extraordinary ExtraBits"); BitMask = BitMaskArray[ExtraBits]; // NB.ExtraBits == 0 not used } // The scan lines are always DWord or Word Aligned, // So now get the actual bytes need to skip over a scanline INT32 ScanAlign = DIBUtil::ScanlineSize(Width, Bpp); BYTE* BmpData = BMBytes; BYTE* OtherBmpData = OtherBmp->BMBytes; for (INT32 Scan = 0; Scan < Height; Scan++) { // Is this scan line the same ? if (memcmp(BmpData, OtherBmpData, ScanLineBytes) != 0) return FALSE; if (ExtraBits > 0) { // The scanlines are not exactly byte aligned, so we'll get the DWORD // after the whole number of bytes, and mask off the bits that we // are interested in // Actually as we've just compared ScanLineBytes we need only check the // last byte (which is byte aligned) BYTE BmpExtraByte = *(BmpData + ScanLineBytes) & BitMask; BYTE OtherExtraByte = *(OtherBmpData + ScanLineBytes) & BitMask; //INT32 ExtraBmpWord = (*((INT32*)(BmpData + ScanLineBytes))) & BitMask; //INT32 ExtraOtherWord = (*((INT32*)(OtherBmpData + ScanLineBytes))) & BitMask; // Are the extra bits the same ? if (BmpExtraByte != OtherExtraByte) return FALSE; } BmpData += ScanAlign; OtherBmpData += ScanAlign; } // Blimey !! They're the Same !! return TRUE; }

void CWxBitmap::PlotPixel (  INT32  x, INT32  y, PixelGreyscale  NewValue )  [virtual]

Plots an 8bpp (0..255) pixel to any type of bitmap The pixel is taken to be a greyscale, and is truncated or expanded as appropriate to fit the greyscale value into the destination bitmap pixel format. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (rewrote Alex's disgusting hack) Date: 3/7/96 Parameters: x,y  - coordinates within the bitmap of the pixel to plot [INPUTS] NewValue - an 8bpp pixel value, presumed to be a greyscale. (changes  attached oil bitmap) [OUTPUTS] Returns: Nothing (Only 8, 24, and 32bpp formats are currently supported) Notes: In debug builds, will check all kinds of stuff, but in release builds, it assumes that you are providing legal offsets in the bitmap, and are only using this call where it will work - this is to reduce retail overhead on each pixel operation. Will probably fail horribly if you haven't called CacheGeometry Returns: Errors: ERROR3 if the bitmap is not 16, 24, or 32bpp Implements OILBitmap. Definition at line 3125 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL || BMBytes == NULL, "PlotPixel called on duff bitmap"); ERROR3IF(x < 0 || y < 0 || x >= (INT32)GetWidth() || y >= (INT32)GetHeight(), "Illegal pixel position in CWxBitmap::PlotPixel"); BYTE *ScanlineStart = BMBytes + (y * ScanLineByteWidth); switch(BMInfo->bmiHeader.biBitCount) { case 8: ScanlineStart[x] = NewValue; break; case 24: ScanlineStart[x * 3 + 0] = \ ScanlineStart[x * 3 + 1] = \ ScanlineStart[x * 3 + 2] = NewValue; break; case 32: ScanlineStart[x * 4 + 0] = \ ScanlineStart[x * 4 + 1] = \ ScanlineStart[x * 4 + 2] = NewValue; ScanlineStart[x * 4 + 3] = 0; break; default: ERROR3("Unsupported bitmap format in PlotPixel(8bpp)"); break; } }

void CWxBitmap::PlotPixel (  INT32  x, INT32  y, Pixel32bpp  NewValue )  [virtual]

Plots a 32bpp pixel to a deep bitmap (24, or 32bpp). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (rewrote Alex's disgusting hack) Date: 3/7/96 Parameters: x,y  - coordinates within the bitmap of the pixel to plot [INPUTS] NewValue - a 32bpp pixel value. (changes  attached oil bitmap) [OUTPUTS] Returns: Nothing Currently unimplemented for 16bpp Makes no sense for <= 8bpp Notes: In debug builds, will check all kinds of stuff, but in release builds, it assumes that you are providing legal offsets in the bitmap, and are only using this call where it will work - this is to reduce retail overhead on each pixel operation. Will probably fail horribly if you haven't called CacheGeometry Returns: Errors: ERROR3 if the bitmap is not 16, 24, or 32bpp Implements OILBitmap. Definition at line 3058 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL || BMBytes == NULL, "PlotPixel called on duff bitmap"); ERROR3IF(x < 0 || y < 0 || x >= (INT32)GetWidth() || y >= (INT32)GetHeight(), "Illegal pixel position in CWxBitmap::PlotPixel"); BYTE *ScanlineStart = BMBytes + (y * ScanLineByteWidth); switch(BMInfo->bmiHeader.biBitCount) { case 16: ERROR3("Unimplemented code"); break; case 24: ScanlineStart[x * 3 + 0] = NewValue.Red; ScanlineStart[x * 3 + 1] = NewValue.Green; ScanlineStart[x * 3 + 2] = NewValue.Blue; break; case 32: ScanlineStart[x * 4 + 0] = NewValue.Red; ScanlineStart[x * 4 + 1] = NewValue.Green; ScanlineStart[x * 4 + 2] = NewValue.Blue; ScanlineStart[x * 4 + 3] = NewValue.Alpha; break; default: ERROR3("Unsupported (non-deep) bitmap format in PlotPixel(32bpp)"); break; } }

BOOL CWxBitmap::PrepareMask (  INT32  PaletteEntry  )  [virtual]

Implements OILBitmap. Definition at line 3882 of file oilbitmap.cpp. { return FALSE; }

Pixel32bpp CWxBitmap::ReadPixel32bpp (  INT32  x, INT32  y, BOOL  UsePalette = TRUE )  [inline, virtual]

reads a pixel Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/96 Parameters: x,y  - coordinates of the pixel to read [INPUTS] UsePalette -Ignored for deep bitmaps For <=8bpp bitmaps, if this value is: FALSE, the bitmap's palette will be ignored, and the actual pixel (palette index) value will be returned as a greyscale RGB value TRUE, the pixel index value will be used to retrieve the 24bpp palette entry for the pixel, if a palette is available. Returns: The pixel value of the given pixel, in 32bpp format Notes: In debug builds, will check all kinds of stuff, but in release builds, it assumes that you are providing legal offsets in the bitmap, and are only using this call where it will work - this is to reduce retail overhead on each pixel operation. NOTE that for <=8bpp bitmaps, the behavior is as follows: If paletted, the value returned is the 24bit RGB looked up in the palette Otherwise, the pixel value is assumed to be a greyscale intensity and is converted into a 24bit RGB where R = G = B = intensity. See also: CWxBitmap::ReadPixelGreyscale Implements OILBitmap. Definition at line 3195 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL || BMBytes == NULL, "PlotPixel called on duff bitmap"); ERROR3IF(x < 0 || y < 0 || x >= (INT32)GetWidth() || y >= (INT32)GetHeight(), "Illegal pixel position in CWxBitmap::ReadPixel"); BYTE *ScanlineStart = BMBytes + (y * ScanLineByteWidth); Pixel32bpp Pix; Pix.Alpha = 0; // Generally there is no alpha channel, so set it to a default if (UsePalette && BMInfo->bmiHeader.biClrUsed < 1) UsePalette = FALSE; // No palette, so can't use one! switch(BMInfo->bmiHeader.biBitCount) { case 1: { BYTE Temp = ScanlineStart[x >> 3]; // Get the byte containing the pixel (x / 8) Temp &= 0x80 >> (x & 7); // Mask out all bits except the pixel (x % 8) // Look up in the palette, if any, else assume it's a greyscale (b&w) if (UsePalette) { Temp = (Temp == 0) ? 0 : 1; Pix.Red = BMInfo->bmiColors[Temp].rgbRed; Pix.Green = BMInfo->bmiColors[Temp].rgbGreen; Pix.Blue = BMInfo->bmiColors[Temp].rgbBlue; } else { Temp = (Temp == 0) ? 0 : 255; Pix.Red = Pix.Green = Pix.Blue = Temp; } } break; case 4: { BYTE Temp = ScanlineStart[x / 2]; // Get the byte containing the pixel // Look up in the palette, if any, else assume it's a greyscale if (UsePalette) { // Pull out the pixel's palette index if ((x & 1) == 0) Temp = (Temp >> 4) & 0x0f; // High nybble else Temp &= 0x0f; // Low nybble Pix.Red = BMInfo->bmiColors[Temp].rgbRed; Pix.Green = BMInfo->bmiColors[Temp].rgbGreen; Pix.Blue = BMInfo->bmiColors[Temp].rgbBlue; } else { // And pull out the actual pixel value. Note that we repeat the nybble twice // into the final byte to get the correct 8bpp greyscale value (white is FF, not F0!) if ((x & 1) == 0) Temp = (Temp & 0xf0) | ((Temp & 0xf0) >> 4); // High nybble else Temp = (Temp & 0x0f) | ((Temp & 0x0f) << 4); // Low nybble Pix.Red = Pix.Green = Pix.Blue = Temp; } } break; case 8: // Look up in the palette, if any, else assume it's a greyscale if (UsePalette) { Pix.Red = BMInfo->bmiColors[ScanlineStart[x]].rgbRed; Pix.Green = BMInfo->bmiColors[ScanlineStart[x]].rgbGreen; Pix.Blue = BMInfo->bmiColors[ScanlineStart[x]].rgbBlue; } else Pix.Red = Pix.Green = Pix.Blue = ScanlineStart[x]; break; case 24: x *= 3; Pix.Blue = ScanlineStart[x++]; Pix.Green = ScanlineStart[x++]; Pix.Red = ScanlineStart[x++]; break; case 32: x *= 4; Pix.Blue = ScanlineStart[x++]; Pix.Green = ScanlineStart[x++]; Pix.Red = ScanlineStart[x++]; Pix.Alpha = ScanlineStart[x++]; break; default: Pix.Red = Pix.Green = Pix.Blue = 0; ERROR3("Unsupported bitmap format in ReadPixel(32bpp)"); break; } return(Pix); }

PixelGreyscale CWxBitmap::ReadPixelGreyscale (  INT32  x, INT32  y )  [virtual]

reads a pixel Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/96 Parameters: x,y  - coordinates of the pixel to read [INPUTS] Returns: The pixel value of the given pixel, as an 8bpp greyscale Notes: In debug builds, will check all kinds of stuff, but in release builds, it assumes that you are providing legal offsets in the bitmap, and are only using this call where it will work - this is to reduce retail overhead on each pixel operation. Coloured pixels from deep bitmaps will be converted to greyscales Pixels from <=8bpp bitmaps will be read directly, and ASSUMED to be in a greyscale format (e.g. it does NOT read the palette entry for the pixel value and convert that to a greyscale) See also: CWxBitmap::ReadPixel32bpp Implements OILBitmap. Definition at line 3397 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL || BMBytes == NULL, "PlotPixel called on duff bitmap"); ERROR3IF(x < 0 || y < 0 || x >= (INT32)GetWidth() || y >= (INT32)GetHeight(), "Illegal pixel position in CWxBitmap::ReadPixel"); BYTE *ScanlineStart = BMBytes + (y * ScanLineByteWidth); PixelGreyscale Pix; switch(BMInfo->bmiHeader.biBitCount) { case 1: { BYTE Temp = ScanlineStart[x >> 3]; // Get the byte containing the pixel (x / 8) Temp &= 0x80 >> (x & 7); // Mask out all bits except the pixel (x % 8) Pix = (Temp == 0) ? 0 : 255; } break; case 4: { BYTE Temp = ScanlineStart[x / 2]; // Get the byte containing the pixel // And pull out the actual pixel value. Note that we repeat the nybble twice // into the final byte to get the correct 8bpp greyscale value (white is FF, not F0!) if ((x & 1) == 0) Temp = (Temp & 0xf0) | ((Temp & 0xf0) >> 4); // High nybble else Temp = (Temp & 0x0f) | ((Temp & 0x0f) << 4); // Low nybble Pix = Temp; } break; case 8: Pix = ScanlineStart[x]; break; case 24: { double Temp; x *= 3; Temp = 0.109 * (double) ScanlineStart[x++]; // B Temp += 0.586 * (double) ScanlineStart[x++]; // G Temp += 0.305 * (double) ScanlineStart[x]; // R Pix = (BYTE) Temp; } break; case 32: { double Temp; x *= 4; Temp = 0.109 * (double) ScanlineStart[x++]; // B Temp += 0.586 * (double) ScanlineStart[x++]; // G Temp += 0.305 * (double) ScanlineStart[x]; // R // Alpha Pix = (BYTE) Temp; } break; default: Pix = 0; ERROR3("Unsupported bitmap format in ReadPixel(32bpp)"); break; } return(Pix); }

void CWxBitmap::ReplaceBitmap (  LPBYTE  pBytes, LPBITMAPINFO  pInfo )  [virtual]

To reset the bitmap stored in this CWxBitmap object. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 04/02/2004 Parameters: the  bytes and bitmapinfo of the new bitmap [INPUTS] Returns: - Implements OILBitmap. Definition at line 4246 of file oilbitmap.cpp. { if (IsDefaultBitmap()) { ERROR2RAW("ReplaceBitmap asked to replace the default bitmap!"); return; } // Do we have valid inputs? if (pBytes==NULL && pInfo==NULL) { ERROR2RAW("Call to ReplaceBitmap with bad parameters"); return; } // Remove the old data from memory FreeDIB( BMInfo, BMBytes ); DestroyGreyscaleVersion(); DestroyContonePalette(); // Set the new data pointers BMInfo = pInfo; BMBytes = pBytes; // Set the information up CacheGeometry(); }

INT32 CWxBitmap::ReturnPaletteIndexUsed (  INT32  x, INT32  y )  [virtual]

When the user clicks in, or moves the mouse over a pixel in one of the preview images, this function is called to work out the actual palette index of the colour used. Author: Alex_Price (Xara Group Ltd) <camelotdev@xara.com> Date: 29/09/99 Parameters: x,y  - The x and y co-ordinates of the pixel under consideration [INPUTS] Returns: -1 if something went wrong, otherwise the relevant palette index. Notes: This function is based on the function ReadPixel32bpp() Implements OILBitmap. Definition at line 3321 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL || BMBytes == NULL, "PlotPixel called on duff bitmap"); ERROR3IF(x < 0 || y < 0 || x >= (INT32)GetWidth() || y >= (INT32)GetHeight(), "Illegal pixel position in CWxBitmap::ReadPixel"); BYTE *ScanlineStart = BMBytes + (y * ScanLineByteWidth); INT32 PaletteIndex; switch(BMInfo->bmiHeader.biBitCount) { case 1: { BYTE Temp = ScanlineStart[x >> 3]; // Get the byte containing the pixel (x / 8) Temp &= 0x80 >> (x & 7); // Mask out all bits except the pixel (x % 8) Temp = (Temp == 0) ? 0 : 1; PaletteIndex = Temp; } break; case 4: { BYTE Temp = ScanlineStart[x / 2]; // Get the byte containing the pixel // Pull out the pixel's palette index if ((x & 1) == 0) Temp = (Temp >> 4) & 0x0f; else Temp &= 0x0f; PaletteIndex = Temp; } break; case 8: PaletteIndex = ScanlineStart[x]; break; default: PaletteIndex = -1; ERROR3( "Couldn't find the palette index" ); break; } return PaletteIndex; }

void CWxBitmap::SetRecommendedHeight (  INT32  NewHeight  )  [virtual]

Sets the recommended height of the bitmap. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: NewHeight,the  new height of the bitmap in Millipoints [INPUTS] Implements OILBitmap. Definition at line 1009 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo) { double PelH = DEFAULT_PIXEL_SIZE; if (NewHeight > 0) { const UINT32 Height = BMInfo->bmiHeader.biHeight; PelH = ((double)Height * M_MP_VAL)/(double)NewHeight; } BMInfo->bmiHeader.biYPelsPerMeter = (INT32)(PelH + 0.5); } }

void CWxBitmap::SetRecommendedWidth (  INT32  NewWidth  )  [virtual]

Sets the recommended width of the bitmap. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/96 Parameters: NewWidth,the  new width of the bitmap in Millipoints [INPUTS] Implements OILBitmap. Definition at line 981 of file oilbitmap.cpp. { RebuildXPEBitmap(); if (BMInfo) { double PelW = DEFAULT_PIXEL_SIZE; if (NewWidth > 0) { const UINT32 Width = BMInfo->bmiHeader.biWidth; PelW = ((double)Width * M_MP_VAL)/(double)NewWidth; } BMInfo->bmiHeader.biXPelsPerMeter = (INT32)(PelW + 0.5); } }

BOOL CWxBitmap::SetTransparencyIndex (  INT32  Index  )  [virtual]

Finds the Transparent index colour of a bitmap if one exists. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/6/96 Returns: TRUE if the Index was set, FALSE if there is no transparent index Implements OILBitmap. Definition at line 660 of file oilbitmap.cpp. { RebuildXPEBitmap(); ERROR3IF(BMInfo == NULL, "SetTransparencyIndex called when BMInfo is NULL"); if (BMInfo == NULL) return FALSE; INT32 NumCols = 0; switch (GetBPP()) { case 1: NumCols = 2; break; case 4: NumCols = 16; break; case 8: NumCols = 256; break; default: ERROR3("Bad colour depth in SetTransparencyIndex"); break; } RGBQUAD* pCols = BMInfo->bmiColors; // Set the specified Index to be transparent for (INT32 i=0; i<NumCols; i++) { if (i == Index) pCols[i].rgbReserved = 0xFF; else pCols[i].rgbReserved = 0; } return TRUE; }

BOOL CWxBitmap::WritePalette (  BaseCamelotFilter *  pFilter  )  [virtual]

Function used when exporting an 8bpp JPEG into the web file and we need to squirt the palette information into the record ready for reuse when the file is loaded back in. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 20/06/96 Parameters: pFilter  - the filter to use to write the data. [INPUTS] -  [OUTPUTS] Returns: True if data saved ok, False otherwise Implements OILBitmap. Definition at line 2742 of file oilbitmap.cpp. { ERROR2IF(pFilter == NULL,FALSE,"CWxBitmap::WritePalette null pFilter"); RebuildXPEBitmap(); BOOL ok = TRUE; UINT32 NumberOfPaletteEntries = GetNumPaletteEntries(); ERROR2IF(NumberOfPaletteEntries == 0 || NumberOfPaletteEntries > 256, FALSE,"Palette entries 0 or > 256!"); // We will save the number of palette entries as a byte, 0 - 255 BYTE Entries = NumberOfPaletteEntries - 1; if (ok) ok = pFilter->Write(Entries); for (UINT32 i = 0; i < NumberOfPaletteEntries; i++) { #if !defined(__WXMSW__) //TRACEUSER("Phil", _T("WritePalette r=%x g=%x b=%x\n"), BMInfo->bmiColors[i].rgbBlue, BMInfo->bmiColors[i].rgbGreen, BMInfo->bmiColors[i].rgbRed); if (ok) ok = pFilter->Write(BMInfo->bmiColors[i].rgbBlue); if (ok) ok = pFilter->Write(BMInfo->bmiColors[i].rgbGreen); if (ok) ok = pFilter->Write(BMInfo->bmiColors[i].rgbRed); #else //TRACEUSER("Phil", _T("WritePalette r=%x g=%x b=%x\n"), BMInfo->bmiColors[i].rgbRed, BMInfo->bmiColors[i].rgbGreen, BMInfo->bmiColors[i].rgbBlue); if (ok) ok = pFilter->Write(BMInfo->bmiColors[i].rgbRed); if (ok) ok = pFilter->Write(BMInfo->bmiColors[i].rgbGreen); if (ok) ok = pFilter->Write(BMInfo->bmiColors[i].rgbBlue); #endif } // During the preparation process we told the system we would update by the // the number of entries in the palette, so do so pFilter->IncProgressBarCount(NumberOfPaletteEntries); return ok; }

---

Friends And Related Function Documentation

OILBitmap* OILBitmap::Create (  UINT32  , UINT32  , UINT32  , UINT32  )  [friend]

OILBitmap* OILBitmap::Create (   )  [friend]

void OILBitmap::Deinit (   )  [friend]

BOOL OILBitmap::Init (   )  [friend]

---

Member Data Documentation

INT32 CWxBitmap::BitmapSize

Definition at line 230 of file oilbitmap.h.

LPBYTE CWxBitmap::BMBytes

Definition at line 243 of file oilbitmap.h.

LPBITMAPINFO CWxBitmap::BMInfo

Definition at line 242 of file oilbitmap.h.

INT32 CWxBitmap::ScanLineByteWidth

Definition at line 229 of file oilbitmap.h.

---

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

• wxOil/oilbitmap.h (r1785/r1366)
• wxOil/oilbitmap.cpp (r1785/r1464)

---