
#include <neoPixel.h>
#include "SDTools.h"
#include "bmpImage.h"
#include "filePath.h"
#include <resizeBuff.h>

#define SD_CS   4     // SD chip select pin number. Change to suit your setup.

neoPixel    display(32*32,2);
filePath    wd;

void setup() {

	Serial.begin(9600);
	SD.begin(SD_CS); 
  wd.setPath("/System/icons/standard/");  
  display.begin();
}


void setPixelColor(int x,int y,colorObj* color) {
  display.setPixelColor(32*y+x,color);
}


void displayBmp(const char* bmpPath) {

  bmpImage  theImage(bmpPath);
  RGBpack   thePixel;
  colorObj  aColor;

  theImage.openDocFile(FILE_READ);
  for (int y=0;y<32;y++) {
    for (int x=0;x<32;x++) {
      thePixel = theImage.getRawPixel(x,y);
      aColor.setColor(&thePixel);
      setPixelColor(x,y,&aColor);
    }
  }
  theImage.closeDocFile();
  display.show();
}


bool checkFile(pathItem*	item) {

  if (item->name[0]=='.') return false;
  if (!strstr(item->name,"32.BMP")) return false; 
  return true;
}


void listDirectory(void) {

  pathItem*		trace;
  int         numBytes;
  char*       path;
  
  path = NULL;                                                          //
  if (wd.getPathType()==fileType) {                             // If this is pointing to a file..? 
    Serial.println("Sorry, this is a file, not a directory.");  // Just wrong, we can't list a file.
    return;                                                     // Just walk away..
  } else {                                                      // Else, not a file. Good!
    numBytes = wd.numPathBytes();
    numBytes = numBytes + 14;
    resizeBuff(numBytes,&path);
    wd.refreshChildList();                                      // Make sure we have an up to date child list..
    if (wd.numChildItems()==0) {                                // Wait, no children to list?
      Serial.println("This directory is empty.");               // Tell the user.
      return;                                                   // And walk away.
    } else {                                                    // Else, we DO have kids to list.
      trace = wd.childList;																	    // Grab a pointer to the first child.
      while(trace) {																						// While we have a non-NULL pointer..
        if (checkFile(trace)) {																	// Pass this child through the crucible of the user's filter function.
          strcpy(path,wd.getPath());
          strcat(path,trace->getName());
          Serial.println(path);
          displayBmp(path);
          delay(2000);
        }                                                       //
        trace = (pathItem*)trace->dllNext;											// Jump to the next item on the list.
      }
    }
  }
  resizeBuff(0,&path);
}


// Your loop where it parses out all your typings.
void loop(void) {
	listDirectory();
  delay(2000);
}


sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

SD
LC_baseTools
LC_neoPixel


libraries.txt

#ifndef SDTools_h
#define SDTools_h

#include <SD.h>

//#define FILE_TRUNCATE (O_READ | O_WRITE | O_CREAT)	// See if this works..

//****************************************************************************************
//
// Little indian, big indian?
// Some files have the 2 & 4 byte integers stored in reverse byte order than what we use
// here in Arduinoland. These routines swap 'em back. (We use little indian)
//
//****************************************************************************************

// Put this at top of function, and for the duration of the function, all intergers will
// be swapped both reading and writing to files.
#define	BYTE_SWAP	bigIndian swap;


// This sets if we flip or not.
extern bool flipBytes;								


// This is set if an big/small indian function has a file error.
extern bool	SDFileErr;


// Stack based class thata flips the byte order for the calls while it's in scope.
// Automatically flips them back when going out of scope. NOT reentrant!
class bigIndian {

	public:
				bigIndian(void);
	virtual	~bigIndian(void);
};


// For reading two byte numbers.
//bool read16(uint16_t* result,File f);
bool read16(void* result,File f);

// For writing two byte numbers.
bool write16(uint16_t val, File f);

// For reading four byte numbers.
//bool read32(uint32_t* result,File f);
bool read32(void* result,File f);  
  
// For writing four byte numbers.  
bool write32(uint32_t val, File f);


// ***************************************************
//          End of the big/little indian thing.
// ***************************************************


// Returns true if this folderPath can be found, or created.
bool createFolder(const char* folderPath);


// Given a path, baseName and extension this hands back a string with a path to an unused
// numbered file. For example "/docs/NoName5.doc". IF it can not allocated this file it
// will return NULL. IF THIS IS A SUCCESS, YOU MUST COPY THE RETURNED STRING. It won't last
// very long before being recycled.
char* numberedFilePath(const char* folderPath,const char* baseName,const char* extension);


// TOTAL HACK TO GET AROUND NO FILE truncate() CALL..
File TRUNCATE_FILE(const char* path);


// fcpy() : The file version of strcpy(). The dest file must be open for writing. The src
// file must be, at least, open for reading. (Writing is ok too) The dest file index is
// left pointing to the end of the file. The src file index is not changed.
void fcpy(File dest,File src);


// fcat() : The file version of strcat(). The dest file must be open for writing. The src
// file must be, at least, open for reading. (Writing is ok too) The dest file index is
// left pointing to the end of the file. The src file index is not changed.
void fcat(File dest,File src);


// Pass in your extension and a file path. returns if the file extension matches.
bool extensionMatch(const char* extension,const char* filePath);



#endif


SDTools.h

#include "SDTools.h"
#include <resizeBuff.h>
#include <strTools.h>




// The string that is passed back when asking for a numbered file name. 
char* filePathStr = NULL;


// Once you copy or use the file path string, you can safely call this to recycle it's
// memory.
void freePathStr(void) { resizeBuff(0,&filePathStr); }



// ***************************************************
//         Big indian, little indian land.
// ***************************************************


// This sets if we flip integer bytes or not.
bool flipBytes = false;	


// Stack based class that flips the byte order for the calls while it's in scope.
// Automatically flips them back when going out of scope. NOT reentrant!

bigIndian::bigIndian(void) { flipBytes=true; }
bigIndian::~bigIndian(void) { flipBytes=false; }


// If one of these big/little indian number readers/writers has an error. This will be set
// to true. The idea is to clear it before doing your reads/writes. Then check it to see
// if everything went ok.
bool	SDFileErr = false;


// For reading two byte numbers.
//bool read16(uint16_t* result,File f) {
bool read16(void* result,File f) {

	uint8_t	tempByte;
	
	if (f.read(result,2)==2) {
		if (flipBytes) {
			tempByte = ((uint8_t *)result)[1];
			((uint8_t *)result)[1] = ((uint8_t *)result)[0];
			((uint8_t *)result)[0] = tempByte;
		}
		return true;
	}
	SDFileErr = true;
	return false;
}


// For writing two byte numbers.
bool write16(uint16_t val, File f) {

	uint8_t	tempByte;
	
	if (flipBytes) { 
		tempByte = ((uint8_t *)&val)[1];
		((uint8_t *)&val)[1] = ((uint8_t *)&val)[0];
		((uint8_t *)&val)[0] = tempByte;
	}
	if (f.write((char*)&val,4)==4) {
		return true;
	}
	SDFileErr = true;
	return false;
}  


// For reading four byte numbers.
//bool read32(uint32_t* result,File f) {
bool read32(void* result,File f) {
  
  	uint8_t	tempByte;
  	
	if (f.read(result,4)==4) {
		if (flipBytes) {
			tempByte = ((uint8_t *)result)[3];
			((uint8_t *)result)[3] = ((uint8_t *)result)[0];
			((uint8_t *)result)[2] = ((uint8_t *)result)[1];
			((uint8_t *)result)[1] = ((uint8_t *)result)[2];
			((uint8_t *)result)[0] = tempByte;
		}
		return true;
	}
	SDFileErr = true;
	return false;
}
  
  
// For writing four byte numbers.  
//bool write32(uint32_t val, File f) {
bool write32(uint32_t val, File f) {
  
  	uint8_t	tempByte;
  	
	if (flipBytes) {
		tempByte = ((uint8_t *)&val)[3];
		((uint8_t*)&val)[3] = ((uint8_t*)&val)[0];
		((uint8_t*)&val)[2] = ((uint8_t*)&val)[1];
		((uint8_t*)&val)[1] = ((uint8_t*)&val)[2];
		((uint8_t*)&val)[0] = tempByte;
	}
	if(f.write((char*)&val,4)==4) {
		return true;
	}
	SDFileErr = true;
	return false;
}  


// ***************************************************
//                End of the reservation.
// ***************************************************



// Returns true if this folderPath can be found, or created.
bool createFolder(const char* folderPath) {

	File	theDir;
	int	numChars;
	bool	success;
	char*	dirPath;
	
	success = false;											// If we started with a success, why start?
	if (folderPath) {											// If we got a path. (Sanity)
		numChars = strlen(folderPath);					// Lets see how long the path is.
		if (folderPath[numChars-1]=='/') {				// Paths end in '/'. Make sure this has that.
			dirPath = NULL;									// Dynamic starts with NULL.
			if (resizeBuff(numChars+1,&dirPath)) {		// WAIT!! Patching bug here. If you pass 
				strcpy(dirPath,folderPath);				// "name/" and it fails, it crashes!
				dirPath[numChars]='\0';						// Clip off the trailing '/'. No '/' no crash.
				theDir=SD.open(dirPath,FILE_READ);		// Lets try to open the path they gave us.
				if (theDir) {									// If we were able to open the path they gave us..
					success = theDir.isDirectory();		// If its a directory, its a success.
					theDir.close();							// Close the directory we opened.
				} else {											// Else, there was no directory of that name..
					success = SD.mkdir(dirPath);			// If we can create the directory, its a success.
				}													//
				resizeBuff(0,&dirPath);						// Toss the temp buff.
			}														//
		}															//
	}																//
	return success;											// Return whether we were a success or not?
}	


// Given a path, baseName and extension this hands back a string with a path to an unused
// numbered file. For example "/docs/NoName5.doc". IF it can not allocated this file it
// will return NULL. IF THIS IS A SUCCESS, YOU MUST COPY THE RETURNED STRING. I won't last
// very long before being recycled.
char* numberedFilePath(const char* folderPath,const char* baseName,const char* extension) {

	File	tempFile;
	int	numBytes;
	int	maxNum;
	int	fileNum;
	char	numStr[8];
	bool	done;
	
	if (strlen(baseName)<8 													// If the params make sense..
		&& strlen(extension)<=4 											//
		&& folderPath[0]=='/') {											//
		if (createFolder(folderPath)) {									// If we can find/create the folder..
			maxNum = pow(10,8 - strlen(baseName));						// How many chars we got for a value?
			maxNum--;															// Actually, you get one too many.
			numBytes = strlen(folderPath) + 8 + 4 + 1;				// Path, max name, max extension, '\0'.
			if (resizeBuff(numBytes,&filePathStr)) {					// If we can get the RAM..
				fileNum = 1;													// Starting at one.
				done = false;													// 'Cause we ain't.
				do {																// Do for each..
					itoa(fileNum++,numStr,7);								// Setup a number string.
					strcpy(filePathStr,folderPath);						// Build up the test path.
					strcat(filePathStr,baseName);							// Add the base name.
					strcat(filePathStr,numStr);							// Add the number string.
					strcat(filePathStr,extension);						// Add the extension.
					tempFile = SD.open(filePathStr,FILE_READ);		//	Try to open this file for reading.
					if (tempFile) {											// If the file opened..
						tempFile.close();										// We just close it and move on.
					} else {														// Else, we have a possible candidate here.
						done = true;											// Either its the real deal or an error. In any case, we are done. 
						tempFile = SD.open(filePathStr,FILE_WRITE);	// Try to create the file we couldn't open.
						if (tempFile) {										// If we were able to create the file..
							tempFile.close();									// Close it.
							return filePathStr;								// And We'll call that a success!
						}															//
					}																//
				} while(!done && fileNum<maxNum);						// Loop while we are not done. (And have numbers to go.)
				resizeBuff(0,&filePathStr);								// If we get here, its a failure so recycle the RAM.
			}																		//
		}																			//
	}																				//
	return filePathStr;														// And this'll be returning a NULL.
}


// TOTAL HACK TO GET AROUND NO FILE truncate() CALL..
File TRUNCATE_FILE(const char* path) {
	
	SD.remove(path);							// Delete the file. So now it has zero bytes of data.
	return SD.open(path,FILE_WRITE);		// Re-open the file. Now its been truncated. (Sigh..)
}													// AND NOW WE HAVE A TRUNCATED FILE.


/*
void truncateFile(File aFile) {

	char* path;
	uint8_t truncate(uint32_t size);
	path = NULL;
	aFile							
*/


// fcpy() : The file version of strcpy(). The dest file must be open for writing. The src
// file must be, at least, open for reading. (Writing is ok too) The dest file index is
// left pointing to the end of the file. The src file index is not changed.
void fcpy(File dest,File src) {
	
	unsigned long	filePos;
	maxBuff	cpyBuff(src.size());
	unsigned long	numBytes;
	unsigned long	remaingBytes;
	
	
	filePos = src.position();				// Lets save the file pos for miss user.
	src.seek(0);								// Point at first byte of the src file.
	
	// HACK, THERE IS NO truncate() CALL SO WE DO IT BEFORE THIS CALL.
	//dest.truncate();							// Clear out the old. I wish!
	// AND THERE YOU GO..
	
	remaingBytes = src.size();
	for (int i=0;i<cpyBuff.numPasses;i++) {
		numBytes = min(cpyBuff.numBuffBytes,remaingBytes);
		src.read((uint8_t*)(cpyBuff.theBuff),numBytes);
		dest.write((char*)(cpyBuff.theBuff),numBytes);
		remaingBytes = remaingBytes - numBytes;
	}
	src.seek(filePos);						// Put it back like we found it.						
}


// fcat() : The file version of strcat(). The dest file must be open for writing. The src
// file must be, at least, open for reading. (Writing is ok too) The dest file index is
// left pointing to the end of the file. The src file index is not changed.
void fcat(File dest,File src) {
	
	unsigned long	filePos;
	maxBuff	cpyBuff(src.size());
	unsigned long	numBytes;
	unsigned long	remaingBytes;
	
	dest.seek(dest.size());												// Point at end of the dest file.
	filePos = src.position();											// Lets save the file pos for miss user.
	src.seek(0);															// Point at first byte of the src file.
	remaingBytes = src.size();											// Get the remaining bytes to copy.
	for (int i=0;i<cpyBuff.numPasses;i++) {						// For every pass through..
		numBytes = min(cpyBuff.numBuffBytes,remaingBytes);		// Use buffer size or remaining bytes.
		src.read((uint8_t*)(cpyBuff.theBuff),numBytes);			// Fill the buffer.
		dest.write((char*)(cpyBuff.theBuff),numBytes);			// Write out the buffer.
		remaingBytes = remaingBytes - numBytes;					// Recalculate the remaining bytes.
	}																			// 
	src.seek(filePos);													// Put it back like we found it.					
}


// Pass in your extension and a file path. returns if the file extension match.
bool extensionMatch(const char* extension,const char* filePath) {

	char*	ext;
	char* path;
	char*	pathExt;
	int	index;
	bool	success;
	
	success	= false;										// Not a success yet.
	ext		= NULL;										// Local pointers start at NULL
	path		= NULL;										// Yeah, you too!
	heapStr(&ext,extension);							// Save off local copy of the extension.
	heapStr(&path,filePath);							// Save off local copy of the path.
	upCase(ext);											// Up case both;
	upCase(path);											// I said both.
	index = strlen(path)-1;								// Starting index at last character of path.
	while(index && path[index]!='.') index--;		// Run backwards looking for the dot.
	if (index) {											// If not zero, must be the dot.
		pathExt = &(path[index]);						// Grab the address of this character.
		success = !strcmp(ext,pathExt);				// Do a string compare. Save the result
	}															//
	freeStr(&ext);											// Free the local copy of the extension.
	freeStr(&path);										// Free the local copy of the path.
	return success;										// Return our results.
}
	
	

SDTools.cpp

#include "baseImage.h"

// Just setup default values..
baseImage::baseImage(const char* filePath)
	: docFileObj(filePath) {

	width		= 0;
	height	= 0;
}

		
// Nothing to do at this level..
baseImage::~baseImage(void) { }


int baseImage::getWidth(void) { return width; }


int baseImage::getHeight(void) { return height; }

		
// Grab a pixel from this location from your image file. Return it as a colorObj.
// Typically this is what the outside user would call.
colorObj baseImage::getPixel(int x,int y) {

	colorObj	aColor;
	RGBpack	aPack;

	aColor.setColor(&black);				// Black's a good default.
	if (mode != fClosed) {					// If the file's open for anything..	
		if(checkXYLmits(x,y)) {				// Make sure the x,y params are "sane".
			aPack = getRawPixel(x,y);			// Ask inherited to give us the packed pixel.
			aColor.setColor(&aPack);		// Set it up as a colorObj.
		}
	}
	return aColor;								// return the colorObj.
}


// Given a colorObj, set this pixel to that color. (In the editing file)
bool baseImage::setPixel(int x,int y,colorObj* aColor) {

	RGBpack	aPack;
	bool		success;
	
	success = false;										// Not a success yet.
	if (mode==fOpenToEdit || mode==fEdited) {		// If the file's open for editing..
		if (checkXYLmits(x,y)) {						// If the point is within the image..											
			aPack = aColor->packColor();				// Pack up the color.
			setRawPixel(x,y,&aPack);					// Set the pixel.
			success = true;								// Looks good!
		}
	}
	return success;										// Pass back our result.
}


// Grab a row of pixels from this image.
bool baseImage::getRow(int x,int y,int numPix,RGBpack* RGBArray) {

	int	xMax;
	int	arrayIndex;
	bool	success;
	
	success = false;													// Not a success yet.
	if (mode != fClosed) {											// If the file's open for anything..
		xMax = x + numPix;											// Calculate xMax.
		if (checkXYLmits(x,y)) {									// If the start point is within the image..
			if (checkXYLmits(xMax-1,y)) {							// If the end point is ALSO within the image..
				arrayIndex = 0;										// Start array index at zero.
				for(int i=x;i<xMax;i++) {							// Loop through all the pixels..
					RGBArray[arrayIndex] = getRawPixel(i,y);	// Pass in the row, offset and file, get back the pixel.
					arrayIndex++;										// Bump up the array index.
				}
				success = true;										// At this point we're calling it a success.
			}
		}
	}
	return success;													// Pass back our result.
}


// Given an RGBpack array, set this row of pixels in the temp image file to
// these colors.
bool baseImage::setRow(int x,int y,int numPix,RGBpack* RGBArray) {
		
	int	xMax;
	int	arrayIndex;
	bool	success;
	
	success = false;													// Not a success yet.
	if (mode==fOpenToEdit || mode==fEdited) {					// If the file's open for editing..
		xMax = x + numPix;											// Calculate xMax.
		if (checkXYLmits(x,y)) {									// If the start point is within the image..
			if (checkXYLmits(xMax,y)) {							// If the end point is ALSO within the image..
				arrayIndex = 0;										// Start array index at zero.
				for(int i=x;i<xMax;i++) {							// Loop through all the pixels..
					setRawPixel(i,y,&(RGBArray[arrayIndex]));	// Pass in the row, offset and file, get back the pixel.
					arrayIndex++;										// Bump up the array index.
				}
				success = true;										// At this point we're calling it a success.
			}
		}
	}
	return success;													// Pass back our result.
}


bool baseImage::checkXYLmits(int x, int y) {

	if (x < 0 || x >= width) return false;		// If x is negative or past the end, bail.
	if (y < 0 || y >= height) return false;	// If y is negative or past the bottom, bail.
	return true;										// If we got this far, call it good.
}

baseImage.cpp

#ifndef baseImage_h
#define baseImage_h

#include "docFileObj.h"
#include <colorObj.h>

	
class baseImage :	public docFileObj {

	public:
					baseImage(const char* filePath);
	virtual		~baseImage(void);
	
					int		getWidth(void);
					int		getHeight(void);
	virtual		colorObj	getPixel(int x,int y);
	virtual		RGBpack	getRawPixel(int x,int y)=0;
	virtual		bool		setPixel(int x,int y,colorObj* aColor);
	virtual		void		setRawPixel(int x,int y,RGBpack* anRGBPack)=0;
	virtual		bool		getRow(int x,int y,int numPix,RGBpack* RGBArray);
	virtual		bool		setRow(int x,int y,int numPix,RGBpack* RGBArray);
					bool		checkXYLmits(int x, int y);
					
	protected:				
					int		width;
					int		height;
};

#endif


baseImage.h

#ifndef bmpImage_h
#define bmpImage_h

#include "baseImage.h"
#include <colorObj.h>


bool createNewBMPFile(const char* newPath,int inWidth,int inHeight);


class bmpImage :	public baseImage {

	public:
				bmpImage(const char* filePath);
	virtual	~bmpImage(void);
	
				void		setPWH(const char* imgPath,int w,int h);
	virtual	bool		setNewBMPFile(const char* BMPPath,int w,int h);
	virtual	bool		createNewDocFile(void);
	virtual	RGBpack	getRawPixel(int x,int y);
	virtual	void		setRawPixel(int x,int y,RGBpack* anRGBPack);	
	virtual	bool		checkDoc(File inFile);
				uint32_t	fileIndex(int x,int y);
					
	protected:
				
				char*		newImgPath;
				int		newW;
				int		newH;
				bool		rightSideUp;
				uint32_t	imageOffset;
				int16_t	pixBytes;
				int32_t	bytesPerRow;
};

#endif

bmpImage.h

#include "bmpImage.h"
#include <resizeBuff.h>
#include <strTools.h>
#include "SDTools.h"
//#include <debug.h>


#define DEF_IMAGE_OFFSET	54
#define DEF_DEPTH				32
#define COLOR_BUF_SIZE		4   // When grabbing a color off a bitmap you get 3 or 4 bytes. Go big!

// .bmp files have the 2 & 4 byte numbers stored in reverse byte order than what we use
// here in Arduinoland. These routines swap 'em back. (Sure seems like they aren't doing
// anything to me though.. Turns out they didn't do anything.
// 
// For 2 byte numbers.
// uint16_t read16(File f) {
// 
//     uint16_t result;
//   
//     ((uint8_t *)&result)[0] = f.read(); // LSB
//     ((uint8_t *)&result)[1] = f.read(); // MSB
//     return result;
//   }
// 
// 
// void write16(uint16_t val, File f) {
//   
//    f.write(((uint8_t *)&val)[0]);
// 	f.write(((uint8_t *)&val)[1]);
// }
// 
// 
// For 4 byte numbers.
// uint32_t read32(File f) {
//   
//     uint32_t result;
//   
//     ((uint8_t *)&result)[0] = f.read(); // LSB
//     ((uint8_t *)&result)[1] = f.read();
//     ((uint8_t *)&result)[2] = f.read();
//     ((uint8_t *)&result)[3] = f.read(); // MSB
//     return result;
//   }
//   
//   
// void write32(uint32_t val, File f) {
//   
// 	f.write(((uint8_t *)&val)[0]);
// 	f.write(((uint8_t *)&val)[1]);
// 	f.write(((uint8_t *)&val)[2]);
// 	f.write(((uint8_t *)&val)[3]);
// }  



// **************************************************************************
// ********************** Create new .bmp file function *********************
// **************************************************************************

bool createNewBMPFile(const char* newPath,int inWidth,int inHeight) {

	File		bmpFile;
	bool		success;
	uint32_t	pixBytes;
	uint32_t	bytesPerRow;
	uint32_t	fileSize;
	uint32_t	imageBytes;
	byte buff[4];
	
	success = false;															// Ok, assume failure..									
	bmpFile = SD.open(newPath,FILE_WRITE);								// See if its a valid path.
	if (bmpFile) {    														// We got a file?
		bmpFile.seek(0);														// Write puts us at the end. Move to the beginning.
		
		// File header 14 bytes.
		write16(0x4D42,bmpFile);											// It wants this. Whatever.
		pixBytes		= DEF_DEPTH / 8;										// Calc. bytes per pixel.
		bytesPerRow	= inWidth * pixBytes;								// Calc bytes per row.
		while(bytesPerRow % 4) bytesPerRow++;							// We need to pad it to a multiple of 4.
		fileSize = DEF_IMAGE_OFFSET + (inHeight * bytesPerRow);	// Calc. fileSize.
		write32(fileSize,bmpFile);											// Calculate and write out the file size.
		write32(0,bmpFile);													// write out our creator bits. All I've seen are zero.
		write32(DEF_IMAGE_OFFSET,bmpFile);								// Image offset. Always seems to be 54. Size of header?
		
		// DIB Header
		write32(40,bmpFile);													// DIB Header size. Always seems to be 40. 40->BITMAPINFOHEADER
		write32(inWidth,bmpFile);											// Width.
		write32(inHeight,bmpFile);											// Height. (Positive, upside down)
		
		write16(1,bmpFile);													// It wants a one here. Why? Its a mystery to me.
		write16(DEF_DEPTH,bmpFile);										// We're going for 32 bit image stuff here.
		write32(0,bmpFile);													// No compression.
		imageBytes = bytesPerRow * inHeight;							// Calc. total image bytes.
		write32(imageBytes,bmpFile);										// Stuff it in.
		buff[3] = 0;															// Padding.
		while(bmpFile.position()<DEF_IMAGE_OFFSET) {					// Just in case we didn't make it to the right spot..
			bmpFile.write(&(buff[3]),1);									// Force the issue!
		}
		buff[0] = 255;	// BLUE												// We're going for the color white.
		buff[1] = 255; // GREEN												//
		buff[2] = 255; // RED												//																			// Now..
		for (int y=0;y<inHeight;y++) {									// We're going to..
			for (int x=0;x<inWidth;x++) {									// Go to every pixel
				bmpFile.write(buff,4);										// Stamp out the 4 byte color.
			}																		//
		}																			//
		bmpFile.close();														// Default file has been initialized. Close the file.
		success = true;														// Made it this far? We're calling this a success!
	}																				//
	return success;															// Report our results.
}



//****************************************************************************************
// bmpImage class:
//****************************************************************************************


bmpImage::bmpImage(const char* filePath)
	: baseImage(filePath) { newImgPath = NULL; }


bmpImage::~bmpImage(void) { freeStr(&newImgPath); }


// Setup for the next createNewDocFile() call.
void bmpImage::setPWH(const char* imgPath,int w,int h) { 

	heapStr(&newImgPath,imgPath);
	newW	= w;
	newH	= h;
}


bool bmpImage::setNewBMPFile(const char* BMPPath,int w,int h) {

	tempStr newPath(BMPPath);								// Save a local copy..
	
	closeDocFile();											// Close the original file, if any.
	if (createNewBMPFile(newPath.getStr(),w,h)) {	// If we can setup the new file..
		if (changeDocFile(newPath.getStr())) {			// If we can change to this new file..
			return  true;										// We'll call that a success.
		}															//
	}																//
	return false;												// Return our success.
}


// We get a general "We need a new file now" call. So using defaults..
bool bmpImage::createNewDocFile(void) { return setNewBMPFile(newImgPath,newW,newH); }


// Grab a pixel from this location from your image file.
// Return it as a RGBpack.
RGBpack bmpImage::getRawPixel(int x,int y) {
	
	uint8_t	buf[COLOR_BUF_SIZE];
	RGBpack	aPack;
	uint32_t	index;
	//Serial.println("Going for pixel");
	if (mode != fClosed) {			// If we are not closed. IE valid open file.
    //Serial.println("Got pixel");
		index = fileIndex(x,y);		// Do the math for this pixel index.
		if (index != position()) {	// If we are NOT already there..
			seek(index);				// Point the file to our pixel.
		}									//
		read(buf,pixBytes);			// Grab the pixel.
		aPack.r = buf[2];				// Stuff the pack.
		aPack.g = buf[1];				//
		aPack.b = buf[0];				//
	}										//
	return aPack;						// Return the pack.
}


void bmpImage::setRawPixel(int x,int y,RGBpack* anRGBPack) {
	
	uint32_t	index;

	if (mode==fOpenToEdit || mode==fEdited) {		// If we are in an edit mode..
		index = fileIndex(x,y);							// Do the math for this pixel index.
		if (index != position()) {						// If we are NOT already there..
			seek(index);									// Point the file to our pixel.
		}														//
		write(anRGBPack->b);								// Write out the values.
		write(anRGBPack->g);								//
		write(anRGBPack->r);								//
	}
}


// Open the doc file and see if its what we expect. Then grab out the info. we need to
// "deal" with it.
bool bmpImage::checkDoc(File bmpFile) {

	uint32_t	creatorBits;	// A thing that seems to always be zero.
	uint32_t	DIBHeaderSize;	// And so is this thing.
	int32_t	imageHeight;	// Used as a temp. Can be negative.
	uint32_t	fileSize;
	int16_t	imageDepth;
	uint16_t	aWord;
	int32_t	aLong;
	bool		success;
	
	success = false;													// Ok, assume failure..									
	if (read16((void*)&aWord,bmpFile)) {						// If we can we read a word..
		if (aWord == 0x4D42) {										// If we have something or other..
			read32(&fileSize,bmpFile);								// We grab the file size.
			read32(&creatorBits,bmpFile);							// Creator bits
			read32(&imageOffset,bmpFile);							// image offset.
			read32(&DIBHeaderSize,bmpFile);						// read DIB header size?
			read32(&width,bmpFile);									// width? Good thing to save for later.
			read32(&imageHeight,bmpFile);							// Height? Negative means the data is right side up. Go figure..
			rightSideUp = imageHeight<0;							// Set a bool about that bit.
			height = abs(imageHeight);								// Bloody weird encrypting.
			read16(&aWord,bmpFile);									// Grab a couple bytes.
			if (aWord == 1) {											// if the next word is 1? What's this mean? Needs to be though.
				read16(&imageDepth,bmpFile);						// color depth.
				if (imageDepth == 24 || imageDepth == 32) {	// We can do 24 or 32 bits..
					pixBytes = imageDepth / 8;						// Bytes / pixel
					read32(&aLong,bmpFile);							// Grab 4 bytes.
					if (!aLong) {										// And no compression!
						bytesPerRow = width * pixBytes;			// Data takes up this much, but..
						while(bytesPerRow % 4) bytesPerRow++;	// We need to pad it to a multiple of 4.
						success = true;								// Made it this far? We can do this!
					}
				}
			}
		}
	}
	return success;
}


// Given an x,y location of a pixel. Hand back the file
// index of its location.
uint32_t bmpImage::fileIndex(int x,int y) {

	uint32_t  index;
	
	index = imageOffset;											// Starting here..
	if (rightSideUp) {											// The image is right side up?
		index = index + (y*bytesPerRow);						// Right side up
	} else {															// Else..
		index = index + ((height-y-1)*bytesPerRow);		// Upside down.
	}
	index = index + (x * pixBytes);							// Add offset for x.
	return index;													// Tell the world.
}




bmpImage.cpp

#include "docFileObj.h"
#include <resizeBuff.h>
#include <timeObj.h>
#include "filePath.h"
#include <strTools.h>

//#include <debug.h>


// A docFile object MUST have a path to exist. 	
docFileObj::docFileObj(const char* filePath) {
		
	docFilePath		= NULL;									// Dynamic things start at NULL.
	editFilePath	= NULL;									// Dynamic things start at NULL.
	returnBuffer	= NULL;									// Someone wants..  Say.. a path? Store it here. Pass this back.
	autoGenFile		= false;									// We assume this is NOT an autoGenerated temp file.
	mode 				= fClosed;								// We are NOT editing at the moment.
	heapStr(&docFilePath,filePath);						// Grab our local copy of the file path.		
}


docFileObj::~docFileObj(void) {

	closeDocFile();					// Close files and Recycle the editFile stuff.
	if (autoGenFile) {				// If this was originally an auto generated file..
		SD.remove(docFilePath);		// Delete the auto file. (This and changFile())
		autoGenFile = false;			// And we are no longer carrying an auto generated file.
	}
	freeStr(&docFilePath);			// Recycle the docFilePath.
	freeStr(&editFilePath);			// Recycle the editFilePath.
	freeStr(&returnBuffer);			// And the return buffer.
}


// Called by user to open a document.
//
// If opening for reading, its left open for reading. User MUST call close on it when
// finished.
// 
// If open for editing, this creates a clone of the doc file for editing and leaves that
// open to be used by the user for editing. And of course the user must call closed on it
// when finished. But, before that, saveDocFile() needs to be called for saving changes to
// the original file.
bool docFileObj::openDocFile(int openMode) {

	File	tempFile;
	bool	success;

	success = false;																// Not a success yet..
	if (docFilePath) {															// If we have a non-NULL path..
    if (openMode==FILE_WRITE) {											// If they want to edit this file..
			if (mode==fOpenToEdit || mode==fEdited) {						// If already open for editing.
				ourFile.seek(ourFile.size());									// Opening a file to WRITE assumes you start at the end.
				return true;														// Actually nothing else to do, return success!
			}
			if (mode==fOpenToRead) {											// If currently open to read..
				closeDocFile();													// We close the file to open later.
			}
			tempFile = SD.open(docFilePath,FILE_READ);					// Have a go at opening the doc file path.
			if (tempFile) {														// If we were able to open the file..
				if (checkDoc(tempFile)) {										// If the file passed the acid test..
					if (createEditPath()) {										// If we were able to create an edit path..
						ourFile = SD.open(editFilePath,FILE_WRITE);		// Have a go at opening the edit file path.	
						if (ourFile) {												// If we were able to open the edit file..
							ourFile.close();										// Close the file. We know we can open it.
							ourFile = TRUNCATE_FILE(editFilePath);
							fcpy(ourFile,tempFile);								// Copy the original to the new editing file.
							mode = fOpenToEdit;									// We are open for editing.
							success = true;										// Success!! The edit file is open and ready to use.
						}
					}
				}
				tempFile.close();													// Close the doc file.
			}
		} else if (openMode==FILE_READ) {									// If they just want to read this file..
			if (mode==fOpenToRead) {											// If we're already open to read..	
        ourFile.seek(0);													// Opening to READ assumes you start at the beginning of the file.
				return true;														// We're all set, lets go.
			} else {
				closeDocFile();													// We close the file.
        ourFile = SD.open(docFilePath,FILE_READ);					// Have a go at opening the doc file path.
				if (ourFile) {														// If we were able to open the file..
          if (checkDoc(ourFile)) {									// If the file passed the acid test..
						ourFile.seek(0);											// Point at first byte of the file.
						mode = fOpenToRead;										// We are open for reading.
						success = true;											// Success! The file is open and ready to read.
					}
				}
			}
		}
	}
	return success;
}


// If we are editing a file, we will save the edited version either to a new file path. If
// one has been passed in. Or if not, to the original doc file. If we are NOT editing AND
// we are passed in a new file path, we'll clone the doc file to this new path. If, in
// this case, no path is passed in? Its kind of.. "Shrug your shoulders and return false."
// The user is obviously just not getting it.
//
// In any case, if the new path is different than the original path, we leave here
// pointing at the new path.
bool docFileObj::saveDocFile(const char* newFilePath) {

	File			tempFile;
	char*			savedPath;
	fileModes	savedMode;
	bool			success;
	bool			changePath;
	
	success = false;														// Not a success yet.
	savedPath = NULL;														// Damn! forgot this last time.
	if (!newFilePath) {													// If we don't have a new file path..
		changePath = false;												// We don't change paths.
	} else if (!strcmp(newFilePath,docFilePath)) {				// If we DO have a new file path, but its the same as ours..
		changePath = false;												// We don't change paths.
	} else {																	// Else, only other choice is different paths..
		changePath = true;												// We DO change paths.
	}																			// Ok that's settled.
	if (!changePath) {													// If we're NOT going to change paths..
		if (mode==fEdited || mode==fOpenToEdit) {					// If we are using an editFile.
			tempFile = SD.open(docFilePath,FILE_WRITE);			// Have a go at opening our (real) file path.
			if (tempFile) {												// If we got the (real) file..
				tempFile.close();											// Close the file. We know we can open it.
				tempFile = TRUNCATE_FILE(docFilePath);				// Now we clear out the contents of the (real) file..
				fcpy(tempFile,ourFile);									// Copy the original editfile to the (real) file.
				tempFile.close();											// Close the (real) file.
				mode=fOpenToEdit;											// Edits have been saved so, mode is just open for edit.
				success = true;											// We are a success!
			}																	//
		} else {																// Else, mode is either closed or read only?
		}																		// We can not save to a closed or read only file.
	} else {																	// Else, we're doing a "saveAs" command.
		if (heapStr(&savedPath,docFilePath)) {						// If we can save off the document's path..
			if (mode==fEdited || mode==fOpenToEdit) {				// If we are using an editFile.
				tempFile = SD.open(newFilePath,FILE_WRITE);		// Have a go at opening our (new) file path.
				if (tempFile) {											// If we got the (new) file..
					tempFile.close();										// Close the file. We know we can open it.
					tempFile = TRUNCATE_FILE(newFilePath);			// Now we clear out the contents of the (new) file..
					fcpy(tempFile,ourFile);								// Copy the original editfile to the (new) file.
					tempFile.close();										// Close the (new) file.
					closeDocFile();										// Close ourselves..
					if (changeDocFile(newFilePath)) {				// Switch to the (new) file we saved.
						if (openDocFile(FILE_WRITE)) {				// If we can open the new doc file for writing..
							if (autoGenFile) {							// If this was originally an auto generated file..
								SD.remove(savedPath);					// Delete the auto file.
								autoGenFile = false;						// And we are no longer carrying an auto generated file.
							}													//
							success = true;								// Success!
						}														//
					}															//
				}																//
			} else {															// Else, mode is either closed or read only..
				savedMode = mode;											// Save off the mode we started with.
				if (mode==fClosed) {										// If the file's closed..
					openDocFile(FILE_READ);								// Give it a shot to open it for reading.
				}																//
				if (mode==fOpenToRead) {								// If the file is open to read..
					tempFile = SD.open(newFilePath,FILE_WRITE);	// Have a go at opening our (new) file path.
					if (tempFile) {										// If we got the (new) file..
						tempFile.close();									// Close the file. We know we can open it.
						tempFile = TRUNCATE_FILE(newFilePath);		// Now we clear out the contents of the (new) file..
						fcpy(tempFile,ourFile);							// Copy the original editfile to the (new) file.
						tempFile.close();									// Close the (new) file.
						closeDocFile();									// Close ourselves..
						if (changeDocFile(newFilePath)) {			// If we can switch to the (new) file we saved.
							if (savedMode==fOpenToRead) {				// If the original was open for reading..
								if (openDocFile(FILE_READ)) {			// If we can Open the new doc file for reading..
									success = true;						// We'll call that a success!
								}												//
							} else {											// Else it was originally closed..
								success = true;							// We'll call that a success as well!
							}													//
						}														//
					}															//
				}																//
			}																	//
			freeStr(&savedPath);											// Free the allocated string buffer.
		}																		//
	}																			//
	return success;														// Return the result, success or failure.
}


// This closes the docFile and if there is a temp file associated with it, that is
// deleted. There is no checking if this is ok to do, or if data will be lost. All that is
// up to the user of this object.
void docFileObj::closeDocFile(void) {

	switch(mode) {									// Mode decides our action..
		case fClosed		: return;			// If already closed, bolt.
		case fOpenToRead	:						// If open to read..
			ourFile.close();						// Close the file.
		break;										// And we're done.
		case fOpenToEdit	:						// Open for editing..
		case fEdited		:						// Or open for editing and have changes..
			ourFile.close();						// We close our document file.
			SD.remove(editFilePath);			// We remove our document editing file.
			freeStr(&editFilePath);				// Recycle the edit file path.
		break;										//
	}													//
	mode = fClosed;								// Mode is now, closed.
}


bool docFileObj::changeDocFile(const char* newPath) {
	
	if (newPath) {									// If we have a new file path. (Sanity, we'd better!)
		closeDocFile();							// Close our current document file.
		if (autoGenFile) {						// If this was originally an auto generated file..
			SD.remove(docFilePath);				// Delete the auto file.
			autoGenFile = false;					// And we are no longer carrying an auto generated file.
		}												//
		heapStr(&docFilePath,newPath);		// Save the new path.
		if (docFilePath) {						// If we got the RAM to store it..
			return true;							// Success!
		}												//					
	}													//
	return false;									// Either no name or not enough RAM to store it.
}



// Save off whether our document has an auto generated name or not.
void docFileObj::setAsAutoGen(bool trueFalse) { autoGenFile = trueFalse; }


// Return if we have unsaved changes or not.
bool docFileObj::fileEdited(void) {  return mode==fEdited; }


// This should pass back the name of the file for our document.
char* docFileObj::getName(void) {
	
	filePath aPath;
	
	aPath.setPath(docFilePath);
	heapStr(&returnBuffer,aPath.getCurrItemName());
	return returnBuffer;
}


// This should give us the folder path that our file is saved in.
char* docFileObj::getFolder(void) {

	filePath aPath;
	
	aPath.setPath(docFilePath);					// Setup the path obj for this path string.
	aPath.popItem();									// Pop the last file/folder off the string.
	heapStr(&returnBuffer,aPath.getPath());	// Allocate and save off the resultant path string.
	return returnBuffer;								// Return a pinter to the resultant path string.
}


byte docFileObj::peek(void) {

	if (mode != fClosed) {
		return ourFile.peek();
	} else {
		return 0;
	}
}


uint32_t docFileObj::position(void) {
	
	if (mode != fClosed) {
		return ourFile.position();
	} else {
		return 0;
	}
}


bool docFileObj::seek(uint32_t index) {
	
	if (mode != fClosed) {
		return ourFile.seek(index);
	} else {
		return false;
	}
}


uint32_t docFileObj::size(void) {
	
	if (mode != fClosed) {
		return ourFile.size(); 
	} else {
		return 0;
	}
}


int docFileObj::read(void) {

	if (mode != fClosed) {
		return ourFile.read();
	} else {
		return -1;
	}
}


uint16_t docFileObj::read(byte* buff,uint16_t numBytes) {

	if (mode != fClosed) {
		return ourFile.read(buff,numBytes);
	} else {
		return 0;
	}
}


size_t docFileObj::write(uint8_t aByte) {
	
	size_t	result;
	
	result = 0;
	if (mode==fOpenToEdit || mode==fEdited) {
		result = ourFile.write(&aByte,1);
		if (result>0) {
			mode = fEdited;
		}
	}
	return result;
}


size_t docFileObj::write(byte* buff,size_t numBytes) {
		
	size_t result;
	
	result = 0;
	if (mode==fOpenToEdit || mode==fEdited) {
		result = ourFile.write(buff,numBytes);
		if (result>0) {
			mode = fEdited;
		}
	}
	return result;
}	

		
// When the inherited opens up a document, this will be called to see if its parsable as
// the kind of file the class is looking for.
bool docFileObj::checkDoc(File inFile) { return false; }


// Find an unused temp file and assign it to the edit file path.
bool docFileObj::createEditPath(void) {
		
	heapStr(&editFilePath,numberedFilePath(TEMP_FOLDER,"efp",".tmp"));	// Find an unused valid temp file path.
	if (editFilePath) {																	// If we succeeded in this task..
		return true;																		// If we got here, we've succeeded!
	}																							//
	return false;																			// Otherwise, we return false.
}

										
					


docFileObj.cpp

#ifndef docFileObj_h
#define docFileObj_h


// Ok what's this do and what's it NOT do..
//
// TO create a docFileObj you need a path to a document. Simple as that. Once you have
// this you can..
//
// A) Open this file to read. and it will open the file, indexed to byte 0. It then
// leaves the file open to let you read out the data as you wish. When done, you simply
// call docFileClose, and it will cleanup the mess.
//
// B) Open this file to write, or edit. In this case it will create a temporary file with
// a copy of the original file. This file will be opened and indexed 0 for you to edit as
// you wish.
// 
// C) Saving changes or cloning files.. 
//
// If you call saveDocFile() while you are editing, with no path. It will save your edit
// file over the original file.
//
// If you call saveDocFile() with a path. It will save your edited file to the file of
// that path. 
//
// If You are not editing a file and call saveDocFile() with a path. It will clone the doc
// file to the file of that path.
//
// If you are not editing and call saveDocFile() with NO path. The object will probably 
// loose respect for you and you will not receive a Christmas card next Christmas.
//
// D) Closing files. When you are done reading or editing a file you can call
// closeDocFile() and this will close the file and, if present, delete the editing file as
// well.
// 
// E) Deleting the object will have much the same effect as calling closeDocFile(). In
// addition it releases the memory used for holding the file path strings.

#include "SDTools.h"

#define TEMP_FOLDER		"/temp/"		// Default folder to save temporary edit files in.
#define FILE_SEARCH_MS	500			// Amount of milliseconds allowed to find a temp file name.

// #ifdef FILE_WRITE
// #undef FILE_WRITE
// #define FILE_WRITE (O_READ | O_WRITE | O_CREAT)
// #endif
	
	
class docFileObj {

	public:
					enum fileModes { fClosed, fOpenToEdit, fEdited, fOpenToRead };
	
					docFileObj(const char* filePath);
	virtual		~docFileObj(void);
	
	virtual		bool			createNewDocFile(void) = 0;
	virtual		bool			openDocFile(int openMode);
	virtual		bool			saveDocFile(const char* newFilePath=NULL);
					void			closeDocFile(void);
					bool			changeDocFile(const char* newPath);
					void			setAsAutoGen(bool trueFalse=true);
					bool			fileEdited();
					char*			getName(void);
					char*			getFolder(void);	
					byte			peek(void);
					uint32_t		position(void);
					bool			seek(uint32_t index);
					uint32_t		size(void);
					int			read(void);
					uint16_t		read(byte* buff,uint16_t numBytes);
					size_t		write(uint8_t aByte);
					size_t		write(byte* buff,size_t numBytes);
					
	protected:
					
	virtual		bool		checkDoc(File inFile);
	virtual		bool		createEditPath(void);
					
					fileModes	mode;
					bool			autoGenFile;	
					char*			docFilePath;
					char*			editFilePath;
					char*			returnBuffer;
					File			ourFile;
					
							
};


#endif

docFileObj.h

#ifndef filePath_h
#define filePath_h

#include <lists.h>



extern void clipTrialingSlash(char* instr);



//****************************************************************************************
// pathItem:
//
// This will have the default actions. For all the different types pf path items. Root,
// folder, file. This pathItem is pure virtual so it'll never be able to be created.
//****************************************************************************************


enum pathItemType { noType, rootType, folderType, fileType };

class pathItem : public dblLinkListObj {

	public:
				pathItem(void);
				pathItem(pathItem* aGrandItem);
	virtual	~pathItem(void);
	
				pathItemType	getType(void);
	virtual	char* 			getName(void);
	virtual	int				getNumPathChars(void);
	virtual	void				addNameToPath(char* path) =0;
	virtual	pathItem*		getParent(void);
				pathItem*		getNext(void);
				
				pathItemType	ourType;
				char				name[13];
};



//****************************************************************************************
// rootItem:
//
// All paths start with one. Basically the SD card.
//****************************************************************************************


class rootItem : public	pathItem {
	
	public:
				rootItem(void);
	virtual	~rootItem(void);
	
	virtual	int	getNumPathChars(void);
	virtual	void	addNameToPath(char* path);
};



//****************************************************************************************
// fileItem:
//
// These are so useful. You can store stuff in 'em!
//****************************************************************************************


class fileItem : public	pathItem {
	
	public:
				fileItem(const char* fileName);
	virtual	~fileItem(void);
	
	virtual	void addNameToPath(char* path);
};



//****************************************************************************************	
// folderItem:
//
// A little more complicated than a silly old file.
//****************************************************************************************


class folderItem : public	pathItem {
	
	public:
				folderItem(const char* folderName);
	virtual	~folderItem(void);
	
	virtual	int	getNumPathChars(void);
	virtual	void	addNameToPath(char* path);
};



//****************************************************************************************
// filePath:
//
// And now we get to the actual filePath class. This is the bit the user will typically
// interact with. And the bit that will interact with the SD card's file system as well.
//
//****************************************************************************************


class filePath {

	public:
				filePath(void);
	virtual	~filePath(void);
	
	virtual	void				reset(void);
				int				numPathBytes(void);
				pathItemType	getPathType(void);
				char*				getPathName(void);
				pathItemType	checkPathPlus(const char* inPath);
				bool				addPath(const char* inPath);
	virtual	bool				setPath(const char* inPath);
	virtual	char*				getPath(void);
				pathItem*		getCurrItem(void);
				char*				getCurrItemName(void);
				void				dumpChildList(void);
				void				refreshChildList(void);
				int				numChildItems(void);
				pathItem*		getChildItemByName(const char* name);
				bool				pushChildItemByName(const char* name);
	virtual	bool				pushItem(pathItem* theNewGuy);
	virtual	void				popItem(void);
				bool				clearDirectory(void);
				bool				deleteCurrentItem(void);
				
				pathItem*	pathList;
				pathItem*	childList;
				char*			path;
};

#endif