---

DIBitmap Class Reference

A class for loading and saving DIBs. More...

#include <DIBitmap.h>

List of all members.

Public Methods
bool	saveFile (PCTSTR, const DWORD=CREATE_ALWAYS) const
bool	loadFile (PCTSTR)
bool	createCompatible (const int, const int, const int)
bool	set (const PBITMAPINFO)
const DIBitmap &	operator= (const DIBitmap &)
void	clear ()
const PBITMAPINFO	getPBITMAPINFO () const
const PBITMAPINFOHEADER	getPBITMAPINFOHEADER () const
BYTE *	getPBytes () const
RGBQUAD *	getPPalette () const
	operator PBITMAPINFO () const
	DIBitmap ()
	DIBitmap (const DIBitmap &)
virtual	~DIBitmap ()
Static Public Methods
bool	isCompatibleBitmap (const PBITMAPINFOHEADER)
Private Methods
	imageMemDealloc ()
bool	imageMemAlloc (const PBITMAPINFOHEADER)
Private Attributes
BITMAPINFOHEADER *	bmInfoHeader
	pointer to BITMAPINFOHEADER.
RGBQUAD *	RGBQuads
	pointer to RGB Quads.
BYTE *	imageBytes
	pointer to the image bytes.
BYTE *	assignedMemory
	pointer to the assigned memory.

---

Detailed Description

A class for loading and saving Device Independent Bitmaps. This class is capable of writing and reading windows .bmp files to/from a packed BITMAPINFO structure.
See microsofts documentation on BITMAPINFOHEADER and BITMAPINFO structures.

Definition at line 20 of file DIBitmap.h.

---

Constructor & Destructor Documentation

DIBitmap::DIBitmap (    )

Default constructor Definition at line 16 of file DIBitmap.cpp. References assignedMemory, bmInfoHeader, imageBytes, and RGBQuads. { assignedMemory = NULL; bmInfoHeader = NULL; RGBQuads = NULL; imageBytes = NULL; }

DIBitmap::DIBitmap (  const DIBitmap &    copy )

Copy constructor Definition at line 27 of file DIBitmap.cpp. References assignedMemory, bmInfoHeader, imageBytes, RGBQuads, and set(). { assignedMemory = NULL; bmInfoHeader = NULL; RGBQuads = NULL; imageBytes = NULL; set(copy); }

DIBitmap::~DIBitmap (    )  [virtual]

Object Destructor Definition at line 40 of file DIBitmap.cpp. References clear(). { clear(); }

---

Member Function Documentation

void DIBitmap::clear (    )  [inline]

Wipes the Image Definition at line 36 of file DIBitmap.h. References imageMemDealloc(). Referenced by operator=(), set(), and ~DIBitmap(). { imageMemDealloc(); }

bool DIBitmap::createCompatible (  const int    width, const int    height, const int    bits )

Resets the image to allocate space for a bitmap with the following attributes Parameters: width  : Width of bitmap height  : Height of bitmap bits  : Bits per pixel e.g. 8 for a 256 colour palettised bitmap Returns: bool : returns true if space allocated /n Possible reasons for failure include: invalid parmameters insufficient memory Definition at line 412 of file DIBitmap.cpp. References imageMemAlloc(). Referenced by BitmapScreen::BitmapScreen(), and ScreenPipe::readToDIB(). { // sanity checks are performed with a call to isCompatibleBitmap from imageMemAlloc BITMAPINFOHEADER tempHdr; tempHdr.biSize = sizeof(BITMAPINFOHEADER); tempHdr.biWidth = width; tempHdr.biHeight = height; tempHdr.biPlanes = 1; tempHdr.biBitCount = bits; tempHdr.biCompression = BI_RGB; tempHdr.biSizeImage = 0; tempHdr.biXPelsPerMeter = 0; tempHdr.biYPelsPerMeter = 0; tempHdr.biClrUsed = 0; tempHdr.biClrImportant = 0; return imageMemAlloc(&tempHdr); }

const PBITMAPINFO DIBitmap::getPBITMAPINFO (    )  const [inline]

Returns a pointer to a Packed Bitmap i.e. a BITMAPINFO structure with the image bits immediately after Returns: const PBITMAPINFO : Definition at line 44 of file DIBitmap.h. References bmInfoHeader. Referenced by Cls_OnEraseBkgnd(). { return (BITMAPINFO*) this->bmInfoHeader; }

const PBITMAPINFOHEADER DIBitmap::getPBITMAPINFOHEADER (    )  const [inline]

Returns a pointer to a BITMAPINFOHEADER. Provided for easy access to information about the contained bitmap Returns: const PBITMAPINFOHEADER : Definition at line 52 of file DIBitmap.h. References bmInfoHeader. Referenced by Cls_OnCreate(), Cls_OnEraseBkgnd(), BitmapScreen::DoneWriting(), operator=(), and ScreenPipe::readToDIB(). { return this->bmInfoHeader; }

BYTE* DIBitmap::getPBytes (    )  const [inline]

Returns a pointer to the images bits Returns: BYTE* : A pointer to an array of bytes getPBITMAPINFOHEADER()->biSizeImage long. Definition at line 60 of file DIBitmap.h. References imageBytes. Referenced by Cls_OnEraseBkgnd(), and ScreenPipe::readToDIB(). { return this->imageBytes; }

RGBQUAD* DIBitmap::getPPalette (    )  const [inline]

Returns a pointer to the images Palette Returns: RGBQUAD* : A pointer to an array of RGBQUADS getPBITMAPINFOHEADER()->biClrUsed long. Definition at line 68 of file DIBitmap.h. References RGBQuads. Referenced by ScreenPipe::readToDIB(). { return this->RGBQuads; }

bool DIBitmap::imageMemAlloc (  const PBITMAPINFOHEADER    infoHeader )  [private]

Memory allocation function. Given a valid BITMAPINFOHEADER structure it allocates sufficient memory and sets the objects BITMAPINFOHEADER. Parameters: infoHeader  : pointer to a valid bitmapinfo structure Returns: bool : true iff successful Definition at line 254 of file DIBitmap.cpp. References assignedMemory, bmInfoHeader, imageBytes, imageMemDealloc(), isCompatibleBitmap(), and RGBQuads. Referenced by createCompatible(), loadFile(), and set(). { if(infoHeader == bmInfoHeader || infoHeader == NULL) return false; if(!isCompatibleBitmap(infoHeader)) return false; // Calculate the image size (if it's not given). DWORD sizeImage; if( 0 == infoHeader->biSizeImage ){ // The image size hasn't been supplied the following calculates how large // an image with the given width, height and bitcount is. // ((((width * bitcount) + 31) bitwiseAND -31) SHIFTLEFT 3) * absolute(height) sizeImage = (((( infoHeader->biWidth * infoHeader->biBitCount ) + 31) & ~31) >> 3) * abs(infoHeader->biHeight); } else { sizeImage = infoHeader->biSizeImage; } // Calculate the number of colours used (if not specified) DWORD clrUsed; if( 0 == infoHeader->biClrUsed ) { if(infoHeader->biCompression == BI_BITFIELDS) { clrUsed = 3; } else { switch(infoHeader->biBitCount){ case 32: case 24: case 16: clrUsed = 0; break; case 8: case 4: case 1: // shifts 1 right by the bitcount // ie 1 << 8 = 256 // 1 << 4 = 32 // 1 << 1 = 2 clrUsed = 1 << infoHeader->biBitCount; break; default: // This should never happen since isCompatibleBitmap() passed the header clrUsed = 0; break; } } } else clrUsed = infoHeader->biClrUsed; int paletteBytes = sizeof(RGBQUAD) * clrUsed; int totalBytes = sizeof(BITMAPINFOHEADER) + paletteBytes + sizeImage; // If the current allocated memory is different from the required allocation. // There are times when reallocation occurs unnecessarily, there is little point // mudding this check to catch these though. if( bmInfoHeader == NULL || bmInfoHeader->biSize != sizeImage || bmInfoHeader->biClrUsed != clrUsed){ imageMemDealloc(); // The new opperator could be replaced with a windows stack function // providing that imageMemDealloc is also adjusted assignedMemory = new BYTE[totalBytes]; if(assignedMemory == NULL) return false; } // A windows function which does what the name suggests // The purpose is to ensure that padding is zeroed (as it is not normally set // anywhere else). ZeroMemory(assignedMemory, totalBytes); bmInfoHeader = (BITMAPINFOHEADER*)assignedMemory; if(paletteBytes != 0) RGBQuads = (RGBQUAD*)(assignedMemory + sizeof(BITMAPINFOHEADER)); else RGBQuads = NULL; imageBytes = assignedMemory + paletteBytes + sizeof(BITMAPINFOHEADER); // Windows copy function CopyMemory(bmInfoHeader, (BYTE*)infoHeader, sizeof(BITMAPINFOHEADER)); bmInfoHeader->biSizeImage = sizeImage; bmInfoHeader->biClrUsed = clrUsed; return true; }

DIBitmap::imageMemDealloc (    )  [private]

Image memory deallocation function Assign pointers to NULL as the memory is no longer valid but the pointers addresses are checked in other functions and can be returned by get functions. Definition at line 355 of file DIBitmap.cpp. References assignedMemory, bmInfoHeader, imageBytes, and RGBQuads. Referenced by clear(), and imageMemAlloc(). { if(assignedMemory != NULL){ delete [] assignedMemory; assignedMemory = NULL; bmInfoHeader = NULL; RGBQuads = NULL; imageBytes = NULL; } }

bool DIBitmap::isCompatibleBitmap (  const PBITMAPINFOHEADER    ptrHeader )  [static]

Checks the given bitmap header structure and returns true if this class is capable of using it. Parameters: PBITMAPINFOHEADER  : A pointer to a Microsoft defined BITMAPINFOHEADER structure Returns: bool : true = bitmap is compatible false = invalid header Definition at line 460 of file DIBitmap.cpp. Referenced by imageMemAlloc(). { if(ptrHeader == NULL) return false; if(ptrHeader->biSize != sizeof(BITMAPINFOHEADER)) return false; if(ptrHeader->biWidth < 1) return false; if(ptrHeader->biPlanes != 1) return false; if(ptrHeader->biSizeImage < 0) return false; if(ptrHeader->biXPelsPerMeter < 0) return false; if(ptrHeader->biYPelsPerMeter < 0) return false; if(ptrHeader->biClrUsed < 0 || ptrHeader->biClrUsed > 256) return false; if(ptrHeader->biClrImportant < 0 || ptrHeader->biClrImportant > 256) return false; switch(ptrHeader->biCompression){ case BI_RLE8: if(ptrHeader->biHeight < 1) return false; if(ptrHeader->biBitCount == 8) return true; else return false; case BI_RLE4: if(ptrHeader->biHeight < 1) return false; if(ptrHeader->biBitCount == 4) return true; else return false; case BI_BITFIELDS: if(ptrHeader->biHeight == 0) return false; if(ptrHeader->biBitCount == 24 || ptrHeader->biBitCount == 32) return true; else return false; case BI_RGB: if(ptrHeader->biHeight == 0) return false; switch(ptrHeader->biBitCount){ case 32: case 24: case 16: case 8: case 4: case 1: return true; default: return false; } default: return false; } // function has already returned by this point }

bool DIBitmap::loadFile (  PCTSTR    fName )

Loads a bitmap from the specified file Parameters: fName  : The File name as a TCHAR string Returns: bool : true iff successfully loaded Definition at line 56 of file DIBitmap.cpp. References bmInfoHeader, imageBytes, imageMemAlloc(), and RGBQuads. Referenced by Cls_OnCreate(). { BITMAPFILEHEADER filehdr; BITMAPINFOHEADER infohdr; DWORD infoHeaderSize, noBytesRead = 0; HANDLE hFile = INVALID_HANDLE_VALUE; void* ptr = NULL; BOOL isOk = true; bool status = false; // This SEH ensures that handles are released but doesn't catch exceptions __try { if( fName == NULL ) __leave; hFile = CreateFile(fName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); isOk = ReadFile(hFile, &filehdr, sizeof(BITMAPFILEHEADER), &noBytesRead, NULL); if( !isOk || (noBytesRead == 0) ) __leave; if( 0x4d42 != filehdr.bfType ) __leave; isOk = ReadFile(hFile, &infoHeaderSize, sizeof(DWORD), &noBytesRead, NULL); if( !isOk || (noBytesRead == 0) ) __leave; infohdr.biSize = sizeof(BITMAPINFOHEADER); switch(infoHeaderSize){ #if WINVER >= 0x0500 case sizeof(BITMAPV5HEADER): ptr = new BITMAPV5HEADER; isOk = ReadFile(hFile, (BYTE*)ptr + sizeof(DWORD), sizeof(BITMAPV5HEADER) - sizeof(DWORD), &noBytesRead, NULL); if( !isOk || (noBytesRead == 0) ) __leave; infohdr.biBitCount = ((PBITMAPV5HEADER)ptr)->bV5BitCount; infohdr.biClrImportant = ((PBITMAPV5HEADER)ptr)->bV5ClrImportant; infohdr.biClrUsed = ((PBITMAPV5HEADER)ptr)->bV5ClrUsed; infohdr.biCompression = ((PBITMAPV5HEADER)ptr)->bV5Compression; infohdr.biHeight = ((PBITMAPV5HEADER)ptr)->bV5Height; infohdr.biPlanes = ((PBITMAPV5HEADER)ptr)->bV5Planes; infohdr.biSizeImage = ((PBITMAPV5HEADER)ptr)->bV5SizeImage; infohdr.biWidth = ((PBITMAPV5HEADER)ptr)->bV5Width; infohdr.biXPelsPerMeter = ((PBITMAPV5HEADER)ptr)->bV5XPelsPerMeter; infohdr.biYPelsPerMeter = ((PBITMAPV5HEADER)ptr)->bV5YPelsPerMeter; break; #endif #if ((WINVER >= 0x0400) && (_WIN32_WINNT >= 0x0400)) case sizeof(BITMAPV4HEADER): ptr = new BITMAPV4HEADER; isOk = ReadFile(hFile, (BYTE*)ptr + sizeof(DWORD), sizeof(BITMAPV4HEADER) - sizeof(DWORD), &noBytesRead, NULL); if( !isOk || (noBytesRead == 0) ) __leave; infohdr.biBitCount = ((PBITMAPV4HEADER)ptr)->bV4BitCount; infohdr.biClrImportant = ((PBITMAPV4HEADER)ptr)->bV4ClrImportant; infohdr.biClrUsed = ((PBITMAPV4HEADER)ptr)->bV4ClrUsed; infohdr.biCompression = ((PBITMAPV4HEADER)ptr)->bV4V4Compression; infohdr.biHeight = ((PBITMAPV4HEADER)ptr)->bV4Height; infohdr.biPlanes = ((PBITMAPV4HEADER)ptr)->bV4Planes; infohdr.biSizeImage = ((PBITMAPV4HEADER)ptr)->bV4SizeImage; infohdr.biWidth = ((PBITMAPV4HEADER)ptr)->bV4Width; infohdr.biXPelsPerMeter = ((PBITMAPV4HEADER)ptr)->bV4XPelsPerMeter; infohdr.biYPelsPerMeter = ((PBITMAPV4HEADER)ptr)->bV4YPelsPerMeter; break; #endif case sizeof(BITMAPINFOHEADER): isOk = ReadFile(hFile, (BYTE*)(&infohdr) + sizeof(DWORD), sizeof(BITMAPINFOHEADER) - sizeof(DWORD), &noBytesRead, NULL); if( !isOk || (noBytesRead == 0) ) __leave; break; default: __leave; } if(!imageMemAlloc(&infohdr)) __leave; if(bmInfoHeader->biClrUsed != 0){ isOk = ReadFile(hFile, RGBQuads, sizeof(RGBQUAD) * bmInfoHeader->biClrUsed, &noBytesRead, NULL); if( !isOk || (noBytesRead == 0) ) __leave; } isOk = ReadFile(hFile, imageBytes, bmInfoHeader->biSizeImage, &noBytesRead, NULL); if( !isOk ) __leave; status = true; } __finally { if(hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile); if(ptr != NULL) delete ptr; } return status; }

DIBitmap::operator PBITMAPINFO (    )  const [inline]

Overloaded cast function for statically casting the class to a pointer to a BITMAPINFO structure Returns: PBITMAPINFO : Definition at line 76 of file DIBitmap.h. References bmInfoHeader. { return (BITMAPINFO*) this->bmInfoHeader; }

const DIBitmap & DIBitmap::operator= (  const DIBitmap &    right )

Overloaded assignment operator Allows use of the assignement operator for easy copying Definition at line 439 of file DIBitmap.cpp. References clear(), getPBITMAPINFOHEADER(), and set(). { // Check for self assignement if(&right != this) { clear(); if( right.getPBITMAPINFOHEADER() != NULL ){ set(right); } } return *this; }

bool DIBitmap::saveFile (  PCTSTR    fName, const DWORD    disposition = CREATE_ALWAYS )  const

Saves the bitmap to the specified file. Parameters: fName  : The file name as a TCHAR string disposition  : optional file creatation disposition CREATE_NEW (default) Creates a new file. The function fails if the specified file already exists. CREATE_ALWAYS Creates a new file. If the file exists, the function overwrites the file and clears the existing attributes. TRUNCATE_EXISTING Opens the file. Once opened, the file is truncated so that its size is zero bytes. The function fails if the file does not exist. Returns: bool : true iff succesfully saved Definition at line 184 of file DIBitmap.cpp. References assignedMemory, and bmInfoHeader. Referenced by Cls_OnCommand(), and UpdateHandler::update(). { BITMAPFILEHEADER filehdr; DWORD noBytesWritten, offBits, sizeLessFileHdr; HANDLE hFile = INVALID_HANDLE_VALUE; bool status = false; BOOL isOk = true; // SEH ensures that handles are released but doesn't catch exceptions __try { if( fName == NULL || assignedMemory == NULL) __leave; if( !(disposition == CREATE_NEW || disposition == CREATE_ALWAYS || disposition == TRUNCATE_EXISTING) ) __leave; hFile = CreateFile(fName, GENERIC_WRITE, 0,NULL, disposition, FILE_ATTRIBUTE_NORMAL, NULL); if(hFile == INVALID_HANDLE_VALUE) __leave; offBits = sizeof(BITMAPINFOHEADER) + (bmInfoHeader->biClrUsed * sizeof(RGBQUAD)); sizeLessFileHdr = offBits + bmInfoHeader->biSizeImage; filehdr.bfType = (WORD) 0x4d42; filehdr.bfSize = (DWORD) (sizeLessFileHdr + sizeof(BITMAPFILEHEADER)); filehdr.bfReserved1 = 0; filehdr.bfReserved2 = 0; filehdr.bfOffBits = (DWORD) (sizeof(BITMAPFILEHEADER) + offBits); isOk = WriteFile(hFile, &filehdr, sizeof(BITMAPFILEHEADER), &noBytesWritten, NULL); if( !isOk || (noBytesWritten != sizeof(BITMAPFILEHEADER)) ){ isOk = false; __leave; } isOk = WriteFile(hFile, bmInfoHeader, sizeLessFileHdr, &noBytesWritten, NULL); if( !isOk || (noBytesWritten != sizeLessFileHdr) ){ isOk = false; __leave; } status = true; } __finally { if(hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile); // If file can not be written correctly then delete it // Only needs to happens if a new file/truncated file // has been correctly created if(!isOk) DeleteFile(fName); } return status; }

bool DIBitmap::set (  const PBITMAPINFO    dib )

Sets the object given a pointer to a packed bitmap. Parameters: dib  : Pointer to a packed bitmap (BITMAPINFO structure) Returns: bool : returns true iff object successfully set Definition at line 373 of file DIBitmap.cpp. References bmInfoHeader, clear(), and imageMemAlloc(). Referenced by DIBitmap(), and operator=(). { bool rtrn= false; if( dib == NULL ) return false; if( (PBITMAPINFOHEADER)dib == bmInfoHeader ) return true; __try { if( !imageMemAlloc((PBITMAPINFOHEADER)dib) ) __leave; int size = (sizeof(RGBQUAD) * bmInfoHeader->biClrUsed) + bmInfoHeader->biSizeImage; CopyMemory( (BYTE*) bmInfoHeader + sizeof(BITMAPINFOHEADER), (BYTE*) dib + sizeof(BITMAPINFOHEADER), size ); rtrn = true; } __except( (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) { clear(); } return rtrn; }

---

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

• DIBitmap.h
• DIBitmap.cpp

---