#include <SD.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include <idlers.h>
#include "screen.h"
#include "adafruit_1947_Obj.h"
#include "ourOSObj.h"

void setup() {
  Serial.begin(57600);
  if (!initScreen(ADAFRUIT_1947,ADA_1947_SHIELD_CS,PORTRAIT)) {  // Init screen.
      Serial.println("NO SCREEN!");                               // Screen init failed. Tell user.
      Serial.flush();                                             // Make sure the mesage gets out.
      while(true);                                                // Lock the process here.
   }
   screen->fillScreen(&black);  
   if (!SD.begin(ADA_1947_SHIELD_SDCS)) {                         // With icons, we now MUST have an SD card.
      Serial.println("NO SD CARD!");                              // Tell user we have no SD card.
      Serial.flush();                                             // Make sure the mesage gets out.
      while(true);                                                // Lock the process here.
   }
   ourEventMgr.begin();                                           // Boot Event manager.
   ourOS.begin();                                                 // Boot OS manager.
}


void loop(void) {

  idle();         // Idlers get their time.
  ourOS.loop();   // ourOS gets time to pass on to the current panel.
}

RPN Calculator & Breakout game.ino

diagram.json

SD
Adafruit FT6206 Library
Adafruit BusIO
Adafruit GFX Library
Adafruit ILI9341
Adafruit NeoPixel
Adafruit SSD1331 OLED Driver Library for Arduino
Adafruit SSD1351 library
Adafruit STMPE610
Adafruit TouchScreen
LC_baseTools

libraries.txt

#include "baseGraphics.h"
#include <math.h>

#define DEF_LOC_X  16    // Just anything so the user can see something.
#define DEF_LOC_Y  16
#define DEF_SIZE_X 16
#define DEF_SIZE_Y 16

/*
void printPoint(point* inPt,char* name) {

	Serial.print(name);
	Serial.print(inPt->x);
	Serial.print(F(", "));
	Serial.println(inPt->y);
}
*/
	
int	xDistance(point ptA,point ptB) { return ptB.x - ptA.x; }


int	yDistance(point ptA,point ptB) { return ptB.y - ptA.y; }


float distance(point ptA,point ptB) {

	float widthSq;
	float heighSq;
	
	widthSq = pow(xDistance(ptA,ptB),2);
	heighSq = pow(yDistance(ptA,ptB),2);
	return sqrt(widthSq + heighSq);
}


float	angle(point ptA,point ptB) {

	float xDist;
	float yDist;
	float	angle;
		
	xDist = xDistance(ptA,ptB);
	yDist	= yDistance(ptA,ptB);
	if (xDist) {
		angle = atan(yDist/xDist);
	} else {
		angle = M_PI/2;
	}
	return angle;
}


/*
// HANDY for tracing issues through the drawing code.
void rect::printRect(char* label) {

	Serial.print(label);
	Serial.print(F("x:"));Serial.print(x);Serial.print(F(" "));
	Serial.print(F("y:"));Serial.print(y);Serial.print(F(" "));
	Serial.print(F("w:"));Serial.print(width);Serial.print(F(" "));
	Serial.print(F("h:"));Serial.println(height);
}
*/


rect::rect(void) {
   
   setLocation(DEF_LOC_X,DEF_LOC_Y);
   setSize(DEF_SIZE_X,DEF_SIZE_Y);
 }
 
 
rect::rect(rect* inRect) { setRect(inRect); }


rect::rect(int inX, int inY, int inWidth,int inHeight) {
   
   setRect(inX,inY,inWidth,inHeight);
}

 
rect::~rect(void) { }
 
 
void  rect::setLocation(int inX, int inY) {
  
  x = inX;
  y = inY;
}


void  rect::setSize(int inWidth,int inHeight) {

  width = inWidth;
  height = inHeight;
}


void rect::setRect(rect* inRect) {
  
  setLocation(inRect->x,inRect->y);
  setSize(inRect->width,inRect->height);
}


void rect::setRect(point* inPt1,point* inPt2) {

  int locX = min(inPt1->x,inPt2->x);
  int locY = max(inPt1->y,inPt2->y);
  int width = abs((int)inPt1->x-(int)inPt2->x);
  int height = abs((int)inPt1->y-(int)inPt2->y);
  setLocation(locX,locY);
  setSize(width,height);
}


void rect::setRect(int inX, int inY, int inWidth,int inHeight) {

	setLocation(inX,inY);
   setSize(inWidth,inHeight);
}

// Become the enclosing rect of yourself and this rect.
void  rect::addRect(rect* inRect) {

	rect	result(this);
	
	if (inRect)	{													// If we got a rect..
		result.x			= min(x,inRect->x);					// X would be the minimum of ours && inRect's x values.
		result.y			= min(y,inRect->y);					// Y would be the minimum of ours && inRect's y values.
		if (maxX()>inRect->maxX()) {							// If our max x is larger that inRect's max x..
			result.width = maxX() - result.x;				// Then width would be Our max x minus result's x value.
		} else {														// Else, if our max x is NOT larger than BinRect's max x..
			result.width = inRect->maxX() - result.x;		// Then width would be inRect's max x minus the resulting x value.
		}
		if (maxY()>inRect->maxY()) {							// If our max y is larger that inRect's max y..
			result.height = maxY() - result.y;				// Then height would be our max y minus result's y value.
		} else {														// Else, if our max Y is NOT larger than inRect's max Y..
			result.height = inRect->maxY() - result.y;	// Then width would be inRect's max y minus the resulting y value.
		}
	}
	setRect(&result);
}
	
	
	
	
void rect::insetRect(int inset) {

	x = x + inset;
	y = y + inset;
	width = width - (2*inset);
	height = height - (2*inset);
}
          	
          	
int rect::maxX(void) { return(x + width); }
int rect::maxY(void)  { return(y + height); }
int rect::minX(void) { return(x); }
int rect::minY(void)  { return(y); }


bool rect::inRect(int inX, int inY) {

  return(
  inX >= minX() &&
  inX <= maxX() &&
  inY >= minY() &&
  inY <= maxY()
  );
}


bool rect::inRect(point* inPoint) { return inRect(inPoint->x,inPoint->y); }


point rect::getCorner(rectPt corner) {

	point	tempPt;
	
	switch(corner) {
		case topLeftPt :
			tempPt.x = x;
			tempPt.y = y;
		break;
		case topRightPt :
			tempPt.x = x + width;
			tempPt.y = y;
		break;
		case bottomLeftPt :
			tempPt.x = x;
			tempPt.y = y + height;
		break;
		case bottomRightPt :
			tempPt.x = x + width;
			tempPt.y = y + height;
		break;
	}
	return tempPt;
}


// Are we touching this passed in rectangle?
bool rect::overlap(rect* checkRect) {

		if(maxX()<checkRect->minX()) return false;
		if(minX()>checkRect->maxX()) return false;
		if(maxY()<checkRect->minY()) return false;
		if(minY()>checkRect->maxY()) return false;
		return true;
	}


// Are we contained in this passed in rectangle?
bool rect::isSubRectOf(rect* checkRect) {
	
	point tr;
	point tl;
	point br;
	point bl;
	
	tr = getCorner(topRightPt);
	tl = getCorner(topLeftPt);
	br = getCorner(bottomRightPt);
	bl = getCorner(bottomLeftPt);
	
	return checkRect->inRect(&tr)
			&& checkRect->inRect(&tl)
			&& checkRect->inRect(&br)
			&& checkRect->inRect(&bl);
}









baseGraphics.cpp

#ifndef baseGraphics_h
#define baseGraphics_h

#include "Arduino.h"

// This is the top point.. err.. Foundation? Base? Of all the drawing.
// You start with a point, use that to define a rectangle. Basically
// everything you draw is a rectangle. Yeah, lines and circles are a
// little different. But really they are too. Everyone gets to know
// what a point and a rect are.

// The lowest common denominator
  struct point {
    int x;
    int y;
  }; 
  
//void	printPoint(point* inPt,char* name="Point : ");
int	xDistance(point ptA, point ptB);
int	yDistance(point ptA, point ptB);
float distance(point ptA, point ptB);  
float	angle(point ptA, point ptB);		// Radians, ptA is center point.



// ***************************************************************
// Base class for a rectangle. 
// ***************************************************************

									
enum rectPt { topLeftPt, topRightPt, bottomLeftPt, bottomRightPt };


class rect {

	public :
  				rect(void);
  				rect(rect* inRect);
  				rect(int inX, int inY, int inWidth,int inHeight);
	virtual	~rect(void);

	virtual	void  setLocation(int inX, int inY);
				void  setSize(int inWidth,int inHeight);
  			  	void  setRect(rect* inRect);                 					// Got a rect? Make this one the same.
  			  	void  setRect(point* inPt1,point* inPt2);							// Or two points..
  			  	void	setRect(int inX, int inY, int inWidth,int inHeight);	// Or the usual way..
          	void	insetRect(int inset);											// Inset all sides by this much. Or expand if negative.
          	void	addRect(rect* inRect);											// Become the rect that spans ourself and this incoming rect.
          	int  	maxX(void);                            					// Where's our last pixel?
          	int  	maxY(void);                            					// Same as obove but in the Y direction.
          	int  	minX(void);                            					// Where's our first pixel?
          	int  	minY(void);                            					// Same as obove but in the Y direction.
  			  	bool 	inRect(int inX, int inY);              					// Is this point in us?
  			  	bool 	inRect(point* inPoint);											// Is this point in us?
  			  	point	getCorner(rectPt corner);										// Pass back the corner point.
				bool	overlap(rect* checkRect);										// Is that rect touching us?
				bool	isSubRectOf(rect* checkRect);									// Are we contained in that rect?
				//void	printRect(char* = "Rect : ");
					
				int	x;
				int	y;
				int	width;
				int	height;
};

#endif

baseGraphics.h

 #include "displayObj.h"

  
displayObj::displayObj(bool inGraphic,bool inColor,bool inTouch,bool inSD,bool inReadable) {

	graphic = inGraphic;
	color = inColor;
	hasTouch = inTouch;
	hasSD = inSD;
	readable = inReadable;
	offsetX = 0;
	offsetY = 0;
  }
  

displayObj::~displayObj(void) { }

  
void displayObj::pushOffset(int x, int y) {
	offsetX = offsetX + x;
	offsetY = offsetY + y;
}


void displayObj::popOffset(int x, int y) {
	offsetX = offsetX - x;
	offsetY = offsetY - y;
}

  
int displayObj::gX(int lX) { return lX + offsetX; }

int displayObj::gY(int lY) { return lY + offsetY; }
	
int displayObj::lX(int gX) { return gX - offsetX; }

int displayObj::lY(int gY) { return gY - offsetY; }
	
	
point	displayObj::lP(point gP) {

	point aPt;
	
	aPt.x = gP.x -  offsetX;
	aPt.y = gP.y -  offsetY;
	return aPt;
}
	

int  displayObj::width(void) { return 0; }	// Better fill these two out..
int  displayObj::height(void) { return 0; }	//
void displayObj::startWrite(void) {  }
void displayObj::endWrite(void) {  }
bool displayObj::dispObjBegin(void) { return false; }
void displayObj::setRotation(byte inRotation) { }
void displayObj::setTextColor(colorObj* inColor) { }
void displayObj::setTextColor(colorObj* tColor,colorObj* bColor) { }
void displayObj::setTextSize(byte inSize) { }
void displayObj::setTextWrap(bool inWrap) { }
void displayObj::setFont(const GFXfont* font) { }
void displayObj::setCursor(int inX,int inY) { }
void displayObj::drawText(char* inText) { }
void displayObj::drawChar(int x,int y,char inChar,colorObj* fColor,colorObj* bColor,int size) { }
void displayObj::fillScreen(colorObj* inColor) {  }
void displayObj::fillRect(int locX,int locY,int width,int height,colorObj* inColor) { }
void displayObj::fillRect(rect* inRect,colorObj* inColor) { }
void displayObj::drawRect(int locX,int locY,int width,int  height,colorObj* inColor) { }
void displayObj::drawRect(rect* inRect,colorObj* inColor) { }
void displayObj::fillRoundRect(int locX,int locY,int width,int height,int radius,colorObj* inColor){ }
void displayObj::drawRoundRect(int locX,int locY,int width,int height,int radius,colorObj* inColor){ }
void displayObj::fillRoundRect(rect* inRect,int radius,colorObj* inColor){ fillRoundRect(inRect->x,inRect->y,inRect->width,inRect->height,radius,inColor); }
void displayObj::drawRoundRect(rect* inRect,int radius,colorObj* inColor){ drawRoundRect(inRect->x,inRect->y,inRect->width,inRect->height,radius,inColor); }
void displayObj::drawCircle(int locX,int locY,int inDiam, colorObj* inColor){ }
void displayObj::drawCircleHelper(int locX,int locY,int inRad,byte corner,colorObj* inColor) { }
void displayObj::fillCircle(int locX,int locY,int inDiam, colorObj* inColor){ }
void displayObj::drawVLine(int locX,int locY,int height,colorObj* inColor) { }
void displayObj::drawHLine(int locX,int locY,int width,colorObj* inColor) { }
void displayObj::drawLine(int locX,int locY,int locX2,int locY2,colorObj* inColor) { }
void displayObj::drawLine(point* startPt,point* endPt,colorObj* inColor) { drawLine(startPt->x,startPt->y,endPt->x,endPt->y,inColor); }
void displayObj::drawPixel(int locX,int locY,colorObj* pColor) { }
void displayObj::drawPixelInvert(int x,int y) { }
void displayObj::frameRectInvert(int x,int y,int width,int height) { }


void displayObj::fillRectGradient(int inX,int inY,int width,int height,colorObj* startColor,colorObj* endColor,bool rising,bool vertical) {

	colorMapper theColorMap(startColor,endColor);
	mapper		thePercentMap;
	colorObj		theColor;
	float			percent;

	if (vertical) {
		if (rising) {
			thePercentMap.setValues(inY,inY+height-1,0,100);
		} else {
			thePercentMap.setValues(inY,inY+height-1,100,0);
		}
		for(int y=inY;y<inY+height;y++) {
			percent = thePercentMap.map(y);			
			theColor = theColorMap.map(percent);
			drawHLine(inX,y,width,&theColor);
		}
	} else {
		if (rising) {
			thePercentMap.setValues(inX,inX+width-1,0,100);
		} else {
			thePercentMap.setValues(inX,inX+width-1,100,0);
		}
		for(int x=inX;x<inX+width;x++) {
			percent = thePercentMap.map(x);			
			theColor = theColorMap.Map(percent);
			drawVLine(x,inY,width,&theColor);
		}
	}
}


void displayObj::fillScreenGradient(colorObj* startColor,colorObj* endColor,bool rising,bool vertical) {

	fillRectGradient(0,0,width(),height(),startColor,endColor,rising,vertical);
}

// For now alpha is treated like a binary. Because I'm in a hurry and we can't read what
// the display is showing anyway. Although bitmaps should be able to use the full 255 bits.
void displayObj::blit(int locX,int locY,bitmap* inBitmap) {

	int		width;
	int		height;
	colorObj	aColor;
	
	if (inBitmap) {
		width = inBitmap->getWidth();
		height = inBitmap->getHeight();
		for(int y=0;y<height;y++) {
			for(int x=0;x<width;x++) {
				if (inBitmap->getAlpha(x,y)) {
					aColor = inBitmap->getColor(x,y);
					drawPixel(x+locX,y+locY,&aColor);
				}
			}
		}
	}
}


point   displayObj::getPoint(void) {
  
  point defPnt;
  
  defPnt.x = 0;
  defPnt.y = 0;
  return defPnt;
}

bool displayObj::touched(void) {return false; }
  
bool displayObj::isGraphic(void) { return graphic; }
bool displayObj::isColor(void) { return color; }
bool displayObj::hasTouchScreen(void) { return hasTouch; }
bool displayObj::hadSDDrive(void) { return hasSD; }
bool displayObj::canRead(void) { return readable; }



displayObj.cpp

#ifndef displayObj_h
#define displayObj_h

#include <Arduino.h>
#include <gfxfont.h>
#include "colorObj.h"
#include "baseGraphics.h"
#include "bitmap.h"


// This is our base display object. Similar to adafruit's GFX object.
// The plan is to inherit this for whatever glue code each piece of 
// hardware needs to run.


class displayObj {    

	public :
				displayObj(bool inGraphic,bool inColor,bool inTouch,bool inSD,bool inReadable);
	virtual	~displayObj(void);

				void	pushOffset(int x, int y);
				void	popOffset(int x, int y);
				int	gX(int lX);
				int	gY(int lY);
				int	lX(int gX);
				int	lY(int gY);
				point	lP(point gP);
				
	virtual	int	width(void);
	virtual	int	height(void);
	virtual	bool	dispObjBegin(void);
  	virtual	void	startWrite(void);
  	virtual	void	endWrite(void);
	virtual	void	setRotation(byte inRotation);
	virtual	void	setTextColor(colorObj* tColor);
	virtual	void	setTextColor(colorObj* tColor,colorObj* bColor);
	virtual	void	setTextSize(byte inSize);
	virtual	void	setTextWrap(bool inWrap);
	virtual	void	setFont(const GFXfont* font);
	virtual	void	setCursor(int inX,int inY);
	virtual	void	drawText(char* inText);
	virtual	void  drawChar(int x,int y,char inChar,colorObj* fColor,colorObj* bColor,int size);
	virtual	void	fillScreen(colorObj* inColor);
	virtual	void	fillRect(int locX,int locY,int width,int height, colorObj* inColor);
	virtual	void	fillRect(rect* inRect,colorObj* inColor);
	virtual	void	drawRect(rect* inRect,colorObj* inColor);
	virtual	void	drawRect(int locX,int locY,int width,int height, colorObj* inColor);
	virtual	void	fillRoundRect(int locX,int locY,int width,int height,int radius,colorObj* inColor);
	virtual	void	drawRoundRect(int locX,int locY,int width,int height,int radius,colorObj* inColor);
	virtual	void	fillRoundRect(rect* inRect,int radius,colorObj* inColor);
	virtual	void	drawRoundRect(rect* inRect,int radius,colorObj* inColor);
	virtual	void	drawCircle(int locX,int locY,int inDiam, colorObj* inColor);
	virtual	void	drawCircleHelper(int locX,int locY,int inRad,byte corner,colorObj* inColor);
	virtual	void	fillCircle(int locX,int locY,int inDiam, colorObj* inColor);
	virtual	void	drawVLine(int locX,int locY,int height,colorObj* inColor);
	virtual	void	drawHLine(int locX,int locY,int width,colorObj* inColor);
	virtual	void	drawLine(int locX,int locY,int locX2,int locY2,colorObj* inColor);
	virtual	void	drawLine(point* startPt,point* endPt,colorObj* inColor);
	virtual	void	drawPixel(int locX,int locY,colorObj* pColor);
   virtual	void	blit(int locX,int locY,bitmap* inBitmap);
   
	virtual	void	drawPixelInvert(int x,int y);
	virtual	void	frameRectInvert(int x,int y,int width,int height);
	virtual	void	fillRectGradient(int inX,int inY,int width,int height,colorObj* startColor,colorObj* endColor,bool rising=true,bool vertical=true);
	virtual	void	fillScreenGradient(colorObj* startColor,colorObj* endColor,bool rising=true,bool vertical=true);
	
	virtual	point	getPoint(void);
	virtual	bool	touched(void);
  
  				bool isGraphic(void);
  				bool isColor(void);
  				bool hasTouchScreen(void);
  				bool hadSDDrive(void);
  				bool canRead(void);
  
  protected:
  				int			offsetX;
  				int			offsetY;
				bool			graphic;
				bool			color;
				bool			hasTouch;
				bool			hasSD;
				bool			readable;
};

#endif



displayObj.h

#include "drawObj.h"

// ***********************************

drawObj::drawObj() {

  needRefresh	= true;	// Well Duh! We never been drawn yet!
  focus			= false;			// But we're hopefull.
  clicked		= false;
  mEventSet		= noEvents;	// 'Cause this is actually the default.
  callback		= NULL;		// And, no.. We have none of this either.
  lastX			= 0;				// Yes, these are where we were before we moved.
  lastY			= 0;
}


drawObj::drawObj(rect* inRect,eventSet inEventSet)
	: rect(inRect) {
	
	needRefresh	= true;		// Well Duh! We never been drawn yet!
	focus			= false;		// But we're hopefull.
	clicked		= false;
	mEventSet	= inEventSet;	
	callback		= NULL;		// And, no.. We have none of this either.
	lastX			= 0;			// Yes, these are where we were before we moved.
	lastY			= 0;
}


drawObj::drawObj(int inLocX, int inLocY, int inWidth,int inHeight,eventSet inEventSet)
	: rect(inLocX,inLocY,inWidth,inHeight) {
	
	needRefresh	= true;		// Well Duh! We never been drawn yet!
	focus			= false;		// But we're hopefull.
	clicked		= false;
	mEventSet	= inEventSet;
	callback		= NULL;		// And, no.. We have none of this either.
	lastX			= 0;			// Yes, these are where we were before we moved.
	lastY			= 0;
}


// Wake up! Time to die.
drawObj::~drawObj() {

		if (currentFocus == this) {	// We were great..
			currentFocus = NULL;			// And how the great have fallen. (But do it quiet like. We don't want a setFocus call right now!)
		}
		if (theTouched == this) {		// We were the movers and shakers..
			theTouched = NULL;			// But, its all over now.
		}
	}


// When the manager asks if we want a refresh..
bool drawObj::wantRefresh(void) { return needRefresh; }


// Sometimes others know better than us that we need a refresh.
// This allows them to make that happen. Sometimes they want to tell
// us that they'll take care of the refresh stuff themselves.
void drawObj::setNeedRefresh(bool refresh) { needRefresh = refresh; }


void drawObj::setLocation(int inX,int inY) {

	lastX = x;					// Just in the off chance we're doing screen animation.
	lastY = y;					// We'll save where we were.
	rect::setLocation(inX,inY);
	needRefresh = true;
}
	
	
// Call this one to draw..
void  drawObj::draw(void) {

	eraseSelf();			// Like I said, just in case you need it..
	drawSelf();
	needRefresh = false;
}


// Mostly you can ignore this one. Typically used for animation.
// "I've moved, erase where I was before redrawing".
void  drawObj::eraseSelf(void) {  }


// override this one and draw yourself.
void  drawObj::drawSelf(void) {
  
  screen->fillRect(x, y, width, height, &black); // Default draw.
  screen->drawRect(x, y, width, height, &white);
}


// We are either getting or loosing focus.
void  drawObj::setThisFocus(bool setLoose) {

	focus = setLoose;
	needRefresh = true;
}
	
// Well, do we have focus or not?
bool  drawObj::haveFocus(void) { return focus; }

				
// The ability to control this may be handy..
void drawObj::setEventSet(eventSet inEventSet) {

	if (theTouched!=this) {		// I think we better not change this while in the middle of a event set.
		mEventSet = inEventSet;
	}
}


// There may be cases when something needs to see what our even set is.
eventSet drawObj::getEventSet(void) { return mEventSet; }


//nullEvent, touchEvent, liftEvent, dragBegin, dragOn, clickEvent
bool drawObj::acceptEvent(event* inEvent,point* locaPt) {

	switch (mEventSet) {
		case noEvents		: return false;			// noEvents, pass on..
		case touchLift		: 								// Classic button events, clicked lets you draw clicked.
			if (inEvent->mType==touchEvent) {		// If its a touch..
				if (inRect(locaPt)) {					// - and if its on us..
					clicked		= true;					// Might want to show we're clicked on.
					doAction(inEvent,locaPt);			// Do those things we do.
					theTouched	= this;					// Tell the world WE are accepting this event set.
					needRefresh = true;					// touchLift doesn't get a lift event. So it needs the setRefresh here.
					return true;							// Tell the world the event has been accepted.
				}
			} else if (theTouched==this 
				&& inEvent->mType==liftEvent) {		// We only want lifts if we'd accepted the touch.
				clicked		= false;						// And we're no longer clicked.
				needRefresh = true;						// And here.. (see above)
				return true;								// Again, tell the world the event has been accepted.
			}
			break;
		case fullClick 	:								// Things like edit fields. A click changes their state.
			if (inEvent->mType==clickEvent) {		// If its a click event, that matches.
				if (inRect(locaPt)) {					// and if its on us..
					clicked		= false;					// No longer clicked by the time you see this.
					doAction(inEvent,locaPt);			// Do the action.
					return true;							// We don't set touched because this is a one shot event.
				}
			}
			break;
		case dragEvents	:								// Things that move by touch.
			if (inEvent->mType==dragBegin) {			// If, the dragging finger has started..
				if (inRect(locaPt)) {					// and if its on us..
					doAction(inEvent,locaPt);			// Do our stuff.
					theTouched	= this;					// Tell the world WE are accepting this event set.
					return true;
				}
			} else if (inEvent->mType==dragOn) {		// still moving,
				doAction(inEvent,locaPt);					// Stil dragging? Keep drawing.
				return true;									// Event has been accepted.
			} else if (inEvent->mType==liftEvent) {	// Done dragging.
				doAction(inEvent,locaPt);					// Do our stuff.
				return true;									// Again, tell the world the event has been accepted.
			}
			break;
		}
		return false;
	}

// 										****** doAction() ******
//
// Choose one or the other. If you just want something like a button the simple one is best.
// If you need the event, or local point etc. Use the one with the event & local point
// passed in.
//
//											************************

// *** BASIC ACTION, SIMPLE SIMPLE ***
// Override this one to do an action.
void drawObj::doAction(void) {

	if (callback) {	// If you figure out how to setup a callback, it'll work. I can't 
		  callback();	// remember how to do this. (I did it once.) Typically I just
	}						// override this and make it do what I want. Or.. (See below)
}


// *** MORE INCVOLVED ACTION ***
// Override this for more involved action. Like dragging. (The event has global point.
// We'll pass in local point. You may need it.) 
void drawObj::doAction(event* inEvent,point* localPt) { doAction(); }


// Define a void function, for example : void myCallback(void){...} 
// Then, just call this method with your callback's name.
// myDrawObj.setCallback(myCallback);   
// Simple as that.
void drawObj::setCallback(void (*funct)(void)) { callback = funct; }



// ***************************************************
// viewMgr, This is they guy that runs the screenshow.
// Handles redrawing, clicks, etc.
//
//
// Two globals that are somewhat related.
//
// currentFocus : This is a pointer to show who has focus.
// If (this==currentFocus) you know to draw yourslelf in a
// way to show the user you have focus. This can be set by
// anyone by calling setFocusPtr(); Pass in a NULL for no
// focus.
//
// This focus stuff is purely optional. By default it does
// nothing. But, if you have a layout that has a choice of
// things the user can interact with? You can write code
// that uses it to keep track of what the user is
// interacting with. The important part is that that only
// one thing at a time can have focus. So when object A) gets
// a click and grabs focus, object B) is told that its
// loosing focus. Kinda' handy.
//
// theTouched : This is a pointer to who just accepted the
// last screen touch. This way its touchOver() method can
// be located and called. Basically that's all it's for.
// ***************************************************


viewMgr 	viewList;
drawObj*	currentFocus = NULL;	// Totally global because? There's only ONE user.
drawObj*	theTouched = NULL;	// Who's accepted a finger touch on the screen?

void	setFocusPtr(drawObj* newFocus) {

		if (newFocus!=currentFocus) {					// People are lazy. Now they don't need to check.
			if (currentFocus) {							// Check for NULL..
				currentFocus->setThisFocus(false);	// Warn them that their star is falling.
			}
			currentFocus = newFocus;					// The up and coming..
			if (currentFocus) {							// If we're actually passed in something.
				currentFocus->setThisFocus(true);	// Tell 'em their star is rising!!
			}
		}
	}
	
	
viewMgr::viewMgr(void) { }


viewMgr::~viewMgr(void) { listHeader.dumpList(); }



// New objects go on top.
void viewMgr::addObj(drawObj* newObj) {
    
    newObj->linkAfter(&listHeader);	// Put the new guy at the top of the list.
    hookup();								// hookup on the first addition. Ignored otherwise.
}

// Now anyone can tell us to do that.
void viewMgr::dumpDrawObjList(void) { listHeader.dumpList(); }


// Checking events. If no one is set as "theTouched" we begin a
// new set of events. If a drawObj accepts an event it is fed
// all subsequent events through a lift event. Then the process
// starts over.
bool viewMgr::checkEvents(event* theEvent) {
    
	drawObj*	trace;
	point		lPoint;

	if (screen->hasTouchScreen()) {								// Sanity! Does it even have the hardware?
		lPoint = screen->lP(theEvent->mTouchPos);				// Possibly we're sublist, localize.
		if (theTouched==NULL) {										// No one has accepted a touch yet.					
			trace = theList();										// Make sure we're at the top.
			while(trace) {												// While we have something to work with.
				if (trace->acceptEvent(theEvent,&lPoint)) {	// If someone accepts this event..
					return true;										// We are done. Return success.
				}
				trace = (drawObj*)trace->dllNext;				// Hop to the next.
			}
		} else {															// Someone is accepting events.
			theTouched->acceptEvent(theEvent,&lPoint);		// Let them have this one.
			if (theEvent->mType==liftEvent) {					// If it was a lift?
				theTouched = NULL;                        	// Clear out our pointer, event set is complete.
				return true;                           		// We changed something. Lets go.
			}
		}
	}
	return false;														// No changes to report.
}



// Checking for redraws.
void viewMgr::checkRefresh(void) {
    
	drawObj*	trace;
	
	trace = (drawObj*)listHeader.getLast();		// make sure we're at the bottom.
	while(trace && trace!=(&listHeader)) {			// While not NULL or pointing at our header.
		if (trace->wantRefresh()) {					// Does this guy want refresh?
      	trace->draw();								// Call his Draw method.
		}
      trace = (drawObj*)trace->dllPrev;			// Bump up the list.
	}
}
 
 
// Counts & returns the number of objects in the list.           
int viewMgr::numObjects(void) { return (int)listHeader.countTail(); }


// Finds the "nth" item on the list, index starting at 0. NULL if not found.
drawObj* viewMgr::getObj(int index) { return (drawObj*)listHeader.getTailObj((int)index); }


drawObj* viewMgr::theList(void) { return (drawObj*)listHeader.getTailObj(0); }


// We have time to do stuff, NOT A LOT!
void viewMgr::idle(void) {
   
   event	theEvent;
   
   if (ourEventMgr.haveEvent()) {			// Have an event for us?
		theEvent = ourEventMgr.getEvent();	// Grab the event.
		checkEvents(&theEvent);					// Pass it in and see if its handled.
	}
	checkRefresh();								// Check if we need to do some drawing?
}



// ***************************************************
// drawGroup, This is they guy that runs a bunch of sub
// objects. He is both a drawObj and a viewMgr.
// Before taking any action with a sub object the drawGroup
// pushes its location onto the screen. This allows all sub
// objects to work on local coordinates.
// ***************************************************


drawGroup::drawGroup(rect* inRect,eventSet inEventSet) 
	: drawObj(inRect,inEventSet) {  }


drawGroup::drawGroup(int x, int y, int width,int height,eventSet inEventSet)
	: drawObj(x,y,width,height,inEventSet) {  }
	
	
// We don't actually allocate anything new. Just work old tools.
drawGroup::~drawGroup() { }



// Another handy tool. Sometimes you just KNOW everyone you manage
// Needs a refresh. Typically when scrolled, subObjects don't know
// they've been moved. Why? Because their offsets move with them.
// This sets everyone's needRefresh flag.
void drawGroup::setGroupRefresh(bool refresh) {
		
		drawObj* trace;

		trace = theList();										// Make sure we're at the top.
		while(trace) {
			trace->setNeedRefresh(refresh);
			trace = (drawObj*)trace->dllNext;
		} 
	}
	
	
bool drawGroup::checkGroupRefresh(void) {
	
	drawObj* trace;

	trace = theList();										// Make sure we're at the top.
	while(trace && trace!=(&listHeader)) {
		if(trace->wantRefresh()) {
			return true;
		}
		trace = (drawObj*)trace->dllNext;
	}
	return false;
}


// The viewMgr that we live on wants to know if we need a redraw.
// If we don't, the kids might.
bool drawGroup::wantRefresh(void) { return (needRefresh || checkGroupRefresh()); }


// Someone from the outside is hinting to us that we are
// due for a redraw. We'd better let the kids know too..
void drawGroup::setNeedRefresh(bool refresh) {

	drawObj::setNeedRefresh(refresh);
	setGroupRefresh(refresh);
}


// When we move, the subs can't tell 'less we tell 'em.
void drawGroup::setLocation(int x,int y) {

		drawObj::setLocation(x,y);
		setGroupRefresh();
}


// First we see if a list item wants the click. then, if not
// and we are accepting clicks, we take it.
bool drawGroup::acceptEvent(event* inEvent,point* locaPt) {
   
   bool	success;
   
   success = false;												// No accepted yet.
   if (theTouched==this) {										// Oh God no! Its me?!
   	return drawObj::acceptEvent(inEvent,locaPt);		// In this one case, we are being dragged as a group.
   }
	if (inRect(locaPt)) {										// It's in our list or us, somewhere.
		screen->pushOffset(x,y);								// Ok, push our offset for the sublist.
		success = checkEvents(inEvent);						// See if they handle it.
		screen->popOffset(x,y);									// Pop off the offset.
		if (!success) {											// If no one took it.
			return drawObj::acceptEvent(inEvent,locaPt);	// We return the standard check on ourselves.
		}
	}
	return success;												// Return the ultimate result.
}


// The groups are NOT linked into the drawing loop.
// They get their draw calls from the parent getting called.              					
void drawGroup::addObj(drawObj* newObj) {

  	newObj->linkAfter(&listHeader);   	// Put the new guy at the top of the list.
	needRefresh = true;	
}


// Drawing for a group. Sometimes we are visabile sometimes not. Also, drawing is
// done as a stack. Start at the bottom and draw all the pictures 'till you reach
// the top. We as the group are defined as the bottom of this stack.
void	drawGroup::draw(void) {

	drawObj*	trace;

	if (needRefresh) {								// We may be the background.
		eraseSelf();
		drawSelf();										// Do our drawing.
		setGroupRefresh();							// If we're drawing, the entire group needs it.
	}
	trace = (drawObj*)listHeader.getLast();	// make sure we're at the bottom.
	screen->pushOffset(x,y);						// Ok, push our offset for the sublist.
	while(trace && trace!=(&listHeader)) {		// And while we're not done..
		if(trace->wantRefresh()) {					// If this guy needs it.
			trace->draw();								// Call his Draw method.
		}
		trace = (drawObj*)trace->dllPrev;		// Hop to the next one up the list.
	}
	screen->popOffset(x,y);							// Pop off the offset.
	needRefresh = false;								// In any case, we no longer need a refresh.
}


// I'm pretty sure we don't want to be calling idle like viewMgr.
// We're NOT the one to initiate the event chain. Inherited can
// overwrite and do stuff, that'll be fine. This should block
// bad behavior by us.
void	drawGroup::idle(void) { }



// ***************************************************
// drawList is the same as a drawGroup except it arranges
// its sub Objects in list form.
// ***************************************************


drawList::drawList(rect* inRect,eventSet inEventSet,bool vertical) 
	: drawGroup(inRect,inEventSet) {

	mVertical = vertical;	// Save it for now, deal with coding it later.
	itemHeight	= 1;
	itemWidth	= 1;
}


drawList::drawList(int x, int y, int width,int height,eventSet inEventSet,bool vertical) 
	: drawGroup(x,y,width,height,inEventSet) {

	mVertical = vertical;	// Save it for now, deal with coding it later.
	itemHeight	= 1;
	itemWidth	= 1;
}


drawList::~drawList() { }
	
 
// Adding list items we assume they are all the same height.
// We reset our internal list item height each time one is added.
// So if they are NOT all uniform, we treat them like they are
// anyway. Too bad, inherit and fix it if this ain't good enough.					
void drawList::addObj(drawObj* newObj) {

	if (mVertical) {
		itemHeight = max(itemHeight,newObj->height);
		newObj->setLocation(0,numObjects()*itemHeight);
	} else {
		itemWidth = max(itemWidth,newObj->width);
		newObj->setLocation(numObjects()*itemWidth,0);
	}
	newObj->linkToEnd(&listHeader);   									// Put the new guy at the BOTTOM of the list.
	needRefresh = true;
}


// Perhaps you deleted an item from your list? This'll patch the hole.
// This sets the list to item one at top (or left).
void drawList::setPositions(int offset) {

	int		i;
	drawObj*	trace;
	
	i = 0;														// Start our multiplier at zero.
	trace = theList();
	while(trace!=NULL) {										// Standard loop through link list.
		trace->y = offset + i++ *  itemHeight;			// Each is moved by itemHeight from the last.
		trace->setNeedRefresh();							// Just in case, everyione is told to redraw.
		trace = (drawObj* )trace->dllNext;				// Hop to the next in the list.
	}
}


// Seeing that all the list items are positioned as if they were the same size..
// We can calculate the last possible y position an item can have to be viewable.
int drawList::lastY(void) {
	
	int	numViewable;
	
	numViewable = (height/itemHeight);	// Quick int division to force truncation.
	return (numViewable-1) * itemHeight;		// To make sure first is at zero. All overages to bottom.
}


// Any of our items can be passed in and find if its showing or not.
// Good for deciding to draw or not.
bool drawList::isVisible(drawObj* theItem) { return (theItem->y >= 0 && theItem->y<= lastY()); }


// If this itm is not showing, show it. If above the window, bring it down to the first
// position. If below the window bring it up to the last position of the window.
void drawList::showItem(drawObj* theItem) {

  int       yDif;
  drawObj*  trace;
  
  if (theItem->y<0) {							// Need to scroll down.
    yDif = theItem->y;							// Simple, we just bring it down to zero.
  } else if (theItem->y>lastY()) {			// Need to scroll up.
    yDif = theItem->y - lastY();				// This gives us how much to scroll up.
  } else {
    return;                               // No scrolling neccisary. Lets go home.
  }
  trace = theList();                      // EVERYBODY must scroll!
  while(trace!=NULL) {                    // Standard loop through link list.
    trace->y = trace->y-yDif;             // Each is moved by - xDif;
    trace->setNeedRefresh();              // Just in case, everyione is told to redraw.
    trace = (drawObj* )trace->dllNext;    // Hop to the next in the list.
  }
}


// What's the index of the guy at this position?
drawObj* drawList::findItem(point* where) {
	
	drawObj*  trace;
	
	trace = theList();
	while(trace!=NULL) {                    // Standard loop through link list.
		if (trace->inRect(where)) {
			return trace;
		}
		trace = (drawObj* )trace->dllNext;    // Hop to the next in the list. 
	}
	return NULL;
}

	





drawObj.cpp

#ifndef drawObj_h
#define drawObj_h

#include "lists.h"
#include "idlers.h"
#include "baseGraphics.h"
#include "screen.h"
#include "eventMgr.h"

// ***************************************************************
// Base class for an object that can be drawn on the screen.
// Possibly clicked on.
// ***************************************************************


enum eventSet	{ noEvents, touchLift, fullClick, dragEvents };


class drawObj : public rect, public dblLinkListObj {


	public:
  				drawObj();
  				drawObj(rect* inRect,eventSet inEventSet=noEvents);
  				drawObj(int inLocX, int inLocY, int inWidth,int inHeight,eventSet inEventSet=noEvents);
	virtual	~drawObj();
    
   virtual	bool		wantRefresh(void);
   virtual	void		setNeedRefresh(bool=true);
	virtual	void		setLocation(int x,int y);
   virtual	void  	draw(void);												// Call this one. Don't inherit this one.
   virtual	void		eraseSelf(void);										// Mostly you can ignore this one. Used for animation.
   virtual 	void  	drawSelf(void);										// Inherit this one and make it yours.
	virtual	void		setThisFocus(bool setLoose);						// We are either getting or loosing focus.
	virtual	bool		haveFocus(void);										// Do we have focus or not?
	virtual	void		setEventSet(eventSet inEventSet);				// Want to change our event set on the fly?
	virtual	eventSet	getEventSet(void);									// Want to see what this guys even set is?
  	virtual	bool		acceptEvent(event* inEvent,point* locaPt);	// Is this event for us?
  	virtual	void  	doAction(void);										// Override me for action!
  	virtual	void  	doAction(event* inEvent,point* locaPt);		//	Special for them that drag around.
          	void		setCallback(void(*funct)(void));					// Or use a callback.
  
protected:
  bool		needRefresh;
  bool		focus;
  eventSet	mEventSet;
  bool		clicked;
  void		(*callback)(void);
  int			lastX;					// Yes, these are where we were before we moved.
  int			lastY;
};


// ***************************************************************
// Here we have the management of the screen. Get the clicks,
// find drawObjs to act on the clicks and tell the objects when to
// redraw themselves.
//
// "viewList" is the global that does all these things during
// idle time.
// ***************************************************************


class viewMgr : public idler {
    
public:
            viewMgr(void);
	virtual	~viewMgr(void);
    
	virtual	void		addObj(drawObj* newObj);
    			void		dumpDrawObjList(void);
            bool		checkEvents(event* theEvent);
	virtual	void    	checkRefresh(void);
				int		numObjects(void);
				drawObj*	getObj(int index);
				drawObj*	theList(void);
    virtual void    	idle(void);
    
            drawObj	listHeader;				// Header of the drawObj list;
};

extern	viewMgr 	viewList;								// Our global GUI manager.
extern 	drawObj*	theTouched;								// Who's accepted a finger touch on the screen?
extern	drawObj*	currentFocus;							// Focus goes hand in hand with view management.
extern 	void		setFocusPtr(drawObj* newFocus);	// Anyone can set focus by calling this function.



// ***************************************************************
// The idea here is to have a draw object that manages a group of
// drawObjects. This is the base of all lists & popups. Or at least,
// that's the plan.
// ***************************************************************

class drawGroup : public drawObj, public viewMgr {

	public:
				drawGroup(rect* inRect,eventSet inEventSet=noEvents);
				drawGroup(int x, int y, int width,int height,eventSet inEventSet=noEvents);
  	virtual	~drawGroup();

	virtual	bool		checkGroupRefresh(void);
	virtual	void		setLocation(int x,int y);
	virtual	void		setGroupRefresh(bool refresh=true);
	virtual	bool		wantRefresh(void);
	virtual	void		setNeedRefresh(bool refresh=true);
  	virtual	bool		acceptEvent(event* inEvent,point* locaPt);	// Is this event for us?
  	virtual	void  	addObj(drawObj* newObj);
  	virtual	void  	draw(void);
  	virtual	void    	idle(void);
};			
		
		
		
class drawList : public drawGroup {
 
	public:
				drawList(rect* inRect,eventSet inEventSet=noEvents,bool vertical=true);
				drawList(int x, int y, int width,int height,eventSet inEventSet=noEvents,bool vertical=true);
  	virtual	~drawList();
  					
  	virtual	void		addObj(drawObj* newObj);
  				void		setPositions(int offset=0);
  				int		lastY(void);
  				bool		isVisible(drawObj* theItem);
				void		showItem(drawObj* theItem);
				drawObj*	findItem(point* where);
				
  				int	itemHeight;
  				int	itemWidth;
  				bool	mVertical;
  	
};
	
#endif



drawObj.h

#include "eventMgr.h"
#include "resizeBuff.h"
#include "screen.h"


// Our global event manager.
eventMgr 	ourEventMgr;

eventType		mType;
	
	unsigned long	mTouchMs;
	unsigned long	mLastMs;
	unsigned long	mNumMs;
	
	point				mTouchPos;
	point				mLastPos;
	
	int				mXDist;
	int				mYDist;
	float				mDist;
	
	float				mXPixlePerSec;
	float				mYPixlePerSec;
	float				mPixalPerSec;
	
	float				mAngle;

/*	
void printEvent(event* anEvent) {

	
	Serial.print(F("mType         : "));
	switch (anEvent->mType) {
		case nullEvent		: Serial.println(F("nullEvent"));	break;
		case touchEvent	: Serial.println(F("touchEvent"));	break;
		case liftEvent		: Serial.println(F("liftEvent"));	break;
		case dragBegin		: Serial.println(F("dragBegin"));	break;
		case dragOn			: Serial.println(F("dragOn")); 		break;
		case clickEvent	: Serial.println(F("clickEvent"));	break;
	}
	Serial.println();
	
	Serial.print(F("Size in bytes : "));Serial.println(sizeof(event));
	Serial.println();
	
	Serial.print(F("mTouchMs      : "));Serial.println(anEvent->mTouchMs);
	Serial.print(F("mLastMs       : "));Serial.println(anEvent->mLastMs);
	Serial.print(F("mNumMs        : "));Serial.println(anEvent->mNumMs);
	Serial.println();
	
	printPoint(&anEvent->mTouchPos,"mTouchPos     : ");Serial.println();
	printPoint(&anEvent->mLastPos,"mLastPos     : ");Serial.println();
	Serial.println();
	
	Serial.print(F("mXDist        : "));Serial.println(anEvent->mXDist);
	Serial.print(F("mYDist        : "));Serial.println(anEvent->mYDist);
	Serial.print(F("mDist         : "));Serial.println(anEvent->mDist);
	Serial.println();
	
	Serial.print(F("mXPixlePerSec : "));Serial.println(anEvent->mXPixlePerSec);
	Serial.print(F("mYPixlePerSec : "));Serial.println(anEvent->mYPixlePerSec);
	Serial.print(F("mPixalPerSec  : "));Serial.println(anEvent->mPixalPerSec);
	Serial.println();
	
	Serial.print(F("mAngle        : "));Serial.println(anEvent->mAngle);
};
*/


eventObj::eventObj(event* inEvent) { mEvent = inEvent; }


eventObj::~eventObj(void) { if (mEvent) free(mEvent); };
				


// ***************************************************
// eventMgr, This is the guy that figures out what kind
// of screen things are going on. touch, lift, dragBegin,
// dragOn, click or nothing.
// ***************************************************
   
				
eventMgr::eventMgr(void) {
	
	setTime(DRAG_TIME);		// Set up our timer.
	
	mTouched		= false;		// Initialize the past.
	mDragging	= false;		// This is a lot like rewriting history.
	
	mTouchMs		= 0;
	mLastMs		= 0;
	
	mTouchPos.x	= 0;
	mTouchPos.y	= 0;
	mLastPos.x	= 0;
	mLastPos.y	= 0;
				
	mNullEvent.mType				= nullEvent;	// Setup a global, ready to go null event.						
	mNullEvent.mTouchMs			= 0;				// This way if nothing's going on. We won't	
	mNullEvent.mLastMs			= 0;
	mNullEvent.mNumMs				= 0;
	
	mNullEvent.mTouchPos			= mLastPos;		// waste time creating a bunch of these.						
	mNullEvent.mLastPos			= mLastPos;		// Using mLastPos for all these 'cause its currently 0,0.
								
	mNullEvent.mXDist				= 0;				
	mNullEvent.mYDist				= 0;
	mNullEvent.mDist				= 0;
	
	mNullEvent.mXPixlePerSec	= 0;	
	mNullEvent.mYPixlePerSec	= 0;				
	mNullEvent.mPixalPerSec		= 0;
	
	mNullEvent.mAngle				= 0;
}


eventMgr::~eventMgr(void) { }


void eventMgr::begin(void) { hookup(); }


/*
// New events go in here.
void eventMgr::addEvent(event* newEvent) { push((linkListObj*)newEvent); }
*/

// Sometimes you want a fresh start.
void eventMgr::flushEvents(void) { dumpList(); }


// We have an event for somebody?
bool eventMgr::haveEvent(void) { return !isEmpty(); }


// Someone wants the next event. That's our job!
event eventMgr::getEvent(void) {

	eventObj*	nextEvent;
	event			anEvent;
	
	nextEvent = (eventObj*)pop();			// Pop the queue for a pointer to the next event.
	if (nextEvent) {							// If there was an event to pop off the queue..
		anEvent = *(nextEvent->mEvent);	// Save off the data to stack memory.
		delete nextEvent;						// Delete the copy we pulled off the queue.
		return anEvent;						// Return our local copy.
	}
	return mNullEvent;						// No event waiting? Send them a nullEvent.
}


// We figure out every possible bit of information we
// can about an event.
void eventMgr::addEvent(eventType inType) {

	event*		newEvent;
	eventObj*	newEventObj;
	
	newEvent = NULL;															// The pointer needs to start as NULL.
	if (resizeBuff(sizeof(event),(uint8_t**)&newEvent)) {			// Becuse we allocate with resizeBuff();
		switch(inType) {
			case nullEvent		: free(newEvent); return;				// We don't make nullEvents, we
			case touchEvent	:
				newEvent->mType			= touchEvent;					
				newEvent->mTouchMs		= mTouchMs;						// Fist thing, grab the time.					
				newEvent->mLastMs			= mTouchMs;						// Same time, we just touched.
				newEvent->mNumMs			= 0;								// Calculate the number of milliseconds since last time.

				newEvent->mTouchPos		= mTouchPos;					// Grab the location of the event.					
				newEvent->mLastPos		= mTouchPos;
								
				newEvent->mXDist			= 0;				
				newEvent->mYDist			= 0;
				newEvent->mDist			= 0;
	
				newEvent->mXPixlePerSec	= 0;	
				newEvent->mYPixlePerSec	= 0;				
				newEvent->mPixalPerSec	= 0;
	
				newEvent->mAngle			= 0;
			break;
			case liftEvent		:
				newEvent->mType			= liftEvent;					
				newEvent->mTouchMs		= mTouchMs;					
				newEvent->mLastMs			= millis();
				newEvent->mNumMs			= abs(newEvent->mLastMs-mTouchMs);					// Calculate the number of milliseconds since touch.
	
				newEvent->mTouchPos		= mTouchPos;												// Saved when we got the touch.					
				newEvent->mLastPos		= mLastPos;													// Updated during idle time while touched.
								
				newEvent->mXDist			= xDistance(mTouchPos,mLastPos);						// Calculate the x distance.				
				newEvent->mYDist			= yDistance(mTouchPos,mLastPos);						// Calculate the y distance.	
				newEvent->mDist			= distance(mTouchPos,mLastPos);						// Calculate the total distance.	
	
				newEvent->mXPixlePerSec	= (newEvent->mXDist/newEvent->mNumMs)*1000;		// Calculate the x speed. Pixels/sec.
				newEvent->mYPixlePerSec	= (newEvent->mYDist/newEvent->mNumMs)*1000;		// Calculate the y speed. Pixels/sec.				
				newEvent->mPixalPerSec	= (newEvent->mDist/newEvent->mNumMs)*1000;		// Calculate the total speed. Pixels/sec.
	
				newEvent->mAngle			= angle(mTouchPos,mLastPos);							// Calculate the actual angle, in radians.
			break;
			case dragBegin		:
				newEvent->mType			= dragBegin;					
				newEvent->mTouchMs		= mTouchMs;					
				newEvent->mLastMs			= millis();
				newEvent->mNumMs			= abs(newEvent->mLastMs-mTouchMs);					// Calculate the number of milliseconds since touch.
	
				newEvent->mTouchPos		= mTouchPos;												// Saved when we got the touch.					
				newEvent->mLastPos		= mLastPos;													// Updated during idle time while touched.
								
				newEvent->mXDist			= xDistance(mTouchPos,mLastPos);						// Calculate the x distance.				
				newEvent->mYDist			= yDistance(mTouchPos,mLastPos);						// Calculate the y distance.	
				newEvent->mDist			= distance(mTouchPos,mLastPos);						// Calculate the total distance.	
	
				newEvent->mXPixlePerSec	= (newEvent->mXDist/newEvent->mNumMs)*1000;		// Calculate the x speed. Pixels/sec.
				newEvent->mYPixlePerSec	= (newEvent->mYDist/newEvent->mNumMs)*1000;		// Calculate the y speed. Pixels/sec.				
				newEvent->mPixalPerSec	= (newEvent->mDist/newEvent->mNumMs)*1000;		// Calculate the total speed. Pixels/sec.
	
				newEvent->mAngle			= angle(mTouchPos,mLastPos);							// Calculate the actual angle, in radians.
			break;
			case dragOn			:
				newEvent->mType			= dragOn;					
				newEvent->mTouchMs		= mTouchMs;					
				newEvent->mLastMs			= millis();
				newEvent->mNumMs			= abs(newEvent->mLastMs-mTouchMs);					// Calculate the number of milliseconds since touch.
	
				newEvent->mTouchPos		= mTouchPos;												// Saved when we got the touch.					
				newEvent->mLastPos		= mLastPos;													// Updated during idle time while touched.
								
				newEvent->mXDist			= xDistance(mTouchPos,mLastPos);						// Calculate the x distance.				
				newEvent->mYDist			= yDistance(mTouchPos,mLastPos);						// Calculate the y distance.	
				newEvent->mDist			= distance(mTouchPos,mLastPos);						// Calculate the total distance.	
	
				newEvent->mXPixlePerSec	= (newEvent->mXDist/newEvent->mNumMs)*1000;		// Calculate the x speed. Pixels/sec.
				newEvent->mYPixlePerSec	= (newEvent->mYDist/newEvent->mNumMs)*1000;		// Calculate the y speed. Pixels/sec.				
				newEvent->mPixalPerSec	= (newEvent->mDist/newEvent->mNumMs)*1000;		// Calculate the total speed. Pixels/sec.
	
				newEvent->mAngle			= angle(mTouchPos,mLastPos);							// Calculate the actual angle, in radians.
			break;
			case clickEvent	:
				newEvent->mType			= clickEvent;					
				newEvent->mTouchMs		= mTouchMs;					
				newEvent->mLastMs			= millis();
				newEvent->mNumMs			= abs(newEvent->mLastMs-mTouchMs);					// Calculate the number of milliseconds since touch.
	
				newEvent->mTouchPos		= mTouchPos;												// Saved when we got the touch.					
				newEvent->mLastPos		= mLastPos;													// Updated during idle time while touched.
								
				newEvent->mXDist			= xDistance(mTouchPos,mLastPos);						// Calculate the x distance.				
				newEvent->mYDist			= yDistance(mTouchPos,mLastPos);						// Calculate the y distance.	
				newEvent->mDist			= distance(mTouchPos,mLastPos);						// Calculate the total distance.	
	
				newEvent->mXPixlePerSec	= (newEvent->mXDist/newEvent->mNumMs)*1000;		// Calculate the x speed. Pixels/sec.
				newEvent->mYPixlePerSec	= (newEvent->mYDist/newEvent->mNumMs)*1000;		// Calculate the y speed. Pixels/sec.				
				newEvent->mPixalPerSec	= (newEvent->mDist/newEvent->mNumMs)*1000;		// Calculate the total speed. Pixels/sec.
	
				newEvent->mAngle			= angle(mTouchPos,mLastPos);							// Calculate the actual angle, in radians.
			break;
		}
		newEventObj = new eventObj(newEvent);														// Create the node this will live in.
		if (newEventObj) { push(newEventObj); }													// We are a queue. Push the new guy in.
	}
}


// Use this so we can have some type checking.
void eventMgr::push(eventObj* newEventObj) { queue::push((linkListObj*)newEventObj); }


// And this. I was bit by doing it fast and loose earlier.
eventObj* eventMgr::pop(void) { return (eventObj*)queue::pop();	}


void eventMgr::idle(void) {
	
	float	moveDist;
	
	if (mTouched) {											// Last time we checked we were mTouched.
		if (!screen->touched()) {							// This time we are NOT mTouched.
			addEvent(liftEvent);								// This means we got a lift.
			mDragging = false;								// No matter, we're not mDragging.
			mTouched = false;									// Save off that we're no longer mTouched.
			if (!ding()) {										// If it was a "short" touch.
				addEvent(clickEvent);						// That'll pass for a "click".
			}
		} else {													// Else, still mTouched.
			mLastPos = screen->getPoint();				//	Update the last point we saw.
			moveDist = distance(mTouchPos,mLastPos);	// Calculate the total distance.	
			if (ding()||moveDist>DRAG_DIST) {			// If our timer expired or were moving, it's a drag.
				if (!mDragging) {								// If we we weren't already dagging..
					addEvent(dragBegin);						// Create a drag begin event.
					mDragging = true;							// Note that we are mDragging.
				} else if (isEmpty()) {						// Else if already mDragging AND we have an empty queue.
					addEvent(dragOn);							// We pop in a dragOn event. Don't want to swamp the queue.
				}
			}
		}
	} else {											// Else we were not mTouched last time we checked..
		if (screen->touched()) {				// And we ARE mTouched now..
			mTouchMs = millis();					// Save time..
			mTouchPos = screen->getPoint();	// And place of touch!
			addEvent(touchEvent);			// Create a touch event.
			mLastPos = screen->getPoint();	// Init. the last position seen. Not used for touchEvent.
			mTouched = true;						// Note that we've been mTouched.
			start();									// Start up the drag timer.
		}
	}
}




eventMgr.cpp

#ifndef eventMgr_h
#define eventMgr_h

#include <lists.h>
#include <idlers.h>
#include <timeObj.h>
#include "baseGraphics.h"

#define	DRAG_TIME	500	// How many milliseconds before it goes from a click to a drag?
#define	DRAG_DIST	10		// If the finger moves further than this, we'll call it a drag.
// ***************************************************************
// Here we have the management of screen actions. Get the touches
// and lifts then interpret them into touch, click, drag etc.
// events.
// ***************************************************************


enum eventType { nullEvent, touchEvent, liftEvent, dragBegin, dragOn, clickEvent };



// ***************************************************
// event, this is all the information we can gather about
// what the user is doing with the screen. A touch, a lift,
// where it happend, how fast is his finger moving? How
// far has it moved since the last event?
// ***************************************************


struct event {
	eventType		mType;
	
	unsigned long	mTouchMs;
	unsigned long	mLastMs;
	unsigned long	mNumMs;
	
	point				mTouchPos;
	point				mLastPos;
	
	int				mXDist;
	int				mYDist;
	float				mDist;
	
	float				mXPixlePerSec;
	float				mYPixlePerSec;
	float				mPixalPerSec;
	
	float				mAngle;
};

//void printEvent(event* anEvent);


// ***************************************************
// eventObj, this is the object we pack the event into
// so it will be able go into the event queue. Once the
// event has been read, the manager recycles the object
// and the object recycles the event.
// ***************************************************


class eventObj	:	public linkListObj {

	public:
            eventObj(event* inEvent);
	virtual	~eventObj(void);
	
				event*	mEvent;				
};
		


// ***************************************************
// eventMgr: This is the object that creates the events.
// Once created, the events are queued up for the viewMgr
// to dispatch them to its drawObj(s). After an even has
// been dispatched, the eventMgr recycles the event's
// memory.
// ***************************************************


class eventMgr :	public queue,
						public idler,
						public timeObj {
	public:
            eventMgr(void);
	virtual	~eventMgr(void);
    
				void			begin(void);
    			void			flushEvents(void);
    			bool			haveEvent(void);
				event			getEvent(void);
				
				void			addEvent(eventType inType);
	virtual	void			push(eventObj* newEventObj);
	virtual	eventObj*	pop(void);
	virtual	void			idle(void);
	
				bool				mTouched;
				bool				mDragging;
				unsigned long	mTouchMs;
				unsigned long	mLastMs;
				point				mTouchPos;
				point				mLastPos;
				event				mNullEvent;           	
};

extern	eventMgr 	ourEventMgr;								// Our global event manager.


#endif

eventMgr.h

#include "mask.h"

// *************************************
//     The -tiny- mask base class.
// *************************************


mask::mask(void) { setInverse(false); }
mask::~mask(void) {  }

void mask::setInverse(bool inInverse) { inverse = inInverse; }
masktype	mask::checkRect(rect* inRect) { return unMasked; }
masktype	mask::checkRect(int x,int y,int w,int h) { return unMasked; }
bool mask::checkPixel(int x,int y) { return true; }



// *************************************
//     The simple maskRect class.
// *************************************


maskRect::maskRect(rect* inRect)
	: mask(),
	rect(inRect) { }

	
maskRect::maskRect(int inX, int inY, int inWidth,int inHeight)
	: mask(),
	rect(inX,inY,inWidth,inHeight) { }
	
	
maskRect::~maskRect(void) { }


masktype	maskRect::checkRect(rect* inRect) {
		
	if (inRect->isSubRectOf(this)) {
		if (inverse) {
			return unMasked;
		} else {
			return totalMasked;
		}
	} else if (inRect->overlap(this)) {
		return partialMasked;
	} else {
		if (inverse) {
			return totalMasked;
		} else {
			return unMasked;
		}
	}
}


masktype	maskRect::checkRect(int x,int y,int w,int h) {

	rect	inRect;
	
	inRect.setRect(x,y,w,h);
	return checkRect(&inRect);
}


bool maskRect::checkPixel(int x,int y) {

	if (inverse) 
		return !inRect(x,y);
	else
		return inRect(x,y);
}

mask.cpp

#ifndef mask_h
#define mask_h

#include "baseGraphics.h"



// Mask can be applied to a bmpObj to tell whether to write a pixel or not. This can be
// inherited and used for any masking formula you want. Just override checkPixel and have
// at it.
//
// .bmpMask below is a prime example of how this can be used.


enum masktype { unMasked, totalMasked, partialMasked };


class mask {

	public:
				mask(void);
	virtual	~mask(void);
	
	virtual	void		setInverse(bool inInverse);
	virtual	masktype	checkRect(rect* inRect);
	virtual	masktype	checkRect(int x,int y,int w,int h);
	virtual	bool		checkPixel(int x,int y);
	
				bool	inverse;
};



// A simple rect mask. In normal mode, pixels can be drawn outside of the mask rect. They
// will not be drawn inside the mask rect. In inverse mode, pixels can be drawn inside the
// mask rect. But not outside of it. So many double negatives..

class maskRect :	public mask,
						public rect {

	public:
				maskRect(rect* inRect);
				maskRect(int inX, int inY, int inWidth,int inHeight);
	virtual	~maskRect(void);
				
	virtual	masktype	checkRect(rect* inRect);	
	virtual	masktype	checkRect(int x,int y,int w,int h);
	virtual	bool		checkPixel(int x,int y);
	
				
};

#endif

mask.h

#include "region.h"

// Create an empty region.
region::region(void)
	: linkList() { }


// Delete a region..
region::~region(void) { }


// Go through the tail nodes and knock out any that are a sub rect of this one.
void region::checkTail(regionRectObj* current) {

	regionRectObj* trace;
	regionRectObj* next;
	
	if (current) {										// Always check for NULL. They are NUTS out there!
		trace = current->getNextRectObj();				// trace starts and the next node.
		while(trace) {									// While trace is not NULL..
			next = trace->getNextRectObj();				// next get the next node after trace.
			if(trace->isSubRectOf(current)) {	// If trace is a subset of current..
				unlinkObj(trace);						// We unlink trace.
				delete(trace);							// Delete trace.
			}
			trace = next;								// In all cases we now point trace to next.
		}													// And start over.
	}
}


// We do what we need to do to add a rectangle to our region. Keeping enclosingRect up to
// date as we do it.
void region::addRect(rect* inRect) {

	regionRectObj*	newRectObj;
	regionRectObj*	trace;
	
	if (inRect) {																									// Sanity, if they really gave us a valid pointer..
		newRectObj = new regionRectObj(inRect);															// Create a shiny new rect object using inRect as template.
		if (newRectObj) {																							// If we got the new rectObj..
			if (isEmpty()) {																						// If this is our first rect..
				enclosingRect.setRect(inRect);																// Set the enclosing rect to inRect.
				addToTop(newRectObj);																			// We add it to the top of the list.
			} else {																									// Else NOT our first rect..
				enclosingRect.addRect(newRectObj);															// We add inRect to our enclosing rect.
				trace = getFirstRectObj();																		// Point at the first rect on the list.
				while(trace) {																						// While we are pointing to a non-NULL object..
					if (trace->getArea()>=newRectObj->getArea()) {										// If we are looking at a bigger rectangle than the new one..
						if (newRectObj->isSubRectOf(trace)) {												// If the new rect is a subset of the rect we are pointing at..
							delete(newRectObj);																	// No point to put this one in. Delete it.
							return;																					// Nothing left to do here. Bail.
						} else if (!trace->getNextRectObj()) {												// If we have no next node..
							newRectObj->linkAfter(trace);														// Tell the new node to link in after trace.
							return;																					// Again, nothing left to do here. Bail.
						} else if (trace->getNextRectObj()->getArea()<newRectObj->getArea()) {	// If the next one after trace has a smaller area than the new rect..
							newRectObj->linkAfter(trace);														// Link the new rect between the two.
							checkTail(newRectObj);																// Check the tail of the list for subrects and clean them out.
							return;																					// And that's it. Off we go.
						} else {																						// Else, the next node is not smaller than us..
							trace = trace->getNextRectObj();													// We move to the next node and start all over.
						}
					} else {																							// Else, the current node is smaller than us.. (Only can happen initial node.)
						addToTop(newRectObj);																	// Since its the initial node, we add this node to the top of the list.
						checkTail(newRectObj);																	// Then we do the tail check.
						return;																						// And our work is done.
					}	
				}
			}
		}
	}
}


// Add a region to our region. This only copies the inputed region. Does not change it in
// any way.
void region::addRegion(region* inRegion) {

	regionRectObj*	trace;
	
	if (inRegion) {
		trace = inRegion->getFirstRectObj();
		while(trace) {
			addRect(trace);
			trace = trace->getNextRectObj();
		}
	}
}
	

// Pass in a point and this will pass back if the point is contained in this regon or not.	
bool region::pointInRegion(point* inPoint) {

	regionRectObj*	trace;
	
	if (inPoint) {
		if (isEmpty()) {
			return false;
		}
		if (!enclosingRect.inRect(inPoint)) {
			return false;	
		}
		trace = getFirstRectObj();
		while(trace) {
			if (trace->inRect(inPoint)) {
				return true;
			}
			trace = trace->getNextRectObj();
		}
	}
	return false;
}


// Pass in a rect and this will pass back if the rect overlaps our region or not.
bool region::rectOverlapRegion(rect* inRect) {

	regionRectObj*	trace;
	
	if (inRect) {
		if (isEmpty()) {
			return false;
		}
		if (!enclosingRect.overlap(inRect)) {
			return false;	
		}
		trace = getFirstRectObj();
		while(trace) {
			if (trace->overlap(inRect)) {
				return true;
			}
			trace = trace->getNextRectObj();
		}
	}
	return false;
}
	
	
// Pass in a region and this will pass back if the two regions overlap or not.
bool region::regionOverlapRegion(region* inRegion) {

	regionRectObj*	traceA;
	regionRectObj*	traceB;
	rect				theirEnclosingRect;
	
	if (inRegion) {
		if (isEmpty()||inRegion->isEmpty()) {
			return false;
		}
		theirEnclosingRect = inRegion->getEnclosingRect();
		if (!enclosingRect.overlap(&theirEnclosingRect)) {
			return false;	
		}
		traceA = getFirstRectObj();
		while(traceA) {
			traceB = inRegion->getFirstRectObj();
			while(traceB) {
				if (traceA->overlap(traceB)) {
					return true;
				}
				traceB = traceB->getNextRectObj();
			}
			traceA = traceA->getNextRectObj();
		}
	}
	return false;
}


rect region::getEnclosingRect(void) { return enclosingRect; }


// Always pass back a regionRectObj pointer.
regionRectObj* region::getFirstRectObj(void) { return (regionRectObj*)linkList::getFirst(); }


// Create a new regionRectObj using an inputted rect.
regionRectObj::regionRectObj(rect* inRect)
	: linkListObj(),
	rect(inRect) { area = width * height; }
	
	
// Create a new regionRectObj using x,y width and height values.
regionRectObj::regionRectObj(int inX,int inY,int inWidth,int inHeight)
	: linkListObj(),
	rect(inX,inY,inWidth,inHeight) { area = width * height; }
	
	
// Your standard destructor..
regionRectObj::~regionRectObj(void) {  }


// Return the pre-calculated area.
long regionRectObj::getArea(void) { return area; }


// Always pass back a regionRectObj pointer.
regionRectObj* regionRectObj::getNextRectObj(void) { return (regionRectObj*)regionRectObj::getNext(); }




region.cpp

#ifndef region_h
#define region_h


#include	"baseGraphics.h"
#include "lists.h"

class regionRectObj;

class region :	public linkList {

	public:
						region(void);
	virtual			~region(void);
	
				
				void				addRect(rect* inRect);
				void				addRegion(region* inRegion);
				bool				pointInRegion(point* inPoint);
				bool				rectOverlapRegion(rect* inRect);
				bool				regionOverlapRegion(region* inRegion);
				rect				getEnclosingRect(void);
	virtual	regionRectObj*	getFirstRectObj(void);
	
	protected:
				void	checkTail(regionRectObj* current);
				
				rect	enclosingRect;
};



class regionRectObj :	public linkListObj,
								public rect {

	public:
						regionRectObj(rect* inRect);
						regionRectObj(int inX,int inY,int inWidth,int inHeight);
	virtual			~regionRectObj(void);
	
				long				getArea(void);
	virtual	regionRectObj*	getNextRectObj(void);
				
	private:
				long	area;
};
						
#endif				
									

region.h


#include "screen.h"
#include "adafruit_1431_Obj.h"
#include "adafruit_684_Obj.h"
#include "adafruit_1947_Obj.h"
#include "LC_SPI.h"

#include <SD.h>

displayObj* screen = NULL;

bool initScreen(byte hardware, byte csPin, byte inRotation) { 
	return initScreen(hardware,csPin, -1,inRotation);
}
	
	
bool initScreen(byte hardware,byte csPin,byte rsPin,byte inRotation) {

	switch (hardware) {
		
		case ADAFRUIT_684 :
			screen = (displayObj*) new adafruit_684_Obj(csPin,rsPin);
			if (screen) {
				if (screen->dispObjBegin()) {
					screen->setRotation(inRotation);
					return true;
				}
			}
			return false;
		break;
		
		case ADAFRUIT_1431 :
			screen = (displayObj*) new adafruit_1431_Obj(csPin,rsPin);
			if (screen) {
				if (screen->dispObjBegin()) {
					screen->setRotation(inRotation);
					return true;
				}
			}
			return false;
		break;
      
		case ADAFRUIT_1947 :
			screen = (displayObj*) new adafruit_1947_Obj(csPin,rsPin);
			if (screen) {
				if (screen->dispObjBegin()) {
					screen->setRotation(inRotation);
					return true;
				}
			}
			return false;
      break;
   
    	default : return false;
  	}
}



screen.cpp

#ifndef screen_h
#define screen_h

#include "displayObj.h"

#define ADAFRUIT_1947		1   // 2.8" TFT Touch Shield for Arduino w/Capacitive Touch.
#define ADAFRUIT_1431		2   // OLED Breakout Board - 16-bit Color 1.5" w/microSD holder.
#define ADAFRUIT_684			3   // OLED Breakout Board - 16-bit Color 0.69" w/microSD holder.

extern displayObj* screen;

bool initScreen(byte hardware, byte csPin, byte inRotation=0);
bool initScreen(byte hardware, byte csPin, byte rsPin, byte inRotation);

#endif



screen.h

#include "bitmap.h"
#include "resizeBuff.h"
#include "colorObj.h"
//#include "debug.h"

// Give back an initialzed but empty bitmap.
bitmap::bitmap(void) {

  mWidth    = 0;
  mHeight   = 0;
  mBitmap   = NULL;
  mAlpha		= NULL;
  mHaveMap  = false;
}


// Give back a fully functonal bitmap. If it can get the RAM that is.
bitmap::bitmap(int width,int height,bool alpha) {
  
  mBitmap   = NULL;
  mAlpha		= NULL;
  mHaveMap  = false;
  setSize(width,height,alpha);   
}


// Create ourselves as a clone of another bitmap. Just like all bitmaps, if it doesn't
// work? We still have all the check methods working. So you can tell if it didn't make it.
bitmap::bitmap(bitmap* aBitmap) {

	byte* theirMap;
	byte* ourMap;
	int	numBytes;
	int	tWidth;														
	int	tHeight;
	bool	tAlpha;
	
	mWidth	= 0;															// Start off with the standard defaults.
	mHeight	= 0;
	mAlpha	= NULL;
	mBitmap	= NULL;
	mHaveMap	= false;
	if (aBitmap) {															// Sanity, did they even pass in a bitmap?
		if (aBitmap->getHasMap()) {									// Cool, lets see if it has a bitmap allocated?
			tWidth	= aBitmap->getWidth();							// Save off their width.
			tHeight	= aBitmap->getHeight();							// Save off their height.
			tAlpha	= aBitmap->getAlphaAddr()!=NULL;				// Save off.. Do they have an alpha channel?
			if (setSize(tWidth,tHeight,tAlpha)) {					// Ok, lets see if we can allocate one for us?
				ourMap = (byte*)mBitmap;								// Everything seems fine, point at our map as if its ju as array of bytes.
				theirMap = (byte*)aBitmap->getBitmapAddr();		// Point at their map as if its ju an array of bytes. Because really, they are.
				numBytes  = mWidth * mHeight * sizeof(RGBpack);	// Calculate the number of bytes in our map buffer.
				for(int i=0;i<numBytes;i++) {							// For every byte..
					ourMap[i] = theirMap[i];							// Copy theirs into ours.
				}
				if (tAlpha) {												// If they had an alpha channel..
					ourMap = (byte*)mAlpha;								// We have already allocated ours, point at it.
					theirMap = (byte*)aBitmap->getAlphaAddr();	// Get the address of theirs.
					numBytes  = mWidth * mHeight * sizeof(byte);	// Calculate the number of bytes in our alpha buffer.
					for(int i=0;i<numBytes;i++) {						// For every byte..
						ourMap[i] = theirMap[i];						// Copy theirs into ours.
					}
				}
			}
		}
	}
}

		
bitmap::~bitmap(void) {

	resizeBuff(0,(byte**)&mBitmap);
	resizeBuff(0,(byte**)&mAlpha);
}


// Copy down the bitmap size then, if possible, allocate the buffer.
// This can also be used to reset to different sizes, But it causes
// all previous data to be lost when called.
bool bitmap::setSize(int width,int height,bool alpha) {

	int numBytes;
  
	mWidth    = 0;														// Not yet.
	mHeight   = 0;														// Allocate before assuming.
	numBytes  = width * height * sizeof(RGBpack);			// Calculate buffer size.
	mHaveMap  = resizeBuff(numBytes,(byte**)&mBitmap);		// Make a grab for the RAM.
	if (mHaveMap && alpha) {										// If we got the RAM and we need an alpha channel..
  		numBytes  = width * height * sizeof(byte);			// Calculate the buffer for alpha channel.
  		if (resizeBuff(numBytes,(byte**)&mAlpha)) {			// If we can also grab the RAM for the alpha channel..
  			for (int i=0;i<numBytes;i++) {						// Just to be nice..
  				mAlpha[i] = 255;										// Default the alpa channel to opaque. (Good default)
  			}
  			mHaveMap = true;											// We are good to go!
  		} else {															// Else, we could NOT get the RAM for the alpha channel..
  			resizeBuff(0,(byte**)&mBitmap);						// Sadly, we dump the bitmap buffer.
  			mHaveMap = false;											// We have failed.
  		}
	}
	if (mHaveMap) {													// If we have been a success..
		mWidth    = width;											// Its this wide.
		mHeight   = height;											// And this tall.
	}
	return mHaveMap;													// Return our success. Or failure..
}


// Just dump everything. Probably need the memory elsewhere.
void bitmap::clearMap(void) {

	mWidth    = 0;
	mHeight   = 0;
	resizeBuff(0,(byte**)&mBitmap);
	resizeBuff(0,(byte**)&mAlpha);
	mHaveMap  = false;
}


// Caller wants to know if we have a map allocated.
bool bitmap::getHasMap(void) { return mHaveMap; }


// These two are for reading back our size..
int bitmap::getWidth(void) { return mWidth; }
int bitmap::getHeight(void) { return mHeight; }


// Set this location to a color. Actually just a pass
// through to the color pack version.
void bitmap::setColor(int x,int y,colorObj* aColor) {

  RGBpack aCPack;

  if (aColor) {
    aCPack = aColor->packColor();
  }
  setColor(x,y,&aCPack);
}


// Set this location to a color. This is the method that actually
// writes to RAM. Hence, everything is sanity checked first.
void  bitmap::setColor(int x,int y,RGBpack* aColor) {

  int index;

  if (x>=0 && x<mWidth && y>=0 && y<mHeight && mHaveMap && aColor) {
    index = y * mWidth + x;
    mBitmap[index] = *aColor;
  }
}


// Set this location's alpha channel. This is the method that actually
// writes to RAM. Hence, everything is sanity checked first.
void  bitmap::setAlpha(int x,int y,byte alpha) {

  int index;

  if (x>=0 && x<mWidth && y>=0 && y<mHeight && mHaveMap && mAlpha) {
    index = y * mWidth + x;
    mAlpha[index] = alpha;
  }
}


// Grab a color object out of RAM. We need this fast so, no sanity checking.
// Give bad input? Get undefined output.
colorObj bitmap::getColor(int x,int y) {

  colorObj  aColor;
  RGBpack   aCPack;

  aCPack = getColorPack(x,y);
  aColor.setColor(&aCPack);
  return aColor;
}


// Grab a color pack out of RAM. Again, we need this fast so, no sanity checking.
// Give bad input? Get bad output.
RGBpack bitmap::getColorPack(int x,int y) {

  RGBpack aCPack;
  int     index;
  
  index = y * mWidth + x;
  aCPack = mBitmap[index];
  return aCPack;
}


byte bitmap::getAlpha(int x,int y) {

	int     index;
  	
  	if (mAlpha) {
		index = y * mWidth + x;
		return mAlpha[index];
	}
	return 255;
}


// This one is kinda' scary. We hand off the address to your bitmap buffer. I mean, I
// don't even like valet parking.
RGBpack* bitmap::getBitmapAddr(void) { return mBitmap; }


// And this one too. Here's the address to our alpha channel buffer.
byte*  bitmap::getAlphaAddr(void) { return mAlpha; }




bitmap.cpp

#ifndef bitmap_h
#define bitmap_h

#include "colorObj.h"

class bitmap {

	public :
				bitmap(void);
				bitmap(int width,int height,bool alpha=false);
				bitmap(bitmap* aBitmap);
	virtual	~bitmap(void);

				bool			setSize(int width,int height,bool alpha=false);
				void			clearMap(void);
				bool			getHasMap(void);
				int			getWidth(void);
				int			getHeight(void);
				void			setColor(int x,int y,colorObj* aColor);
				void			setColor(int x,int y,RGBpack* aColor);
				void			setAlpha(int x,int y,byte alpha);
				colorObj		getColor(int x,int y);
				RGBpack		getColorPack(int x,int y);
				byte			getAlpha(int x,int y);
				RGBpack*		getBitmapAddr(void);
				byte*			getAlphaAddr(void);
				
  protected:
      int			mWidth;
      int			mHeight;
      bool			mHaveMap;
      RGBpack*		mBitmap;
      byte*			mAlpha;
};


#endif


bitmap.h

#include "offscreen.h"
#include "screen.h"


// ***************************************************************
// mapDisplay : Mimics a display to catch the drawing.
// ***************************************************************

// Constructor is only used by the offscreen class and it'll do the
// sanity checking before calling. Setting up the GFX object width
// & height are actually asking, max width & max height. So you need
// to add in the offsets as well. This seems to only be checked when
// drawing text.
mapDisplay::mapDisplay(bitmap* inMap,int ofsX,int ofsY)  
  : Adafruit_GFX((int16_t)inMap->getWidth()+ofsX,(int16_t)inMap->getHeight()+ofsY) {

  mBitmap = inMap;
  offsetX = ofsX;
  offsetY = ofsY;
}


mapDisplay::~mapDisplay(void) {  }


bool mapDisplay::dispObjBegin(void) { return true; }


void mapDisplay::drawPixel(int16_t x, int16_t y, uint16_t color) {

	colorObj  aColor(color);
	mBitmap->setColor(x-offsetX,y-offsetY,&aColor);
}



// ***************************************************************
// offscreen : The part the user interacts with.
// ***************************************************************

    
offscreen::offscreen(void)
  : displayObj(true,true,false,false,true) {
    
	oldScreen = NULL;
	mDisplay  = NULL;
	mDrawing  = false;
}


offscreen::~offscreen(void) { 
  
  if (mDisplay) delete mDisplay;
}


// Accept a bitmap, sanity check everything. If everything
// is good, set up for drawing to it.
void offscreen::beginDraw(bitmap* inMap,int inOffsetX,int inOffsetY) {

  if (mDrawing) {                        			 					// We already drawing? Someone forgot to shut down?
    endDraw();                            							// Shut it down.
  }
  if (mDisplay) {                         							// If we have a display object..
    delete mDisplay;                      							// dump it.
    mDisplay = NULL;                      							// Note it's gone.
  }
  if (inMap) {                            							// Sanity. We got a bitmap?
    if (inMap->getHasMap()) {             							// And its RAM's been allocated?
      mDisplay  = new mapDisplay(inMap,inOffsetX,inOffsetY);	// Create the display objecet with the bitmap.
      if (mDisplay) {                     							// Sanity. We got that display?
        oldScreen = screen;               							// Everything seems ok. Save off the screen pointer.
        screen = this;                    							// Replace it with us.
        mDrawing = true;                  							// Note that we are now rerouting drawing calls.
      }
    }
  }
}


// ENOUGH! We're done drawing to the bitmap.
void offscreen::endDraw(void) {
  
	if (mDrawing) {			// Have we rerouted drawing calls?
		screen = oldScreen;	// Undo the screen rerouting.
		oldScreen = NULL;		// Note this is done.
		mDrawing = false;		// Note that we are no longer rerouting drawing calls.
	} 
}


// In case someone asks.
bool offscreen::dispObjBegin(void) { return true; }


// The standard pass throughs.
void offscreen::setRotation(byte inRotation)                                                  	{ mDisplay->setRotation(inRotation); }
void offscreen::setTextColor(colorObj* inColor)                                               	{ mDisplay->setTextColor(inColor->getColor16()); }
void offscreen::setTextColor(colorObj* tColor,colorObj* bColor)                               	{ mDisplay->setTextColor(tColor->getColor16(),bColor->getColor16()); }
void offscreen::setTextSize(byte inSize)                                                      	{ mDisplay->setTextSize(inSize); }
void offscreen::setTextWrap(boolean wrap)                                                     	{ mDisplay->setTextWrap(wrap); }
void offscreen::setFont(const GFXfont* font)                                                  	{ mDisplay->setFont(font); }
void offscreen::setCursor(int x,int y)                                                        	{ mDisplay->setCursor(gX(x),gY(y)); }
void offscreen::drawText(char* inText)                                                        	{ mDisplay->print(inText); }
void offscreen::drawChar(int x,int y,char inChar,colorObj* fColor,colorObj* bColor,int size) 	{ mDisplay->drawChar(gX(x),gY(y),inChar,fColor->getColor16(),bColor->getColor16(),size); }
void offscreen::fillScreen(colorObj* inColor)                                                 	{ mDisplay->fillScreen(inColor->getColor16()); }
void offscreen::fillRect(int x,int y,int width,int height,colorObj* inColor)                  	{ mDisplay->fillRect(gX(x),gY(y), width, height,inColor->getColor16()); }
void offscreen::fillRect(rect* aRect,colorObj* inColor)                                       	{ mDisplay->fillRect(gX(aRect->x),gY(aRect->y), aRect->width, aRect->height,inColor->getColor16()); }
void offscreen::drawRect(int x,int y,int width,int height,colorObj* inColor)                  	{ mDisplay->drawRect(gX(x),gY(y), width, height,inColor->getColor16()); }
void offscreen::drawRect(rect* aRect,colorObj* inColor)                                       	{ mDisplay->drawRect(gX(aRect->x),gY(aRect->y), aRect->width, aRect->height,inColor->getColor16()); }
void offscreen::fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)  	{ mDisplay->fillRoundRect(gX(x),gY(y),width,height,radius,inColor->getColor16()); }
void offscreen::fillRoundRect(rect* aRect,int radius,colorObj* inColor)                       	{ mDisplay->fillRoundRect(gX(aRect->x),gY(aRect->y),aRect->width,aRect->height,radius,inColor->getColor16()); }
void offscreen::drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)  	{ mDisplay->drawRoundRect(gX(x),gY(y),width,height,radius,inColor->getColor16()); }
void offscreen::drawRoundRect(rect* aRect,int radius,colorObj* inColor)                       	{ mDisplay->drawRoundRect(gX(aRect->x),gY(aRect->y),aRect->width,aRect->height,radius,inColor->getColor16()); }
void offscreen::drawCircle(int x,int y,int diam, colorObj* inColor)                           	{ drawRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void offscreen::fillCircle(int x,int y,int diam, colorObj* inColor)                           	{ fillRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void offscreen::drawVLine(int x,int y,int height,colorObj* inColor)                           	{ mDisplay->drawFastVLine(gX(x),gY(y),height,inColor->getColor16()); }
void offscreen::drawHLine(int x,int y,int width,colorObj* inColor)                            	{ mDisplay->drawFastHLine(gX(x),gY(y),width,inColor->getColor16()); }
void offscreen::drawLine(int x,int y,int x2,int y2,colorObj* inColor)                         	{ mDisplay->drawLine(gX(x),gY(y),gX(x2),gY(y2),inColor->getColor16()); }
void offscreen::drawPixel(int x,int y,colorObj* inColor)                                      	{ mDisplay->drawPixel(gX(x),gY(y),inColor->getColor16()); }


 


offscreen.cpp

#ifndef offscreen_h
#define offscreen_h

#include "bitmap.h"
#include "displayObj.h"
#include "Adafruit_GFX.h"


class mapDisplay :  public Adafruit_GFX {
  
  public :
            mapDisplay(bitmap* inMap,int ofsX,int ofsY);
    virtual ~mapDisplay(void);
          
            bool  dispObjBegin(void);
    virtual void  drawPixel(int16_t x, int16_t y, uint16_t color);

  protected :
  				int		offsetX;
				int		offsetY;
            colorObj	mFColor;
            colorObj	mBColor;
            bool		mTransp;
            bitmap*	mBitmap;
};



class offscreen : public displayObj {

  public :
				offscreen(void);
				~offscreen(void);

				bool  dispObjBegin(void);
				void  beginDraw(bitmap* inMap,int inOffsetX=0,int inOffsetY=0);
				void  endDraw(void);

	virtual   void  setRotation(byte inRotation);
	virtual   void  setTextColor(colorObj* tColor);
	virtual   void  setTextColor(colorObj* tColor,colorObj* bColor);
	virtual   void  setTextSize(byte inSize);
	virtual   void  setTextWrap(boolean wrap);
	virtual   void  setFont(const GFXfont* font);
	virtual   void  setCursor(int x,int y);
	virtual   void  drawText(char* inText);
	virtual   void  drawChar(int x,int y,char inChar,colorObj* fColor,colorObj* bColor,int size);
	virtual   void  fillScreen(colorObj* inColor);
	virtual   void  fillRect(int x,int y,int width,int height,colorObj* inColor);
	virtual   void  fillRect(rect* aRect,colorObj* inColor);
	virtual   void  drawRect(int x,int y,int width,int height,colorObj* inColor);
	virtual   void  drawRect(rect* aRect,colorObj* inColor);
	virtual   void  fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual   void  fillRoundRect(rect* aRect,int radius,colorObj* inColor);
	virtual   void  drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual   void  drawRoundRect(rect* aRect,int radius,colorObj* inColor);
	virtual   void  drawCircle(int x,int y,int diam, colorObj* inColor);
	virtual   void  fillCircle(int x,int y,int diam, colorObj* inColor);
	virtual   void  drawVLine(int x,int y,int height,colorObj* inColor);
	virtual   void  drawHLine(int x,int y,int width,colorObj* inColor);
	virtual   void  drawLine(int x,int y,int x2,int y2,colorObj* inColor);
	virtual   void  drawPixel(int x,int y,colorObj* inColor);

		
		bool        mDrawing;
		mapDisplay* mDisplay;
		displayObj* oldScreen;
};


#endif


offscreen.h

#include "adafruit_1431_Obj.h"


adafruit_1431_Obj::adafruit_1431_Obj(byte inCS,byte inRST)
  :displayObj(true,true,false,true,false) {

  theOLED = NULL;
  cs = inCS;
  rst = inRST;
}

adafruit_1431_Obj::~adafruit_1431_Obj(void) {

    if (theOLED) { 
      delete theOLED;
      theOLED = NULL;
    }
  }

  
bool adafruit_1431_Obj::dispObjBegin(void) { 

  theOLED = new Adafruit_SSD1351(cs, LC_DC, rst);
  if (theOLED!=NULL) {
    theOLED->begin();
    return true;
  }
  return false;
}

int  adafruit_1431_Obj::width(void)																							{ return theOLED->width(); }
int  adafruit_1431_Obj::height(void)																						{ return theOLED->height(); }
void adafruit_1431_Obj::setRotation(byte inRotation)      															{ theOLED->setRotation(inRotation); }
void adafruit_1431_Obj::setTextColor(colorObj* inColor)   															{ theOLED->setTextColor(inColor->getColor16()); }
void adafruit_1431_Obj::setTextColor(colorObj* tColor,colorObj* bColor)											{ theOLED->setTextColor(tColor->getColor16(),bColor->getColor16()); }
void adafruit_1431_Obj::setTextSize(byte inSize)          															{ theOLED->setTextSize(inSize); }
void adafruit_1431_Obj::setTextWrap(boolean wrap)         															{ theOLED->setTextWrap(wrap); }
void adafruit_1431_Obj::setFont(const GFXfont* font) 																	{ theOLED->setFont(font); }
void adafruit_1431_Obj::setCursor(int x,int y)        																{ theOLED->setCursor(gX(x),gY(y)); }
void adafruit_1431_Obj::drawText(char* inText)            															{ theOLED->print(inText); }
void adafruit_1431_Obj::fillScreen(colorObj* inColor)     															{ theOLED->fillScreen(inColor->getColor16());}
void adafruit_1431_Obj::fillRect(int x,int y,int width,int height,colorObj* inColor)						{ theOLED->fillRect(gX(x),gY(y), width, height,inColor->getColor16()); }
void adafruit_1431_Obj::fillRect(rect* aRect,colorObj* inColor)													{ theOLED->fillRect(gX(aRect->x),gY(aRect->y), aRect->width, aRect->height,inColor->getColor16()); }
void adafruit_1431_Obj::drawRect(int x,int y,int width,int height,colorObj* inColor)						{ theOLED->drawRect(gX(x),gY(y), width, height,inColor->getColor16()); }
void adafruit_1431_Obj::drawRect(rect* aRect,colorObj* inColor)													{ theOLED->drawRect(gX(aRect->x),gY(aRect->y), aRect->width, aRect->height,inColor->getColor16()); }
void adafruit_1431_Obj::fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)	{ theOLED->fillRoundRect(gX(x),gY(y),width,height,radius,inColor->getColor16()); }
void adafruit_1431_Obj::fillRoundRect(rect* aRect,int radius,colorObj* inColor)								{ theOLED->fillRoundRect(gX(aRect->x),gY(aRect->y),aRect->width,aRect->height,radius,inColor->getColor16()); }
void adafruit_1431_Obj::drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)	{ theOLED->drawRoundRect(gX(x),gY(y),width,height,radius,inColor->getColor16()); }
void adafruit_1431_Obj::drawRoundRect(rect* aRect,int radius,colorObj* inColor)								{ theOLED->drawRoundRect(gX(aRect->x),gY(aRect->y),aRect->width,aRect->height,radius,inColor->getColor16()); }
void adafruit_1431_Obj::drawCircle(int x,int y,int diam, colorObj* inColor) 									{ drawRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void adafruit_1431_Obj::fillCircle(int x,int y,int diam, colorObj* inColor) 									{ fillRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void adafruit_1431_Obj::drawVLine(int x,int y,int height,colorObj* inColor) 									{ theOLED->drawFastVLine(gX(x),gY(y),height,inColor->getColor16()); }
void adafruit_1431_Obj::drawHLine(int x,int y,int width,colorObj* inColor) 									{ theOLED->drawFastHLine(gX(x),gY(y),width,inColor->getColor16()); }
void adafruit_1431_Obj::drawLine(int x,int y,int x2,int y2,colorObj* inColor) 								{ theOLED->drawLine(gX(x),gY(y),gX(x2),gY(y2),inColor->getColor16()); }
void adafruit_1431_Obj::drawPixel(int x,int y,colorObj* pColor) 													{ theOLED->drawPixel(gX(x),gY(y),pColor->getColor16()); }


 


adafruit_1431_Obj.cpp

#ifndef adafruit_1431_Obj_h
#define adafruit_1431_Obj_h

#include "displayObj.h"
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1351.h>
#include "LC_SPI.h"


// Rotation
#define PORTRAIT      0  // Wires up
#define LANDSCAPE     1  // Wires left
#define INV_PORTRAIT  2  // Wires down
#define INV_LANDSCAPE 3  // Wires right

class adafruit_1431_Obj : public displayObj {

  public :
  				adafruit_1431_Obj(byte inCS,byte inRST=-1);
  virtual	~adafruit_1431_Obj(void);
  
	virtual 	bool	dispObjBegin(void);
  	virtual	int	width(void);
	virtual	int	height(void);
	virtual 	void	setRotation(byte inRotation);
	virtual 	void	setTextColor(colorObj* tColor);
	virtual 	void	setTextColor(colorObj* tColor,colorObj* bColor);
	virtual 	void	setTextSize(byte inSize);
	virtual 	void	setTextWrap(boolean wrap);
	virtual 	void	setFont(const GFXfont* font);
	virtual 	void	setCursor(int x,int y);
	virtual 	void	drawText(char* inText);
	virtual 	void	fillScreen(colorObj* inColor);
	virtual 	void	fillRect(int x,int y,int width,int height,colorObj* inColor);
	virtual 	void	fillRect(rect* aRect,colorObj* inColor);
	virtual 	void	drawRect(int x,int y,int width,int height,colorObj* inColor);
	virtual 	void	drawRect(rect* aRect,colorObj* inColor);
	virtual 	void	fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual 	void	fillRoundRect(rect* aRect,int radius,colorObj* inColor);
	virtual 	void	drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual 	void	drawRoundRect(rect* aRect,int radius,colorObj* inColor);
	virtual 	void	drawCircle(int x,int y,int diam, colorObj* inColor);
	virtual 	void	fillCircle(int x,int y,int diam, colorObj* inColor);
	virtual 	void	drawVLine(int x,int y,int height,colorObj* inColor);
	virtual 	void	drawHLine(int x,int y,int width,colorObj* inColor);
	virtual 	void	drawLine(int x,int y,int x2,int y2,colorObj* inColor);
	virtual 	void	drawPixel(int x,int y,colorObj* pColor);
  
  private:
          Adafruit_SSD1351* theOLED;
          byte              cs;
          byte              rst;
};

#endif

adafruit_1431_Obj.h

// SPI setting choices are actually a function of the processor.
// Many have hardware dedicated for this, so these are the pins
// we should be using. Trying to define these settings at the
// hardware level is a mistake.
//
// Hence, this file.

#ifndef LC_SPI_H
#define LC_SPI_H

#include <SPI.h>

// The six shared SPI pins..
// These pins are best choice for Arduino & Teensy 3.2.
//#define LC_CLK		13		// Clock				- WHITE WIRE 30AWG
//#define LC_MISO	12		// Input data		- GREEN WIRE 30AWG
//#define LC_MOSI	11		// Output data		- BLUE WIRE 30AWG
//#define LC_DC		9		// Data/command	- YELLOW WIRE 30AWG


// The six shared SPI pins..
// These pins are best choice for Arduino MEGA
#define LC_CLK		52		// Clock				- WHITE WIRE 30AWG
#define LC_MISO	50		// Input data		- GREEN WIRE 30AWG
#define LC_MOSI	51		// Output data		- BLUE WIRE 30AWG
#define LC_DC		53		// Data/command	- YELLOW WIRE 30AWG


// 5V  - RED WIRE 30AWG
// GND - BLACK WIRE 30AWG

// These two are non-shared pins.
// More of a serving suggestion than anything else.
// CS  - RED WIRE 30AWG
// RST - BLACK WIRE 30AWG

// This set is for Adafruit Feather MO #2995
//#define LC_CLK 	24
//#define LC_MOSI	23
//#define LC_MISO	22
//#define LC_DC		21   // Free to choose.


// Each device needs its own chip select pin defined.
// Some devices want reset pins defined as well.


#endif

LC_SPI.h

#include "adafruit_684_Obj.h"

static const int16_t OLED_WIDTH = 96;    ///< The width of the display
static const int16_t OLED_HEIGHT = 64;   ///< The height of the display

float		percBlack = 0;  
colorObj	gColor; 


colorObj* sDim(colorObj* inColor) {

	//return inColor;							// Debug. Keeps display on.
	if (percBlack<=0) return inColor;
	if (percBlack>=100) return &black;
	gColor.setColor(inColor);
	gColor.blend(&black,percBlack);
	return &gColor;
}
	
  
adafruit_684_Obj::adafruit_684_Obj(byte inCS,byte inRST)
  :displayObj(true,true,false,true,false) {

  theOLED = NULL;
  cs = inCS;
  rst = inRST;
}

adafruit_684_Obj::~adafruit_684_Obj(void) {

    if (theOLED) { 
      delete theOLED;
      theOLED = NULL;
    }
  }

  
bool adafruit_684_Obj::dispObjBegin(void) { 

  theOLED = new Adafruit_SSD1331(&SPI,cs, LC_DC, rst);
  if (theOLED!=NULL) {
    theOLED->begin();
    return true;
  }
  return false;
}


int adafruit_684_Obj::width(void)																							{ return theOLED->width(); }
int adafruit_684_Obj::height(void)																							{ return theOLED->height(); }
void adafruit_684_Obj::setRotation(byte inRotation)																	{ theOLED->setRotation(inRotation); }
void adafruit_684_Obj::setTextColor(colorObj* inColor)																{ theOLED->setTextColor(sDim(inColor)->getColor16()); }
void adafruit_684_Obj::setTextColor(colorObj* tColor,colorObj* bColor)											{ theOLED->setTextColor(sDim(tColor)->getColor16(),sDim(bColor)->getColor16()); }
void adafruit_684_Obj::setTextSize(byte inSize)																			{ theOLED->setTextSize(inSize); }
void adafruit_684_Obj::setTextWrap(boolean wrap)																		{ theOLED->setTextWrap(wrap); }
void adafruit_684_Obj::setFont(const GFXfont* font)																	{ theOLED->setFont(font); }
void adafruit_684_Obj::setCursor(int x,int y)																			{ theOLED->setCursor(gX(x),gY(y)); }
void adafruit_684_Obj::drawText(char* inText)																			{ theOLED->print(inText); }
void adafruit_684_Obj::fillScreen(colorObj* inColor)																	{ theOLED->fillScreen(sDim(inColor)->getColor16()); }
void adafruit_684_Obj::fillRect(int x,int y,int width,int height,colorObj* inColor)							{ theOLED->fillRect(gX(x),gY(y), width, height,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::drawRect(int x,int y,int width,int height,colorObj* inColor)							{ theOLED->drawRect(gX(x),gY(y), width, height,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::fillRect(rect* inRect,colorObj* inColor)													{ theOLED->fillRect(gX(inRect->x),gY(inRect->y), inRect->width, inRect->height,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::drawRect(rect* inRect,colorObj* inColor)													{ theOLED->drawRect(gX(inRect->x),gY(inRect->y), inRect->width, inRect->height,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)	{ theOLED->fillRoundRect(gX(x),gY(y),width,height,radius,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)	{ theOLED->drawRoundRect(gX(x),gY(y),width,height,radius,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::drawCircle(int x,int y,int diam, colorObj* inColor)										{ drawRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void adafruit_684_Obj::fillCircle(int x,int y,int diam, colorObj* inColor)										{ fillRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void adafruit_684_Obj::drawVLine(int x,int y,int height,colorObj* inColor)										{ theOLED->drawFastVLine(gX(x),gY(y),height,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::drawHLine(int x,int y,int width,colorObj* inColor)										{ theOLED->drawFastHLine(gX(x),gY(y),width,sDim(inColor)->getColor16()); }
void adafruit_684_Obj::drawLine(int x,int y,int x2,int y2,colorObj* inColor)									{ theOLED->drawLine(gX(x),gY(y),gX(x2),gY(y2),sDim(inColor)->getColor16()); }
void adafruit_684_Obj::drawPixel(int x,int y,colorObj* inColor)													{ theOLED->drawPixel(gX(x),gY(y),sDim(inColor)->getColor16()); }







 


adafruit_684_Obj.cpp

#include "displayObj.h"
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1331.h>
#include "LC_SPI.h"


// Rotation
#define PORTRAIT      0  // Wires up
#define LANDSCAPE     1  // Wires left
#define INV_PORTRAIT  2  // Wires down
#define INV_LANDSCAPE 3  // Wires right


extern float	percBlack;


class adafruit_684_Obj : public displayObj {

  public :
  				adafruit_684_Obj(byte inCS,byte inRST=-1);
  virtual	~adafruit_684_Obj(void);
  
	virtual	int	width(void);
	virtual	int	height(void);
	virtual 	bool	dispObjBegin(void);
	virtual 	void	setRotation(byte inRotation);
	virtual 	void	setTextColor(colorObj* tColor);
	virtual 	void	setTextColor(colorObj* tColor,colorObj* bColor);
	virtual 	void	setTextSize(byte inSize);
	virtual 	void	setTextWrap(boolean wrap);
	virtual 	void	setFont(const GFXfont* font);
	virtual 	void	setCursor(int x,int y);
	virtual 	void	drawText(char* inText);
	virtual 	void	fillScreen(colorObj* inColor);
	virtual 	void	fillRect(int x,int y,int width,int height,colorObj* inColor);
	virtual 	void	drawRect(int x,int y,int width,int height,colorObj* inColor);
	virtual 	void	fillRect(rect* inRect,colorObj* inColor);
	virtual 	void	drawRect(rect* inRect,colorObj* inColor);
	virtual 	void	fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual 	void	drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual 	void	drawCircle(int x,int y,int diam, colorObj* inColor);
	virtual 	void	fillCircle(int x,int y,int diam, colorObj* inColor);
	virtual 	void	drawVLine(int x,int y,int height,colorObj* inColor);
	virtual 	void	drawHLine(int x,int y,int width,colorObj* inColor);
	virtual 	void	drawLine(int x,int y,int x2,int y2,colorObj* inColor);
	virtual 	void	drawPixel(int x,int y,colorObj* inColor);
	
	
  private:
          Adafruit_SSD1331*	theOLED;
          byte              	cs;
          byte              	rst;
};


adafruit_684_Obj.h

#include "adafruit_1947_Obj.h"



// **********************************************************
//								maskableILI9341
//	Adafruit_ILI9341 with the ability to have a mask added.	
// **********************************************************

mask* gMask = NULL;

maskableILI9341::maskableILI9341(int cs, int rst)
	: Adafruit_ILI9341(cs,LC_DC,rst) { }
	
	
maskableILI9341::~maskableILI9341(void) {  }
	
void maskableILI9341::drawPixel(int16_t x, int16_t y, uint16_t color) {

	if (gMask) {
		if (gMask->checkPixel(x,y)) {
			Adafruit_ILI9341::drawPixel(x,y,color);
		}
	} else {
		Adafruit_ILI9341::drawPixel(x,y,color);
	}
}


void maskableILI9341::writePixel(int16_t x, int16_t y, uint16_t color) {

	if (gMask) {
		if (gMask->checkPixel(x,y)) {
			Adafruit_ILI9341::writePixel(x,y,color);
		}
	} else {
		Adafruit_ILI9341::writePixel(x,y,color);
	}
}


void maskableILI9341::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {

	int	lastX;
	int	lastY;
	
	if (gMask) {
		switch(gMask->checkRect(x,y,w,h)) {
			case unMasked			: Adafruit_ILI9341::fillRect(x,y,w,h,color); break;
			case totalMasked		: return;
			case partialMasked	:
				lastX = x + w;
				lastY = y + h;
				for(int i=y;i<lastY;i++) {
					for(int j=x;j<=lastX;j++) {
						drawPixel(j,i,color);
					}
				}
			break;
		}
	} else {
		Adafruit_ILI9341::fillRect(x,y,w,h,color);
	}
}

// **********************************************************
//								adafruit_1947_Obj	
// **********************************************************


adafruit_1947_Obj::adafruit_1947_Obj(void)
	:displayObj(true,true,true,true,false) {
    
	cTS			= NULL;
	theTFT		= NULL;
	cs				= ADA_1947_SHIELD_CS;
	rst			= ADA_1947_SHIELD_RST;
	lastTouch	= false;
	touchNum		= 0;
}


adafruit_1947_Obj::adafruit_1947_Obj(byte inCS,byte inRst)
  :displayObj(true,true,true,true,false) {

	cTS			= NULL;
	theTFT		= NULL;
	cs				= inCS;
	rst			= inRst;
	lastTouch	= false;
	touchNum		= 0;
}


adafruit_1947_Obj::~adafruit_1947_Obj(void) {

	if (theTFT!=NULL) {
		delete theTFT;
		theTFT = NULL;
	}
	if (cTS!=NULL) {
		delete cTS;
		cTS = NULL;
	}
}

rect cRect;

bool adafruit_1947_Obj::dispObjBegin(void) { 

  //theTFT = new Adafruit_ILI9341(cs,LC_DC,rst);
  //theTFT = new ILI9341_t3(cs,LC_DC,rst);
  theTFT = new maskableILI9341(cs,rst);
  if (theTFT!=NULL) {
    cTS = new Adafruit_FT6206();
    if (cTS!=NULL) {
    	theTFT->begin();										// Doesn't have fail mode here.
    	if (cTS->begin(40)) {								// 40 comes from example code.
    		return true;
    	}
    }
  }
  if (theTFT!=NULL) {
	 delete theTFT;
	 theTFT = NULL;
  }
  if (cTS!=NULL) {
    delete cTS;
    cTS = NULL;
  }
  return false;
}

int adafruit_1947_Obj::width(void)																							{ return theTFT->width(); }
int adafruit_1947_Obj::height(void)																							{ return theTFT->height(); }
void adafruit_1947_Obj::startWrite(void)																					{ theTFT->startWrite(); }
void adafruit_1947_Obj::endWrite(void)																						{ theTFT->endWrite(); }
void adafruit_1947_Obj::setRotation(byte inRotation)																	{ theTFT->setRotation(inRotation); }
void adafruit_1947_Obj::setTextColor(colorObj* inColor)																{ theTFT->setTextColor(inColor->getColor16()); }
void adafruit_1947_Obj::setTextColor(colorObj* tColor,colorObj* bColor) 										{ theTFT->setTextColor(tColor->getColor16(),bColor->getColor16()); }
void adafruit_1947_Obj::setTextSize(byte inSize)																		{ theTFT->setTextSize(inSize); }
void adafruit_1947_Obj::setTextWrap(boolean wrap)																		{ theTFT->setTextWrap(wrap); }
void adafruit_1947_Obj::setFont(const GFXfont* font)																	{ theTFT->setFont(font); }
//void adafruit_1947_Obj::setFont(const GFXfont* font)																	{ theTFT->setFontAdafruit(); }
void adafruit_1947_Obj::setCursor(int x,int y)																			{ theTFT->setCursor(gX(x),gY(y)); }
void adafruit_1947_Obj::drawText(char* inText)																			{ theTFT->print(inText); }
void adafruit_1947_Obj::fillScreen(colorObj* inColor)																	{ theTFT->fillScreen(inColor->getColor16()); }
void adafruit_1947_Obj::fillRect(int x,int y,int width,int height,colorObj* inColor)						{ theTFT->fillRect(gX(x),gY(y),width, height,inColor->getColor16()); }
void adafruit_1947_Obj::drawRect(int x,int y,int width,int height,colorObj* inColor)						{ theTFT->drawRect(gX(x),gY(y),width, height,inColor->getColor16()); }
void adafruit_1947_Obj::fillRect(rect* inRect,colorObj* inColor)													{ theTFT->fillRect(gX(inRect->x),gY(inRect->y),inRect->width, inRect->height,inColor->getColor16()); }
void adafruit_1947_Obj::drawRect(rect* inRect,colorObj* inColor)													{ theTFT->drawRect(gX(inRect->x),gY(inRect->y),inRect->width, inRect->height,inColor->getColor16()); }
void adafruit_1947_Obj::fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)	{ theTFT->fillRoundRect(gX(x),gY(y),width,height,radius,inColor->getColor16()); }
void adafruit_1947_Obj::drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor)	{ theTFT->drawRoundRect(gX(x),gY(y),width,height,radius,inColor->getColor16()); }
void adafruit_1947_Obj::drawCircle(int x,int y,int diam, colorObj* inColor)									{ drawRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void adafruit_1947_Obj::drawCircleHelper(int x,int y,int rad,byte corner,colorObj* inColor)				{ theTFT->drawCircleHelper(gX(x),gY(y),rad,corner,inColor->getColor16()); }
void adafruit_1947_Obj::fillCircle(int x,int y,int diam, colorObj* inColor)									{ fillRoundRect(gX(x),gY(y),diam,diam,diam/2,inColor); }
void adafruit_1947_Obj::drawVLine(int x,int y,int height,colorObj* inColor)									{ theTFT->drawFastVLine(gX(x),gY(y),height,inColor->getColor16()); }
void adafruit_1947_Obj::drawHLine(int x,int y,int width,colorObj* inColor)										{ theTFT->drawFastHLine(gX(x),gY(y),width,inColor->getColor16()); }
void adafruit_1947_Obj::drawLine(int x,int y,int x2,int y2,colorObj* inColor)									{ theTFT->drawLine(gX(x),gY(y),gX(x2),gY(y2),inColor->getColor16()); }
 
  
void adafruit_1947_Obj::drawPixel(int x,int y,colorObj* pColor) { theTFT->drawPixel(gX(x),gY(y),pColor->getColor16()); }
	 
point adafruit_1947_Obj::getPoint(void) {

  TS_Point	adaPoint;
  point		lcPoint;

  adaPoint = cTS->getPoint();
  switch (theTFT->getRotation()) {
  case INV_PORTRAIT:
    break;
  case INV_LANDSCAPE:
    swap(adaPoint.x,adaPoint.y);
    adaPoint.x = adaPoint.x;
    adaPoint.y = theTFT->height() - adaPoint.y;
    break;
  case PORTRAIT:
    adaPoint.x = theTFT->width() - adaPoint.x;
    adaPoint.y = theTFT->height() - adaPoint.y;
    break;
  case LANDSCAPE:
    swap(adaPoint.x,adaPoint.y);
    adaPoint.x = theTFT->width() - adaPoint.x;
    adaPoint.y = adaPoint.y;
    break;
  }
  lcPoint.x = adaPoint.x;
  lcPoint.y = adaPoint.y;
  return lcPoint;
}


bool adafruit_1947_Obj::touched(void) { return cTS->touched(); }



adafruit_1947_Obj.cpp

#ifndef adafruit_1947_Obj_h
#define adafruit_1947_Obj_h

#include <Wire.h>      			// this is needed for FT6206
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
//#include <ILI9341_t3.h>
#include <Adafruit_FT6206.h>
#include "LC_SPI.h"
#include "baseGraphics.h"
#include "displayObj.h"
#include "mask.h"

// Shield version
#define ADA_1947_SHIELD_CS		10
#define ADA_1947_SHIELD_RST	-1
#define ADA_1947_SHIELD_SDCS	4

// Rotation
#define PORTRAIT      0  // USB up
#define LANDSCAPE     1  // USB left
#define INV_PORTRAIT  2  // USB down
#define INV_LANDSCAPE 3  // USB right

#ifndef swap
#define swap(a, b) { int16_t t = a; a = b; b = t; }
#endif

extern mask* gMask;

class maskableILI9341 :	public Adafruit_ILI9341 {
								
	public :
				maskableILI9341(int cs, int rst);
	virtual	~maskableILI9341(void);
	
	virtual	void drawPixel(int16_t x, int16_t y, uint16_t color);
	virtual	void writePixel(int16_t x, int16_t y, uint16_t color);
	virtual	void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
};



class adafruit_1947_Obj : public displayObj {

	public :
				adafruit_1947_Obj(void);						// Shield version.
				adafruit_1947_Obj(byte inCS,byte inRst);  // Breakout version.
	virtual	~adafruit_1947_Obj(void);
  
	virtual	bool	dispObjBegin(void);
	virtual	int	width(void);
	virtual	int	height(void);
	virtual	void	startWrite(void);
	virtual	void	endWrite(void);
	virtual	void	setRotation(byte inRotation);
	virtual	void	setTextColor(colorObj* tColor);
	virtual	void	setTextColor(colorObj* tColor,colorObj* bColor);
	virtual	void	setTextSize(byte inSize);
	virtual	void	setTextWrap(boolean wrap);
	virtual	void	setFont(const GFXfont* font);
	virtual	void	setCursor(int inX,int inY);
	virtual	void	drawText(char* inText);
	virtual	void	fillScreen(colorObj* inColor);
	virtual	void	fillRect(int x,int y,int width,int height,colorObj* inColor);
	virtual	void	drawRect(int x,int y,int width,int height,colorObj* inColor);
	virtual	void	fillRect(rect* inRect,colorObj* inColor);
	virtual	void	drawRect(rect* inRect,colorObj* inColor);
	virtual	void	fillRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual	void	drawRoundRect(int x,int y,int width,int height,int radius,colorObj* inColor);
	virtual	void	drawCircle(int x,int y,int diam, colorObj* inColor);
	virtual	void	drawCircleHelper(int x,int y,int rad,byte corner,colorObj* inColor);
	virtual	void	fillCircle(int x,int y,int diam, colorObj* inColor);
	virtual	void	drawVLine(int x,int y,int height,colorObj* inColor);
	virtual	void	drawHLine(int x,int y,int width,colorObj* inColor);
	virtual	void	drawLine(int x,int y,int x2,int y2,colorObj* inColor);
	virtual	void	drawPixel(int x,int y,colorObj* pColor);
  
	virtual	point     getPoint(void);
	virtual	bool		  touched(void);
  
	private:
				Adafruit_FT6206*	cTS;
				//Adafruit_ILI9341*	theTFT;
				//ILI9341_t3*			theTFT;
				maskableILI9341*		theTFT;
				byte					cs;
				byte					rst;
				bool					lastTouch;
				int					touchNum;
};

#endif

adafruit_1947_Obj.h

#include "bmpObj.h"
#include <resizeBuff.h>

// We only draw one at a time. Maybe, this is better used as a global so there is no
// chance or multiples out there in RAM. Also it seems that it's constructor is really
// slow!
File		bmpFile;


// *************************************
//     	A .bmp file mask class
// *************************************


bmpMask::bmpMask(void) { maskBits = NULL; }

bmpMask::~bmpMask(void) { if (maskBits) resizeBuff(0,&maskBits); }

int getGreyscale(colorObj* aColor) {

	int	sum;
	float	ave;
	
	sum = aColor->getRed() + aColor->getGreen() + aColor->getBlue();
	ave = sum/3.0;
	return round(ave);
}

void	bmpMask::readFromBMP(char* filePath) {

	bmpImage*	alphaFile;
	int			numBytes;
	colorObj		aColor;
	byte			alpha;

	alphaFile = new bmpImage(filePath);							// Have a go at creating the .bmp file object.
	if (alphaFile) {													// If we can create the .bmp file object..
		if (alphaFile->openDocFile(FILE_READ)) {				// If we can open the .bmp file..
			width = alphaFile->getWidth();						// We read and save the width.
			height = alphaFile->getHeight();						// We read and save the height.
			numBytes = calcBuffSize();								// Calculate our buff size.
			if (resizeBuff(numBytes,&maskBits)) {				// If we can allocate the bit buffer..
				for(int y=0;y<height;y++) {						// For every line..
					for(int x=0;x<width;x++) {						// For every pixel in that line..
						aColor = alphaFile->getPixel(x,y);		// Grab the pixel.
						//alpha = aColor.getGreyscale();			// Calculate the brightness of the pixel.
						alpha = getGreyscale(&aColor); // HACK!!
						writeBit(x,y,alpha<128);					// Set the bitmap bit accordingly.
					}
				}
			}
			alphaFile->closeDocFile();									// All done, clean up shop.
		}
		delete(alphaFile);												// Recycle the .bmp file object.
	}
}


bool	bmpMask::checkPixel(int x,int y) { return readBit(x,y); }
	

long 	bmpMask::calcBuffSize(void) {
	
	int	rowBytes;
	
	rowBytes = width/8;				// Making a bit array, divide by 8.
	if (width % 8) rowBytes++;		// Add one if there is a remainder.
	return rowBytes * height;		// Return result;
}
	

void	bmpMask::writeBit(int x, int y,bool trueFalse) {
	
	int	byteIndex;
	byte	bitIndex;
	
	if (maskBits) {											// Sanity check. Is there a bit buffer?..
		byteIndex = ((y * width) + x) / 8;				// Offset into the byte buffer.
		bitIndex = x % 8;										// Offset into the bit field.
		if (trueFalse) {										// Lets see what the user wants..
			bitSet(maskBits[byteIndex],bitIndex);		// If its true, set the bit.
		} else {													// Else, ,ust be false..
			bitClear(maskBits[byteIndex],bitIndex);	// Clear the bit.
		}
	}
}


bool	bmpMask::readBit(int x,int y) {
	
	int	byteIndex;
	byte	bitIndex;
	
	if (maskBits) {												// If we have a mask buffer..
		byteIndex = ((y * width) + x) / 8;					// Calc the byte index.
		bitIndex = x % 8;											// Calc the bit index.
		return bitRead(maskBits[byteIndex],bitIndex);	// return the result.
	} else {															// Else, we have no mask?..
		return true;												// Whatever. No mask means draw it all.
	}
}


	
// *************************************
//          The bmpObj class
// *************************************



bmpObj::bmpObj(int inX,int inY,int inWidth,int inHeight,char* bmpPath)
	: drawObj(inX,inY,inWidth,inHeight),
	bmpImage(bmpPath) {
	
	mMask		= NULL;		// No mask yet.
	offsetX	= 0;			// No offset. Typically there will be none.
	offsetY	= 0;
}


bmpObj::bmpObj(rect* inRect,char* bmpPath)
	: drawObj(inRect),
	bmpImage(bmpPath) {
	
	mMask		= NULL;		// No mask yet.
	offsetX	= 0;			// No offset. Typically there will be none.
	offsetY	= 0;
}

		
bmpObj::~bmpObj(void) {  }


// Setup the source offset for reading from the .bmp file.
void bmpObj::setSourceOffset(int offstX,int offstY) {

		offsetX = offstX;
		offsetY = offstY;
}


// Set a pointer to a mask object. You do NOT own this mask. You can only use it. So don't
// go deleting it!
void bmpObj::setMask(mask* aMaskPtr) { mMask = aMaskPtr; }


// Here we draw! If the file stuff is a bust.. We'll draw some default thing. 
void	bmpObj::drawSelf(void) {

	colorObj	aColor;
	
	if (openDocFile(FILE_READ)) {
		if(mMask) {
			for(int ty=0;ty<drawObj::height;ty++) {
				for(int tx=0;tx<drawObj::width;tx++) {
					if (mMask->checkPixel(tx,ty)) {
						aColor = getPixel(tx+offsetX,ty+offsetY);
						screen->drawPixel(tx+x,ty+y,&aColor);
					} 	
				}
			}
		} else {
			for(int ty=0;ty<drawObj::height;ty++) {
				for(int tx=0;tx<drawObj::width;tx++) {
					aColor = getPixel(tx+offsetX,ty+offsetY);
					screen->drawPixel(tx+x,ty+y,&aColor);	
				}
			}
		}
		closeDocFile();
	} else {
		drawObj::drawSelf();
	}
}

bmpObj.cpp

#ifndef bmpObj_h
#define bmpObj_h

#include "drawObj.h"
#include "bmpImage.h"
#include "bitmap.h"
#include "mask.h"


// This reads a .bmp file showing the silhouette of the shape you would like to draw. This
// silhouette is read in as a greyscale image. GREY_CUTOFF is used to decide whether each
// pixel is masked or drawn.
//
// Anything greater than this is NOT drawn. IE mask-white is for masking. Mask-black is for
// drawing.
#define GREY_CUTOFF	127


class bmpMask :	public mask {

	public:
				bmpMask(void);
	virtual	~bmpMask(void);
	
	virtual	void	readFromBMP(char* filePath);
	virtual	bool	checkPixel(int x,int y);
	
	protected:	
				long 	calcBuffSize(void);
				void	writeBit(int x, int y,bool trueFalse);
				bool	readBit(int x,int y);

				byte*	maskBits;
				int	width;
				int	height;
};



// Years later after so much messing about.
//
// This is to be the BASE CLASS for bitmap file drawing objects. Its a rect location on
// the screen that can spat a bitmap to itself. Want to do a picture, a button or an icon?
// Start with this. (Or just draw a bitmap)
//
// Basically this is the glue that hooks a .bmp filepath to a drawObj.

class bmpObj :	public drawObj,
					public bmpImage {

	public:
				bmpObj(int inX,int inY,int inWidth,int inHeight,char* bmpPath);
				bmpObj(rect* inRect,char* bmpPath);
	virtual	~bmpObj(void);
	
				void	setSourceOffset(int offstX,int offstY);
				void	setMask(mask* aMaskPtr);
	virtual	void	drawSelf(void);
				
				int	offsetX;
				int	offsetY;
				mask*	mMask;
};


#endif

bmpObj.h

#include "colorRect.h"


colorRect::colorRect(void)
	: drawObj(),colorObj() {
	
	setInset(0);
}


colorRect::colorRect(rect* inRect,colorObj* inColor,int inset)
  : drawObj(inRect),colorObj() {
	
	setColor(inColor);
	setInset(inset);
}
	
colorRect::colorRect(int inLocX,int inLocY,int inWidth,int inHeight,colorObj* inColor,int inset=0)
  : drawObj(inLocX,inLocY,inWidth,inHeight),colorObj() {
	
	setColor(inColor);
	setInset(inset);
}


colorRect::colorRect(int inLocX, int inLocY, int inWidth,int inHeight,int inset)
  : drawObj(inLocX,inLocY,inWidth,inHeight),
  colorObj(LC_WHITE) { setInset(inset); }
  
  
colorRect::~colorRect(void) { }


void colorRect::setInset(int inset) {

    mInset = inset;
    needRefresh = true;
}


void colorRect::drawSelf(void) {

	colorObj  insetTLColor;
	colorObj  insetBRColor;
  Serial.print(x);Serial.print(", ");
  Serial.print(y);Serial.print(", ");
  Serial.print(width);Serial.print(", ");
  Serial.println(height);
	screen->fillRect(x, y, width, height, (colorObj*)this);
  Serial.println("done");
  delay(5000);
	if (mInset) {
    Serial.print("Had inset?! : ");
    Serial.println(mInset);
		if (mInset>0) {
    		insetTLColor = mixColors(&black,50);
    		insetBRColor = mixColors(&white,50);
    	} else {
    		insetTLColor = mixColors(&white,50);
    		insetBRColor = mixColors(&black,50);
    	}

    for (int i=0;i<abs(mInset);i++) {
      screen->drawVLine(x+i,y+i,height-2*i,&insetTLColor);
      screen->drawHLine(x+i,y+i,width-2*i,&insetTLColor);
      screen->drawVLine(x+width-i,y+i,height-i,&insetBRColor);
      screen->drawHLine(x+i,y+height-i,width-i,&insetBRColor);
    }
  }
}


void colorRect::setColor(byte r,byte g,byte b) {

  colorObj::setColor(r,g,b);
  needRefresh = true;
}


void colorRect::setColor(word color16) {

  colorObj::setColor(color16);
  needRefresh = true;
}


void colorRect::setColor(colorObj* inColor) {

  colorObj::setColor(inColor);
  needRefresh = true;
}


colorRect.cpp

#ifndef colorRect_h
#define colorRect_h

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

// A drawObject that is also a colorObject. Ever so handy! Good for backgrounds.
// It can also auto generate an inset border. If that's what your into.

class colorRect : public drawObj,
                  public colorObj {

  public:
            colorRect(void);
            colorRect(rect* inRect,colorObj* inColor,int inset=0);
            colorRect(int inLocX,int inLocY,int inWidth,int inHeight,colorObj* inColor,int inset=0);
            colorRect(int inLocX,int inLocY,int inWidth,int inHeight,int inset=0);
    virtual ~colorRect(void);

    virtual void  setInset(int inset);
    virtual void  drawSelf(void);
    virtual void  setColor(byte r,byte g,byte b);
    virtual void  setColor(word color16);
    virtual void  setColor(colorObj* inColor);

            int   mInset;
};

#endif


colorRect.h

#include "flasher.h"

#define	DEF_FLASH_PERIOD	1000
#define	DEF_FLASH_PULSE	500


// *****************************************************
//                        flasher
// *****************************************************


flasher::flasher(rect* inRect,colorObj* onColor,colorObj* offColor)
  : drawObj(inRect), 
  squareWave() {

	mFlash = false;						// State of the flash, light on or light off.
	setPeriod(DEF_FLASH_PERIOD);		// Setup default period.
	setPulse(DEF_FLASH_PULSE);			// Setup default pulse.
	setColors(onColor,offColor);		// Setup the colors.
}


flasher::flasher(int inX,int inY,int inWidth,int inHeight,colorObj* onColor,colorObj* offColor)
  : drawObj(inX,inY,inWidth,inHeight), 
  squareWave() {
  
	mFlash = false;						// State of the flash, light on or light off.
	setPeriod(DEF_FLASH_PERIOD);		// Setup default period.
	setPulse(DEF_FLASH_PULSE);			// Setup default pulse.
	setColors(onColor,offColor);		// Setup the colors.
}

                     
flasher::~flasher(void) { }


void flasher::setColors(colorObj* onColor,colorObj* offColor) {

	if (onColor) mForeColor.setColor(onColor);	// What is "on"?
	if (offColor) mBackColor.setColor(offColor);	// What is "off"?
	setNeedRefresh();
}


// What to do when pulse goes high.
void flasher::pulseOn(void) {
	
	mFlash = true;
	setNeedRefresh();
}


// What to do when pulse goes low.                                                      
void flasher::pulseOff(void) {

	mFlash = false;
	setNeedRefresh();
}                                                      
   
   
void flasher::drawSelf(void) {

  if (mFlash) {
    screen->fillRect(x,y,width,height,&mForeColor);
  } else {
    screen->fillRect(x,y,width,height,&mBackColor);
  }
}



// *****************************************************
//                     bmpFlasher
// *****************************************************


bmpFlasher::bmpFlasher(int inX,int inY, int width,int height,char* onBmp, char* offBmp)
  : flasher(inX,inY,width,height,&black) { 
 
  mReady = false;
  setup(onBmp,offBmp);
}

    
bmpFlasher::bmpFlasher(rect* inRect,char* onBmpPath, char* offBmpPath)
  : flasher(inRect,&black) { 
  
  mReady = false;
  setup(onBmpPath,offBmpPath);
}  

    
bmpFlasher::~bmpFlasher(void) {

  if (mOnBmp) delete(mOnBmp);
  if (mOffBmp) delete(mOffBmp);
}


void bmpFlasher::setup(char* onBmpPath,char* offBmpPath) {

  mOnBmp = new bmpObj(this,onBmpPath);
  mOffBmp = new bmpObj(this,offBmpPath);
  mReady = mOnBmp && mOffBmp;
}


void bmpFlasher::drawSelf(void) {

  if (mReady) {							// All ducks in row?
    if (mFlash) {							// We want it on?
    	mOnBmp->setLocation(x,y);		// Just in case. 
      mOnBmp->draw();					// Do it.
    } else {								// Or off?
    	mOffBmp->setLocation(x,y);		// Just in case. 
      mOffBmp->draw();					// Do it.
    }
  }
}


flasher.cpp

#ifndef flasher_h
#define flasher_h


// flasher.h contains base classes for flashing things on the screen. Basically a two
// frame sprit that repeats. flasher, flashes a base class drawOnj and bmpFlasher holds
// and swaps two .bmp files.


#include "drawObj.h"
#include <squareWave.h>
#include "bmpObj.h"


// *****************************************************
//                        flasher
// *****************************************************

// flasher is a drawObj that has two states that automatically flip back and forth.
// The default is a two color rectangle changing colors every 1/2 second.

class flasher :	public drawObj,
						public squareWave {

	public:
				flasher(rect* inRect,colorObj* offColor=&black,colorObj* onColor=&red);
				flasher(int inLocX,int inLocY,int inWidth,int inHeight,colorObj* offColor=&black,colorObj* onColor=&red);
					
	virtual	~flasher(void);
	
	virtual	void	setColors(colorObj* onColor,colorObj* offColor);
	virtual	void	drawSelf(void);
	virtual	void	pulseOn(void);                                                   
	virtual	void	pulseOff(void);
	
	protected:
				colorObj		mForeColor;
				colorObj		mBackColor;
				bool			mFlash;
};



// *****************************************************
//                     bmpFlasher
// *****************************************************

// bmpFlasher swaps between two bitmaps instead of a colored rectangle.

class bmpFlasher :  public flasher {
    
	public:
				bmpFlasher(int inX,int inY, int width,int height,char* onBmpPath, char* offBmpPath);
				bmpFlasher(rect* inRect,char* onBmp, char* offBmp);
	virtual	~bmpFlasher(void);

				void	setup(char* onBmpPath, char* offBmpPath);
	virtual	void	drawSelf(void);

				bool		mReady;
            bmpObj*	mOnBmp;
            bmpObj*	mOffBmp;     
};

#endif


flasher.h

#include "iconButton.h"
#include <resizeBuff.h>


// Its a SQUARE icon. Used to be fixed at 32x32 but no..
// Now we want different sizes, don't we?


iconButton::iconButton(int xLoc,int yLoc,char* path,int pix)
	: bmpObj(xLoc,yLoc,pix,pix,path) {
	
	setEventSet(touchLift);
}
	
	
iconButton::~iconButton(void) { }


void iconButton::doAction(void) {  }



iconButton32::iconButton32(int xLoc, int yLoc,char* path)
	: iconButton(xLoc,yLoc,path,32) {  }


iconButton32::~iconButton32(void) {  }



iconButton22::iconButton22(int xLoc, int yLoc,char* path)
	: iconButton(xLoc,yLoc,path,22) {  }


iconButton22::~iconButton22(void) {  }


iconButton.cpp

#ifndef iconButton_h
#define iconButton_h

#include "bmpObj.h"

// Make a button with a 32x32 pixel icon stored in a .bmp file.
// Seeing its expecting a 32x32 pixel file we can simplify a bunch.
//
// Well, so much for fixed size. Now its a square thing of any size.
//
// FINE! Now its any rectangle?! You try to make things simple for people.
// I'll just add some sub classes for the simple cases.
//
// 9/19 - Doing my own icons now. (So there's suddenly a lot of them!) I think I'll take 
// this piece of code and twist it into a multi purpose, icon based, UI thing.



class iconButton :	public bmpObj {

	public:
				iconButton(int xLoc,int yLoc,char* path,int pix=32);
	virtual	~iconButton(void);
	
	virtual	void	doAction(void);
};


// HAVE NOT TESTED THESE YET!!!

class iconButton32 :	public iconButton {

	public:
				iconButton32(int xLoc, int yLoc,char* path);
	virtual	~iconButton32(void);
	
};


class iconButton22 : public iconButton {

	public:
				iconButton22(int xLoc, int yLoc,char* path);
	virtual	~iconButton22(void);
};


#endif

iconButton.h

#include "lineObj.h"

// Default is a black line across the default 16x16 rectangle.
lineObj::lineObj(void) { 

    color.setColor(&black);
    lnSize = 1;
    slope = positiveSlope;
}


lineObj::lineObj(int x1,int y1,int x2,int y2,colorObj* inColor) {

	setColor(inColor);
	setEnds(x1,y1,x2,y2);
}
	

lineObj::~lineObj(void) {  }

	
void lineObj::setColor(colorObj* inColor) {
  
  color.setColor(inColor);
  needRefresh = true;
}


void lineObj::setSize(byte inSize) {

  lnSize = inSize;
  needRefresh = true;
}


void lineObj::setEnds(int x1,int y1,int x2,int y2) {

  point point1;
  point point2;
  
  point1.x = x1;
  point1.y = y1;
  point2.x = x2;
  point2.y = y2;
  setEnds(&point1,&point2);
 }

 
void lineObj::setEnds(point* startPt,point* endPt) {

  setRect(startPt,endPt);
  if (startPt->x == endPt->x) slope = vertical;
  else if (startPt->y == endPt->y) slope = horizontal;
  else if ((x == startPt->x && y == startPt->y)||(x == endPt->x && y == endPt->y)) slope = negativeSlope;
  else slope = positiveSlope;
  needRefresh = true;
}


void lineObj::setEnds(rect* inRect,slopeType inSlope) {

  setRect(inRect);
  slope = inSlope;
  needRefresh = true;
}


void lineObj::drawSelf() {

  /*
  Serial.println("time to draw line.");
  Serial.print("x     : ");Serial.println(locX);
  Serial.print("y     : ");Serial.println(locY);
  Serial.print("width : ");Serial.println(width);
  Serial.print("height: ");Serial.println(height);
  */
  switch(slope) {
    case vertical : screen->drawVLine(x,y,height,&color); break;
    case positiveSlope : screen->drawLine(x,y-height,x+width,y,&color); break;
    case negativeSlope : screen->drawLine(x,y,x+width,y-height,&color); break;
    case horizontal : screen->drawHLine(x,y,width,&color); break;
  }
}




lineObj.cpp

#ifndef lineObj_h
#define lineObj_h

#include "drawObj.h"

enum slopeType { vertical, positiveSlope, negativeSlope, horizontal };

class lineObj : public drawObj {

public:
             lineObj(void);
  			 lineObj(int x1,int y1,int x2,int y2,colorObj* inColor);
	virtual	~lineObj(void);
	
				void	setColor(colorObj* inColor);
				void	setSize(byte inSize);                      // line width. Sadly, unsuported.
				void	setEnds(int x1,int y1,int x2,int y2);
				void	setEnds(point* startPt,point* endPt);
				void	setEnds(rect* inRect,slopeType inSlope);
	virtual	void	drawSelf();
  
  				colorObj	color;
  				byte		slope;    // We already have a rectangle. This notes which diagonal.
  				byte		lnSize;
};

#endif


lineObj.h

#include "baseImage.h"

// Just setup default values..
baseImage::baseImage(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. (n 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(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

#include "bmpImage.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 two routines swap 'em back.

// 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(char* newPath,int inWidth,int inHeight) {

	File		bmpFile;
	bool		success;
	uint32_t	pixBytes;
	uint32_t	bytesPerRow;
	uint32_t	fileSize;
	uint32_t	imageBytes;
	
	Serial.println("createNewBmpFile");
	success = false;															// Ok, assume failure..									
	bmpFile = SD.open(newPath,FILE_WRITE);								// See if its a valid path.
	if (bmpFile) {    														// We got a file?
		Serial.println("Got .bmp file");
		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 sees to be 54. Size of header?
		write32(40,bmpFile);													// DIB Header size. Always seems to be 40.
		write32(inWidth,bmpFile);											// Width.
		write32(inHeight,bmpFile);											// Height.
		write16(1,bmpFile);													// It wants a one here. Why? Its a mystery to me.
		write32(DEF_DEPTH,bmpFile);										// We're going for 32 bit image stuff here.
		write32(0,bmpFile);													// No compression.
		imageBytes = bytesPerRow * inHeight;							// Calc. total image bytes.
		for (uint32_t i=0;i<imageBytes;i++) {							// For every bloody byte of pixel data..
			bmpFile.write(255);												// Fill image space with white.
		}
		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(char* filePath)
	: baseImage(filePath) {  }


bmpImage::~bmpImage(void) {  }


// 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;
	
	if (mode != fClosed) {							// If we are not closed. IE valid open file.
		index = fileIndex(x,y);						// Do the math for this pixel index.
		if (index != ourFile.position()) {		// If we are NOT already there..
			ourFile.seek(index);						// Point the file to our pixel.
		}
		ourFile.read(buf,pixBytes);				// Grab the pixel.
		aPack.r = buf[2];								// Stuff the pack.
		aPack.g = buf[1];
		aPack.b = buf[0];
	}
	return aPack;
}


// Given an RGBpack, set this pixel in the temp image file to that color.
// THIS is the one that should be inherited and filled out.
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 != ourFile.position()) {			// If we are NOT already there..
			ourFile.seek(index);							// Point the file to our pixel.
		}
		ourFile.write(anRGBPack->b);					// Write out the values.
		ourFile.write(anRGBPack->g);
		ourFile.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.
	int32_t	fileSize;
	int16_t	imageDepth;
	bool		success;
	
	success = false;													// Ok, assume failure..									
	if (read16(bmpFile) == 0x4D42) {								// If we have something or other..
		fileSize = read32(bmpFile);								// We grab the file size.
		creatorBits = read32(bmpFile);							// Creator bits
		imageOffset = read32(bmpFile);							// image offset.
		DIBHeaderSize = read32(bmpFile);							// read DIB header size?
		width = read32(bmpFile);									// width? Good thing to save for later.
		imageHeight = read32(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.
		if (read16(bmpFile) == 1) {								// if the next word is 1? What's this mean? Needs to be though.
			imageDepth = read16(bmpFile);							// color depth.
			if (imageDepth == 24 || imageDepth == 32) {		// We can do 24 or 32 bits..
				pixBytes = imageDepth / 8;							// Bytes / pixel
				if (!read32(bmpFile)) {								// 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

#ifndef bmpImage_h
#define bmpImage_h

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


extern bool createNewBmpFile(char* newPath,int inWidth,int inHeight);

class bmpImage :	public baseImage {

	public:
				bmpImage(char* filePath);
	virtual	~bmpImage(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:
	
				bool		rightSideUp;
				int32_t	imageOffset;
				int16_t	pixBytes;
				int32_t	bytesPerRow;
};

#endif

bmpImage.h

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

#define TEMP_NAME_CHARS		8	// The max num chars for the temp file name 9999.tmp
#define PATH_MIN_CHARS		6	// Min chars is /X.tmp
#define DEF_LOSE_EDIT_MSG	"Closing this file will cause you to loose these unsaved changes. Continue?"

char*	tempDir = NULL;

// Called to setup the temp directory. If there is one already set up it juts falls
// through and returns true as a success. This is called automatically when needed and it
// will use the default folder name. If you want a different location, you can call this
// in setup() with a different name and all your document files will use that.
bool createTempDir(char* inPath) {

	File	theDir;
	int	numChars;
	bool	addSlash;
	bool	success;
	char*	dirPath;
	
	if (tempDir) return true;							// If there already is a temp directory set up, bail!
	if (inPath) {
		dirPath = NULL;
		if (resizeBuff(strlen(inPath)+1,&dirPath)) {
			strcpy(dirPath,inPath);
			addSlash = false;
			success = false;
			// WAIT!! Patching bug here. If you pass name/ and it fails, it crashes! No '/' no crash.
			numChars = strlen(dirPath);                  // Lets see how long the path is.
			if (dirPath[numChars-1]=='/') {					// If it has has a traileing '/'..            
				dirPath[numChars-1]='\0';						// Clip off the trailing '/'.
			} 
			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..
				if (theDir.isDirectory()) {               // If its a directory..
					numChars = strlen(dirPath);            // Lets see how long the path is now.
					if (resizeBuff(numChars+2,&tempDir)) {	// If we can allocate the tempDir path string..
						strcpy(tempDir,dirPath);				// Copy in the path we got.
						strcat(tempDir,"/");						// Plus the '/' we pulled off of it.
						success = true;							// Note our success.
					}
				}
				theDir.close();									// Close the directory we opened.
			} else {													// Else, there was no directory of that name..
				if (SD.mkdir(dirPath)) {						// If we can create the directory.
					numChars = strlen(dirPath);            // Lets see how long the path is.
					if (dirPath[numChars-1]!='/') {			// If we DON'T have a traileing '/'.. 
						numChars++;									// Add one for the '/'.
						addSlash = true;							// Note that we'll need to add a '/'.
					}
					if (resizeBuff(numChars+1,&tempDir)) {	// If we can allocate the tempDir path string..
						strcpy(tempDir,dirPath);				// Copy in the path we got.
						if (addSlash) strcat(tempDir,"/");	// Plus the '/' if it was missing.
						success = true;							// Note our success.
					}
				}
			}
			resizeBuff(0,&dirPath);
		}
	}
	return success;
}


// TOTAL HACK TO GET AROUND NO FILE truncate() CALL..
File TRUNCATE_FILE(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.
							

// 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.
	// AND THERE YOU GO..
	
	remaingBytes = src.size();
	for (int i=0;i<cpyBuff.numPasses;i++) {
		numBytes = min(cpyBuff.numBuffBytes,remaingBytes);
		src.read(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) {
	
	uint32_t	filePos;
	uint32_t	numBytes;
	
	numBytes = dest.size();					// How many bytes we talking here?
	dest.seek(numBytes);						// 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.
	while(src.available()) {				// While not at the end of the src file..
		dest.write(src.read());				// Write the data of the dest file.
	}
	src.seek(filePos);						// Put it back like we found it.					
}



// ************************************************************
// ********************  docFileObj class  ********************
// ************************************************************


// A docFile object MUST have a path to exist. 	
docFileObj::docFileObj(char* filePath) {
	
	int numBytes;
	
	docFilePath		= NULL;								// Dynamic things start at NULL.
	editFilePath	= NULL;								// Dynamic things start at NULL.
	mode 				= fClosed;							// We are NOT editing at the moment.
	if (filePath) {										// If we have	a a file path. (Sanity, we'd better!)
		numBytes = strlen(filePath)+1;				// Calculate the number of bytes to store it.
		if (resizeBuff(numBytes,&docFilePath)) {	// If we get the RAM to store it..
			strcpy(docFilePath,filePath);				// Save the path.
		}
	}						
}


docFileObj::~docFileObj(void) {

	closeDocFile();						// Close files and Recycle the editFile stuff.
	resizeBuff(0,&docFilePath);		// Recycle the docFilePath.
}


// 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 past 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 if (mode==fOpenToEdit||mode==fEdited) {				// We're in the middle of editing..
				closeDocFile();														// We try to close the file to open later.
				if (mode!=fClosed) {												// IF the file is NOT been closed..
					return false;													// They didn't close it, Lets bolt!
				}
			}
			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 past 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.
bool docFileObj::saveDocFile(char* newFilePath) {
	
	File	tempFile;
	bool	success;
	
	success = false;													// Not a success yet.
	if (mode==fEdited || mode==fOpenToEdit) {					// If we are using an editFile..
		if (newFilePath) {											// If we have a new path to save to..
			tempFile = SD.open(newFilePath,FILE_WRITE);		// Have a go at opening the 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);
				
				
				fcpy(tempFile,ourFile);								// Copy the edited file to the new file.
				tempFile.close();										// Close the new file.
				mode = fOpenToEdit;									// Clear the "dirty" flag, if any.
				success = true;										// Success!								
			} 
		} else {															// Else, no path was given. Store edit to doc file.
			tempFile = SD.open(docFilePath,FILE_WRITE);		// Have a go at opening the doc file path.
			if (tempFile) {											// If we were able to open the file..
				
				tempFile.close();											// Close the file. We know we can open it.
				tempFile = TRUNCATE_FILE(docFilePath);
				
				fcpy(tempFile,ourFile);								// Copy the editing file to the original file.
				tempFile.close();										// Close the original file.
				mode = fOpenToEdit;									// Clear the "dirty" flag, if any.
				success = true;										// And we are a success!
			}
		}
	} else if (mode==fOpenToRead && newFilePath) {			// If open to read AND we have a new path to save to..												// Set the pointer to byte 0.
		tempFile = SD.open(newFilePath,FILE_WRITE);			// Have a go at opening the 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);
			
			fcpy(tempFile,ourFile);									// Copy the original file to the new file.
			tempFile.close();											// Close the new file.
			success = true;											// And again, we are a success!
		}
	}
	return success;			
}


// Ask this question in such a way that if ok, it will return true;
bool docFileObj::askOk(char* qStr) { return true; }


// 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) {
		case fClosed		: break;
		case fOpenToRead	:
			ourFile.close();
			mode = fClosed;
		break;
		case fOpenToEdit	:
			ourFile.close();
			SD.remove(editFilePath);
			resizeBuff(0,&editFilePath);
			mode = fClosed;
		break;
		case fEdited :
			if (askOk(DEF_LOSE_EDIT_MSG)){
				ourFile.close();
				SD.remove(editFilePath);
				resizeBuff(0,&editFilePath);
				mode = fClosed;
			}
		break;
	}
}


bool docFileObj::changeDocFile(char* newPath) {

	int	numBytes;
	
	if (mode==fClosed) {											// If the file is closed.
		if (newPath) {												// If we have	a new file path. (Sanity, we'd better!)
			numBytes = strlen(newPath)+1;						// Calculate the number of bytes to store it.
			if (resizeBuff(numBytes,&docFilePath)) {		// If we get the RAM to store it..
				strcpy(docFilePath,newPath);					// Save the path.
				return true;										// Success!
			}
		}
	}
	return false;													// You fail!
}


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; }


// This finds a unused file name in the tempFolder then checks to make sure it can be
// created/opened. Once this is accomplished, it closes the tempFile saves off the path to
// this file and returns its success or failure.
bool docFileObj::createEditPath(void) {
	
	File		tempFile;
	timeObj	timeOut(FILE_SEARCH_MS);
	char*		pathBuff;
	char		fileNumStr[TEMP_NAME_CHARS];
	int		fileNum;
	int		numBytes;
	bool		done;
	bool		success;
	
	if (editFilePath) return true;										// If we already have a temp path set up? Bail.
	success = false;															// As always, not a success yet.
	
	if (createTempDir(TEMP_FOLDER)) {									// Ok we don't have a temp path. So, if we have or can create a temp directory..
		pathBuff = NULL;														// Start it at NULL so resizeBuff will work correctly.
		numBytes = strlen(tempDir)+TEMP_NAME_CHARS + 1;				//	Calculate the max RAM we'll need for the path buff.
		if (resizeBuff(numBytes,&pathBuff)) {							// If we can allocate the RAM.
			done = false;														// Not done yet.
			fileNum = 0;														// File names are a number string with ".tmp" at the end.
			do {																	// We loop around doing..
				strcpy(pathBuff,tempDir);									//	Start building the file path with the temp directory.
				itoa(fileNum++,fileNumStr,10);							// Create a number string.
				strcat(pathBuff,fileNumStr);								// Add the file num to the path.
				strcat(pathBuff,".tmp");									// Add ".tmp" to the path.
				tempFile = SD.open(pathBuff,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(pathBuff,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.
						numBytes = strlen(pathBuff)+1;					// Grab the num chars of the path +1.
						if (resizeBuff(numBytes,&editFilePath)) {		// If we can allocate the editFilePath c string..
							strcpy(editFilePath,pathBuff);				// Save off the path that worked.	
							success = true;									// And We'll call that a success!
						}
					}
				}
			} while(!done && !timeOut.ding());							// Loop while we are not done. (And have time)
			resizeBuff(0,&pathBuff);										// Recycle the build-a-path buffer.
		}
	}
	return success;															// return if we had success or not.
}





										
					


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 <Arduino.h>
#include <SD.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.

bool createTempDir(char* dirPath);
	
class docFileObj {

	public:
					enum fileModes { fClosed, fOpenToEdit, fEdited, fOpenToRead };
	
					docFileObj(char* filePath);
	virtual		~docFileObj(void);
	
	virtual		bool		openDocFile(int openMode);
	virtual		bool		saveDocFile(char* newFilePath=NULL);
	virtual		bool		askOk(char* qStr);
					void		closeDocFile(void);
					bool		changeDocFile(char* newPath);
					
					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;	
					char*			docFilePath;
					char*			editFilePath;
					File			ourFile;
					
							
};


#endif

docFileObj.h

#ifndef ourOSObj_h
#define ourOSObj_h

#include "lilOS.h"

enum  apps { homeApp = HOME_PANEL_ID, calcApp, breakoutApp };

class ourOSObj : public lilOS {

   public:
           ourOSObj(void);
   virtual ~ourOSObj(void);
  
   virtual  int      begin(void);                     // The hardware is online, do hookups.
   virtual  panel*   createPanel(int panelID);        // We need to write our own panel creation method.
   virtual  void     beep(void);                      // Only WE know how to make it beep.
   virtual  int      getTonePin(void);
   virtual  void     setBrightness(byte brightness);  // 0 for full bright 255 for off.
   virtual  char*    getSystemFolder(void);
   virtual  char*    getPanelFolder(int panelID);
};

extern ourOSObj   ourOS;
extern bmpMask    iconMask;

#endif


ourOSObj.h

#include "ourOSObj.h"
#include "rpnCalc.h"
#include "breakout.h"
#include "homeScr.h"

#define BEEP_PIN     14                      // The digital pin choosen for the beeper.
#define SCREEN_PIN   A0                      // The ananlog pin choosen for the screen backlight.
char systemFolder[]  = "/system/";           // Where we decided to store the systemp folder on our SD card.
char panelFolder[]   = "/system/appFiles/";  // Where we decided to store the app folders on our SD card.

// Our OS object.
ourOSObj  ourOS;

bmpMask  iconMask;

// **************************************
// ************** ourOSObj **************
// **************************************


ourOSObj::ourOSObj(void)
   : lilOS() { }


ourOSObj::~ourOSObj(void) {  }


// The hardware is online, do hookups.
int ourOSObj::begin(void) {
   
   pinMode(BEEP_PIN, OUTPUT);       // Setup The beeper pin.
   digitalWrite(BEEP_PIN, HIGH);    //Means off.
   setBrightness(255);
   iconMask.readFromBMP("/system/icons/standard/mask32.bmp");
   return lilOS::begin();          // Return result of the inherited
}


// We need to write our own panel creation method.
panel* ourOSObj::createPanel(int panelID) {
   
   beep();
   //setBrightness(0);
   switch (panelID) {
      case homeApp      : return new homeScr();
      case calcApp      : return new rpnCalc(this,panelID);
      case breakoutApp  : return new breakout(this,panelID);
      default           : return NULL;
   }
}


// Only WE know how to make it beep.
void ourOSObj::beep(void) { tone(BEEP_PIN, 750,20); }


// Here's the pin if you want to use it yourself.
int ourOSObj::getTonePin(void) {return BEEP_PIN; }


// And how to control the screen brightness.
void ourOSObj::setBrightness(byte brightness) { analogWrite(SCREEN_PIN,brightness); }

char*  ourOSObj::getSystemFolder(void) { return systemFolder; }


// Hand this an appID and get back a pointer to the path of its data folder.
char* ourOSObj::getPanelFolder(int panelID) {
     
   strcpy(pathBuff,panelFolder);
   switch (panelID) {
      case homeApp      : return NULL;
      case calcApp      : 
         strcat(pathBuff,"rpnCalc/");
         return pathBuff;
      break;
      case breakoutApp  :
         strcat(pathBuff,"breakout/");
         return pathBuff;
      break;
      default           : return NULL;
   }
}


ourOSObj.cpp

#ifndef homePanel_h
#define homePanel_h

#include "ourOSObj.h"
#include "bmpObj.h"


// *****************************************************
//                        homeScr
// *****************************************************


class homeScr : public panel {

   public:
            homeScr(void);
   virtual  ~homeScr(void);

            char* iconPath(int appID,char* iconName);
   virtual  void  setup(void);
   virtual  void  loop(void);
   virtual  void  drawSelf(void);

            char  pathBuff[80];
};



#endif


homeScr.h

#include "homeScr.h"
#include "lilOS.h"

#define TOP_Y     286
#define STEP_Y    52
#define LEFT_X    78
#define STEP_X    52


homeScr::homeScr(void)
   : panel(&ourOS,homeApp,noMenuBar) { }

   
homeScr::~homeScr(void) {  }


char* homeScr::iconPath(int appID,char* iconName) {

   strcpy(pathBuff,mOSPtr->getPanelFolder(appID));
   strcat(pathBuff,iconName);
   return pathBuff; 
}



void homeScr::setup(void) {
   
   int      traceY;
   int      traceX;
   appIcon* theAppIcon;
   
   traceX = LEFT_X;
   traceY = TOP_Y;
   
   theAppIcon = new appIcon(traceX,traceY,calcApp,iconPath(calcApp,"calc32.bmp"));
   theAppIcon->setMask(&iconMask);
   addObj(theAppIcon); 
  
   traceX = traceX + STEP_X;
   theAppIcon = new appIcon(traceX,traceY,breakoutApp,iconPath(breakoutApp,"breakout.bmp"));
   theAppIcon->setMask(&iconMask);
   addObj(theAppIcon);

}


void homeScr::loop(void) { }


void homeScr::drawSelf(void) { 

   colorObj aColor;
   bmpObj   theScreenImage(0,0,240,282,"/system/images/lake.bmp");

   aColor.setColor(LC_CHARCOAL);
   aColor.blend(&white,20);
   screen->fillRectGradient(0,282,240,38,&aColor,&black);
   aColor.setColor(&blue);
   aColor.blend(&black,40);
   screen->fillRectGradient(0,0,240,320-38,&black,&aColor);
   screen->drawHLine(0,280,240,&white);
   screen->drawHLine(0,281,240,&black);
   screen->drawHLine(0,282,240,&black);
   //theScreenImage.draw();
   //
   //screen->fillRect(20,20,40,40,&green);
}


homeScr.cpp


#include "lilOS.h"
#include "screen.h"

int	nextPanel = NO_PANEL_ID;   // What panel do we want showing now?

// *****************************************************
// ********************   appIcon  *********************
// *****************************************************


appIcon::appIcon(int xLoc,int yLoc,int message,char* path,int pix)
  : iconButton(xLoc,yLoc,path,pix) { mMessage = message;}

  
appIcon::~appIcon(void) { }


void appIcon::doAction(void) { nextPanel = mMessage; }



// *****************************************************
// *******************     panel    ********************
// *****************************************************


// And it all starts up again..
panel::panel(lilOS* ourOS,int panelID,menuBarChoices menuBarChoice,eventSet inEventSet)
  : drawGroup(0,0,PANEL_WIDTH,PANEL_HEIGHT,inEventSet) {
  
  	mOSPtr	= ourOS;									// Save a pointer to our OS object.
	mPanelID = panelID;								// Save what "kind" of panel we are.
	mMenuBar = NULL;									// Default to NULL.
	switch (menuBarChoice) {						// Lets see what kind of bar they wish for?
		case noMenuBar			: break;				// None? Fine, we go now.
		case emptyMenuBar		: 						// Now, panels are created by the O.S. during runtime.
			mMenuBar = new menuBar(this,false);	// Meaning, everything is up and running.
			addObj(mMenuBar);							// So, this call will be fine.
		break;	
		case closeBoxMenuBar	:						// Just like the one above.
			mMenuBar = new menuBar(this);			// Default is to have the close box. (Most do)	
			addObj(mMenuBar);
		break;
	}
}


// The world as you know it, is ending..
panel::~panel(void) { }


// Whom ever is managing panels can assign IDs to us for
// their nefarious plans. Here's where we hand it back.
int panel::getPanelID(void) { return mPanelID; }


// setup() & loop() panel style.
void panel::setup(void) { }


void panel::loop(void) {  }


// The default here is to not draw ourselves. You can change that.
void panel::drawSelf(void) {  }


// Call this when its time to close the panel. Default is to go back
// to the home panel. Maybe you want to link to another from time to time?
void panel::close(void) { nextPanel = HOME_PANEL_ID; }


// Whereas you call close() when you are complete and want to close.. Sometimes
// you don't have control of that. So? No matter if you call close, or something
// else calls close on you, this gets called so you can clean up before being
// deleted.
void panel::closing(void) {  }


// *****************************************************
// *******************   homePanel  ********************
// *****************************************************


homePanel::homePanel(lilOS* ourOS)
  : panel(ourOS,HOME_PANEL_ID,noMenuBar) { } // Home panels have no panel to return to.


homePanel::~homePanel(void) {  }


void homePanel::setup(void) {  }


void homePanel::loop(void) {  }


void homePanel::drawSelf(void) {

	screen->fillScreen(&white);
	screen->setCursor(5,25);
	screen->setTextColor(&black,&white);
	screen->drawText("Default home panel");
	}



// *****************************************************
// *********************   lilOS   ********************
// *****************************************************

 
lilOS::lilOS(void) {

  mPanel = NULL;
  nextPanel = HOME_PANEL_ID;
}


lilOS::lilOS(int homeID) {

  mPanel = NULL;
  nextPanel = homeID;
}


lilOS::~lilOS(void) {  }


// A good plan would be to inherit, do your begin
// then at some point during that, call this one.
int lilOS::begin(void) {

  hookup();							// Want to use idle()? Its ready.
  nextPanel = HOME_PANEL_ID;	// Set to the default home panel.
  return 0;							// 0 means no error right? Or does it mean false, fail?
}


// This is the guy you inherit and use to create your custom panels.
panel* lilOS::createPanel(int panelID) { return new homePanel(this); }


void lilOS::launchPanel(void) {

	while(screen->touched());							// Hold 'till their finger is off the screen. Its important!
	if (mPanel) {											// If we have a panel now..
		mPanel->closing();								// Give the panel one last chance to get its affairs in order.
		delete mPanel;										// Delete the panel.
		mPanel = NULL;										// Flag it. Just in case..
	}
	if (nextPanel!=NO_PANEL_ID) {						// Someone wants a panel.
		mPanel = createPanel(nextPanel);				// See if they can create it.
		if (mPanel) {										// So, we get a panel in the end?
			viewList.addObj(mPanel);					// Hook it up to the global viewList to allow drawing etc.
			mPanel->setup();								// Give it its setup() call. (Just like back home!)
			mPanel->hookup();								// Hookup idle stuff as well.
		} else {
			nextPanel = HOME_PANEL_ID;					// If we could not create a panel, send 'em home.
		}
	}
}


// Tell the current panel its loop time.
void lilOS::loop(void) {
	
	if(!mPanel && nextPanel!=(unsigned int)mPanel) {	// If have no panel and we want one.
		launchPanel();												// Launch a new panel.
	} else if(nextPanel!=mPanel->getPanelID()) {			// Else, if we just want a change of panels.
		launchPanel();												// Launch the new panel.
	}
	if (mPanel) { mPanel->loop(); }							// As always, if there is a panel, let it have some loop time.
}


char* lilOS::stdIconPath(stdIcons theIcon) {
	
	strcpy(pathBuff,getSystemFolder());
	strcat(pathBuff,"icons/standard/");
	switch(theIcon) {
		case app32 		: strcat(pathBuff,"app32.bmp"); 		break;
		case check22 	: strcat(pathBuff,"check22.bmp"); 	break;
		case check32 	: strcat(pathBuff,"check32.bmp"); 	break;
		case copy32 	: strcat(pathBuff,"copy32.bmp"); 	break;
		case cross22 	: strcat(pathBuff,"cross22.bmp"); 	break;
		case cross32 	: strcat(pathBuff,"cross32.bmp"); 	break;
		case cut32 		: strcat(pathBuff,"cut32.bmp"); 		break;
		case edit22 	: strcat(pathBuff,"edit22.bmp"); 	break;
		case edit32 	: strcat(pathBuff,"edit32.bmp"); 	break;
		case fSave22	: strcat(pathBuff,"fSave22.bmp"); 	break;
		case fSave32	: strcat(pathBuff,"fSave32.bmp"); 	break;
		case fOpen22 	: strcat(pathBuff,"fOpen22.bmp"); 	break;
		case fOpen32 	: strcat(pathBuff,"fOpen32.bmp"); 	break;
		case mask22 	: strcat(pathBuff,"mask22.bmp"); 	break;
		case mask32 	: strcat(pathBuff,"mask32.bmp"); 	break;
		case paste32 	: strcat(pathBuff,"paste32.bmp"); 	break;
		case pref22 	: strcat(pathBuff,"pref22.bmp");		break;
		case pref32 	: strcat(pathBuff,"pref32.bmp"); 	break;
		case search22	: strcat(pathBuff,"search22.bmp"); 	break;
		case search32	: strcat(pathBuff,"search32.bmp"); 	break;
		case sort22		: strcat(pathBuff,"sort22.bmp"); 	break;
		case sort32		: strcat(pathBuff,"sort32.bmp"); 	break;
		case trashC22	: strcat(pathBuff,"trashC22.bmp"); 	break;
		case trashC32	: strcat(pathBuff,"trashC32.bmp"); 	break;
		case trashR22	: strcat(pathBuff,"trashR22.bmp"); 	break;
		case trashR32	: strcat(pathBuff,"trashR32.bmp"); 	break;
		case x22			: strcat(pathBuff,"x22.bmp"); 		break;
		case x32			: strcat(pathBuff,"x32.bmp"); 		break;
	}
	return pathBuff;
}

lilOS.cpp

#ifndef lilOS_h
#define lilOS_h

#include "iconButton.h"
#include "drawObj.h"
#include "menuBar.h"

// Look, just start your numbering at 2 alright?
#define	NO_PANEL_ID		0		// You have to have this guy.
#define	HOME_PANEL_ID	1

#define	PATH_LEN			100	// Size of buffer for creating file paths.

// The list of standard icons supplied by the OS for the applications to use.
enum stdIcons	{
	app32, check22, check32, copy32, cross22, cross32, cut32, edit22, edit32, fSave22,
	fSave32, fOpen22, fOpen32, mask22, mask32, paste32, pref22, pref32, search22, search32,
	sort22, sort32, trashC22, trashC32, trashR22, trashR32, x22, x32
};
						
						
						
// The user will expect icons to click on for panel swapping.
// You can use this. Give it a panel ID and a full path to a
// 32x32 bit .bmp file. Use these to populate your home panel,
// and it does the rest.

class appIcon : public iconButton {
  
  public:
          appIcon(int xLoc,int yLoc,int message,char* path,int pix=32);	// Path to .bmp icon dwg.
  virtual ~appIcon(void);
  
  virtual void  doAction(void);

          int  mMessage;
};

// The base panel class

// The panel object. Base class for swapping in and out of different objects
// that want to use the screen. The plan is that the OS can swap panels back
// and forth as the user chooses different things he wants to do. Like
// different apps. Each panel has its own setup() and loop() functions you can
// fill in to pretend your in a "real" sketch. Wow, just like a real boy!

enum menuBarChoices { noMenuBar, emptyMenuBar, closeBoxMenuBar };


// These two have to go. Need to bring these out from
// the displayObj. But, I'm in a hurry and I'm lazy.
#define PANEL_WIDTH   240
#define PANEL_HEIGHT  320

class menuBar;
class lilOS;

class panel : public drawGroup {

	public:
				panel(lilOS* ourOS,int panelID,menuBarChoices menuBarChoice=closeBoxMenuBar,eventSet inEventSet=noEvents);
	virtual	~panel(void);
	
				int	getPanelID();
	virtual	void	setup(void);
	virtual	void	loop(void);
	virtual	void	drawSelf(void);
	virtual	void	close(void);
	virtual	void	closing(void);
  
				lilOS*	mOSPtr;		// Pointer to our OS.
				int		mPanelID;   // What panal am I?
				menuBar*	mMenuBar;	// My menu bar, if so desired.
};


// Default home panel with panelID of HOME_PANEL_ID
class homePanel : public panel {

  public:
          homePanel(lilOS* ourOS);
  virtual ~homePanel(void);
  
  virtual void  setup(void);
  virtual void  loop(void);
  virtual void  drawSelf(void);
    
};


// Our base class for a little OS that switches "panels"
// for user interaction. These panels can be thought of
// as virtual Arduino sketches. Meaning? Everything on
// them must be able to "survive" being deleted when the
// user switches functions. You'll be able to get more
// info in the "panel" files.
class lilOS :  public idler {

	public:
				lilOS(void);
				lilOS(int homeID);
	virtual	~lilOS(void);

	virtual	int		begin(void);					// The global world is online, do hookups. Returns 0, always
	virtual	panel*	createPanel(int panelID);	// INHERIT THIS GUY AND CREATE YUR OWN CUSTOM PANELS.
	virtual	void		launchPanel(void);			// Dispose of current and launch a newly created panel.
	virtual	void		loop(void);						// Tell the current panel its loop time.
	
	// Calls to be overwritten by used version.
	virtual	void		beep(void) = 0;
	virtual	int		getTonePin(void) = 0;
	virtual	void		setBrightness(byte brightness) = 0;
	virtual	char*		getSystemFolder() = 0;
	virtual	char*		getPanelFolder(int panelID) = 0;
	virtual	char*		stdIconPath(stdIcons theIcon);
	
				char		pathBuff[PATH_LEN];			// Workspace for building up file paths.
				panel*	mPanel;
};

extern  int nextPanel;

#endif


lilOS.h

#include "menuBar.h"
#include "lilOS.h"
#include "iconButton.h"
#include <resizeBuff.h>

colorObj	menuBarColor(LC_BLACK);

// *****************************************************
// 							 menueBar
// *****************************************************


menuBar::menuBar(panel* inPanel,bool closeBox)
  : drawGroup(0,0,PANEL_WIDTH,MENU_BAR_H) {
    
  closeBtn*   ourCloseBtn;
  
  mPanel = inPanel;
  if (closeBox) {
    ourCloseBtn = new closeBtn(mPanel);
    addObj(ourCloseBtn);
  }
}


menuBar::~menuBar(void) {  }



void menuBar::drawSelf(void) { screen->fillRect(this,&menuBarColor); }



// *****************************************************
// 							std buttons
// *****************************************************


closeBtn::closeBtn(panel* inPanel)
  : iconButton(CLOSE_X,CLOSE_Y,inPanel->mOSPtr->stdIconPath(x22),22) {
  
  mPanel = inPanel;
 }


closeBtn::~closeBtn(void) {  }


void closeBtn::doAction(void) { mPanel->close(); }



// ******


newBtn::newBtn(panel* inPanel,int x,int y)
  : iconButton(x,y,inPanel->mOSPtr->stdIconPath(cross22),22)  { 
  
  mPanel = inPanel;
}

   
newBtn::~newBtn(void) {  }



// *****


searchBtn::searchBtn(panel* inPanel,int x,int y)
  : iconButton(x,y,inPanel->mOSPtr->stdIconPath(search22),22)  {
  
  mPanel = inPanel;
}
 
    
searchBtn::~searchBtn(void) {  }



// *****


trashBtn::trashBtn(panel* inPanel,int x,int y)
  : iconButton(x,y,inPanel->mOSPtr->stdIconPath(trashC22),22)  {
  
  mPanel = inPanel;
}


trashBtn::~trashBtn(void) {  }




menuBar.cpp

#ifndef menuBar_h
#define menuBar_h

#include "drawObj.h"
#include "iconButton.h"

#define MENU_BAR_H    24  // Because we have 22x22 icos to stick on it. So there!
	
#define CLOSE_X         0
#define CLOSE_Y         1
#define CLOSE_W         22
#define CLOSE_H         22

extern colorObj	menuBarColor;

	
// *****************************************************
//								menueBar
// *****************************************************

class panel;

class menuBar  : public drawGroup {

  public:
            menuBar(panel* inPanel,bool closeBox=true);
    virtual ~menuBar(void);

    virtual void    drawSelf(void);

            panel*  mPanel;
};



// *****************************************************
// 						std buttons
// *****************************************************

// these are the little 22x22 pix buttons that do functions like make a call,
// text someone, new document, delete current document. An entire grab bag of functons.


class closeBtn : public iconButton {

  public:
				closeBtn(panel* inPanel);
  virtual	~closeBtn(void);
  
  virtual	void  doAction(void);
  
				panel* mPanel;
};


class newBtn : public iconButton {

  public:
				newBtn(panel* inPanel,int x,int y);
  virtual	~newBtn(void);
  
				panel* mPanel;
};


class searchBtn : public iconButton {

  public:
				searchBtn(panel* inPanel,int x,int y);
  virtual	~searchBtn(void);
  
				panel* mPanel;
};


class trashBtn : public iconButton {

  public:
				trashBtn(panel* inPanel,int x,int y);
  virtual	~trashBtn(void);
				
				panel* mPanel;
};


#endif

menuBar.h

#include "calcButton.h"
#include "calculator.h"
#include "lilOS.h"

#include "rpnCalc.h"

#define TEXT_SIZE     2
#define CHAR_WIDTH    6
#define BUTTON_HEIGHT 18
#define RADIUS        3

extern calculator mCalc;
extern bool       buttonPressed;
       bool       gSecondFx = false;
extern int			nextPanel;

colorObj numberActiveBColor;
colorObj numberActiveTColor;
colorObj numberClickedBColor;
colorObj numberClickedTColor;

colorObj editActiveBColor;
colorObj editActiveTColor;
colorObj editClickedBColor;
colorObj editClickedTColor;

colorObj fxActiveBColor(LC_BLACK);
colorObj fxActiveTColor;
colorObj fxClickedBColor;
colorObj fxClickedTColor;


void setupButtonColors(void) {

  numberActiveBColor.setColor(LC_WHITE);
  numberActiveTColor.setColor(LC_BLACK);
  numberClickedBColor.setColor(LC_BLACK);
  numberClickedTColor.setColor(LC_WHITE);
  
  editActiveBColor.setColor(LC_BLUE);
  editActiveTColor.setColor(LC_WHITE);
  editClickedBColor.setColor(LC_WHITE);
  editClickedTColor.setColor(LC_BLACK);
  
  fxActiveBColor.setColor(LC_BLACK);
  fxActiveTColor.setColor(LC_WHITE);
  fxClickedBColor.setColor(LC_WHITE);
  fxClickedTColor.setColor(LC_BLACK);

  numberActiveBColor.blend(&black, 40);
  numberActiveBColor.blend(&yellow, 25);
  numberActiveTColor.blend(&black, 60);
  editActiveBColor.blend(&white, 40);
  fxActiveBColor.blend(&white, 20);
}


calcButton::calcButton(char* inFStr, word inLocX, word iny, byte width, byte inType)
  : drawObj(inLocX, iny, width, BUTTON_HEIGHT, touchLift) {

  int numChars = strlen(inFStr) + 1;
  fStr = (char*) malloc(numChars);
  strcpy(fStr, inFStr);
  bType = inType;
  aFStr = NULL;
  secondFx = false;
}


calcButton::calcButton(char* inFStr, char* inAFStr, word inLocX, word iny, byte width, byte inType)
  : drawObj(inLocX, iny, width, BUTTON_HEIGHT, touchLift) {

  int numChars = strlen(inFStr) + 1;
  fStr = (char*) malloc(numChars);
  strcpy(fStr, inFStr);

  numChars = strlen(inAFStr) + 1;
  aFStr = (char*) malloc(numChars);
  strcpy(aFStr, inAFStr);
  
  bType = inType;
  secondFx = false;
}

calcButton::~calcButton(void) {

  if (fStr) free(fStr);
  if (aFStr) free(aFStr);
}


void calcButton::idle(void) {

  if (aFStr && gSecondFx!=secondFx) {
    secondFx = gSecondFx;
    needRefresh = true;
  }
}


void calcButton::drawSelf(void) {

  colorObj* activeBaseColor;
  colorObj* touchedBaseColor;
  colorObj* activeTextColor;
  colorObj* touchedTextColor;
  
  hookup();                   // Need to do a hookup, this is a good time.
  switch (bType) {
    case NUMBER_BTN :
      activeBaseColor = &numberActiveBColor;
      touchedBaseColor = &numberClickedBColor;
      activeTextColor = &numberActiveTColor;
      touchedTextColor = &numberClickedTColor;
      break;
    case  EDIT_BTN :
      activeBaseColor = &editActiveBColor;
      touchedBaseColor = &editClickedBColor;
      activeTextColor = &editActiveTColor;
      touchedTextColor = &editClickedTColor;
      break;
    case FX_BTN :
      activeBaseColor = &fxActiveBColor;
      touchedBaseColor = &fxClickedBColor;
      if (secondFx && aFStr ) {                 // We sportin' a second fx? Let's show it child!
        activeTextColor = &editActiveBColor;
      } else {
        activeTextColor = &fxActiveTColor;
      }
      touchedTextColor = &fxClickedTColor;
      break;
  }

  if (clicked) {
    screen->fillRoundRect(x, y, width, height, RADIUS, touchedBaseColor);
    screen->drawRoundRect(x-1, y-1, width+2, height+2, RADIUS+1, &white);
    screen->drawRoundRect(x-2, y-2, width+4, height+4, RADIUS+2, &white);
    screen->setTextColor(touchedTextColor, touchedBaseColor);
  } else {
    screen->fillRoundRect(x-2, y-2, width+4, height+4, RADIUS+2, &black); 
    screen->fillRoundRect(x, y, width, height, RADIUS, activeBaseColor);
    screen->setTextColor(activeTextColor, activeBaseColor);
  }
  screen->setTextSize(TEXT_SIZE);
  screen->setTextWrap(false);
  word dispWidth = width - (2 * RADIUS);
  if (secondFx && aFStr ) {
    word textWidth = (CHAR_WIDTH * TEXT_SIZE * strlen(aFStr)) - 1;
    if (dispWidth > textWidth) {
      screen->setCursor(x + RADIUS + ((dispWidth - textWidth) / 2), y + 1);
      screen->drawText(aFStr);
    }
  } else {
    word textWidth = (CHAR_WIDTH * TEXT_SIZE * strlen(fStr)) - 1;
    if (dispWidth > textWidth) {
      screen->setCursor(x + RADIUS + ((dispWidth - textWidth) / 2), y + 1);
      screen->drawText(fStr);
    }
  }
}


void calcButton::doAction(void) {

  calcOS->beep();
  if (secondFx && aFStr ) {        // its second function time, if we have a second function do it.
    mCalc.buttonClick(aFStr);      // Send our fuction label to the calculator object to parse.
  } else {
    mCalc.buttonClick(fStr);        // Send our fuction label to the calculator object to parse.
  }
  gSecondFx = false;                // First keystroke clears it.
  buttonPressed = true;            // Tell the calling program we changed something.
}

  
secondfxButton::secondfxButton(char* inFStr,word inLocX, word iny,byte width,byte inType)
  : calcButton(inFStr,inLocX,iny,width,inType) {  }


secondfxButton::~secondfxButton(void) {  }


void secondfxButton::idle() { secondFx = gSecondFx; }         // This one works different..


void secondfxButton::doAction(void) {
  
  calcOS->beep();
  secondFx = !secondFx;
  gSecondFx = secondFx;
}



degRadButton::degRadButton(word inLocX, word iny,byte width,byte height)
    : calcButton("-------",inLocX,iny,width,DEG_RAD_BTN) {
      
    setSize(width,height);
} 


degRadButton::~degRadButton(void) {  }


void  degRadButton::setColors(colorObj* inTColor,colorObj* inHTColor,colorObj* inBColor) {

    tColor.setColor(inTColor);
    hColor.setColor(inHTColor);
    bColor.setColor(inBColor);
    needRefresh = true;
  }


void  degRadButton::drawSelf(void) {

    screen->setTextSize(1);
    screen->setTextWrap(false);
    if (clicked) {
      screen->setTextColor(&hColor, &bColor);
    } else {
      screen->setTextColor(&tColor, &bColor);
    }
    screen->setCursor(x + 2, y + 1);
    
    if ( mCalc.getDegrees()) {
      screen->drawText("Degrees");
    } else {
      screen->drawText("Radians");
    }
  }

  
 void  degRadButton::doAction(void) {

    calcOS->beep();
    mCalc.toggleDegrees();
    needRefresh = true;
 }


closeButton::closeButton(word inLocX, word inLocY,word inWidth, word inHeight,rpnCalc* inCalc)
  : calcButton("X",inLocX,inLocY,inWidth,inHeight) { mCalc =  inCalc; }

closeButton::~closeButton(void) { }


void closeButton::drawSelf(void) {

  screen->fillRoundRect(x, y, width, height, RADIUS, &red);
  screen->setTextColor(&black, &red);
  word textWidth = (CHAR_WIDTH * TEXT_SIZE) - 1;
  word dispWidth = width - (2 * RADIUS);
  screen->setCursor(x + RADIUS + ((dispWidth - textWidth) / 2), y + 1);
  screen->drawText("X");
}

  
void closeButton::doAction(void) { mCalc->close(); }


calcButton.cpp

#ifndef calcButton_h
#define calcButton_h

#include <idlers.h>
#include "drawObj.h"

#define NUMBER_BTN  0
#define EDIT_BTN    1
#define FX_BTN      2
#define DEG_RAD_BTN 3

extern void setupButtonColors(void);

class rpnCalc;

class calcButton : public drawObj, public idler {
  
  public :
          calcButton(char* inFStr,word inLocX, word inLocY,byte width,byte inType);
          calcButton(char* inFStr,char* inAFStr, word inLocX, word inLocY,byte width,byte inType);
  virtual ~calcButton(void);
                  
  virtual void    idle(void);
  virtual void    drawSelf(void);
  virtual void    doAction(void); 
          
  protected :
          char*   fStr;
          char*   aFStr;
          byte    bType;
          boolean secondFx;
};


class secondfxButton : public calcButton {

  public :
          secondfxButton(char* inFStr,word inLocX, word inLocY,byte width,byte inType);
  virtual ~secondfxButton(void);
  
  virtual void    idle(void);
  virtual void    doAction(void);

};
  

class degRadButton : public calcButton {

 public :
                  degRadButton(word inLocX, word inLocY,byte width, byte height);
  virtual ~degRadButton(void);
  
          void    setColors(colorObj* inTColor,colorObj* inHTColor,colorObj* inBColor);
  virtual void    drawSelf(void);
  virtual void    doAction(void);

          colorObj tColor;
          colorObj hColor;
          colorObj bColor;
};


class closeButton : public calcButton {

   public :
          closeButton(word inLocX, word inLocY,word inWidth, word inHeight,rpnCalc* inCalc);
  virtual ~closeButton(void);
  
  virtual void  drawSelf(void);
  virtual void  doAction(void);

          rpnCalc*  mCalc;
};


#endif


calcButton.h

#include "rpnCalc.h"
#include "screen.h"

#include "calculator.h"
#include "calcButton.h"

#define  BACK_COLOR (&black)
#define  DISP_COLOR (&red)
#define  DISP_Y     28
#define  TEXT_SIZE  2

#define  LINE_X1     22
#define  LINE_X2     146
#define  LINE_Y      DISP_Y + 22

#define  LINE2_X1     LINE_X1
#define  LINE2_X2     LINE_X2
#define  LINE2_Y      LINE_Y + 2

#define  LINE3_X1     LINE_X1
#define  LINE3_X2     LINE_X2
#define  LINE3_Y      LINE2_Y + 2
            
#define DEG_RAD_X       156
#define DEG_RAD_Y       LINE_Y - 2
#define DEG_RAD_WIDTH   50
#define DEG_RAD_HEIGHT  15

#define BTN_WIDTH1  30
#define BTN_WIDTH2  50
#define BTN_WIDTH3  80

#define BTN_ROWA_1    64
#define BTN_ROWA_2    94
#define BTN_ROWA_3    124
#define BTN_ROWA_4    154

#define BTN_COLA_1    25
#define BTN_COLA_2    90
#define BTN_COLA_3    155

#define BTN_ROW_1    182
#define BTN_ROW_2    212
#define BTN_ROW_3    242
#define BTN_ROW_4    272
#define BTN_ROW_5    302

#define BTN_COL_1    25
#define BTN_COL_2    75
#define BTN_COL_3    125
#define BTN_COL_4    175

//#define  CLOSE_X    BTN_COL_1
//#define  CLOSE_Y    LINE_Y + 6
//#define  CLOSE_W    BTN_WIDTH2
//#define  CLOSE_H    10

extern      bool            gSecondFx;
            calculator      mCalc;           // The calculator object. Feed it key strokes and it gives calculations.
            bool            buttonPressed;
				lilOS* calcOS = NULL;
          
rpnCalc::rpnCalc(lilOS* ourOS,int panelID)
	: panel(ourOS,panelID) {
	
	calcOS = ourOS;	// Set up our global OS pointer (For the buttons)
	degRad = new degRadButton(DEG_RAD_X,DEG_RAD_Y,DEG_RAD_WIDTH,DEG_RAD_HEIGHT);
		
	XReg = new label(BTN_COL_1, DISP_Y, (BTN_COL_4 + BTN_WIDTH1) - BTN_COL_1, 18, "0");

	aLine = new lineObj(LINE_X1,LINE_Y,LINE_X2,LINE_Y,DISP_COLOR);
	aLine2 = new lineObj(LINE2_X1,LINE2_Y,LINE2_X2,LINE2_Y,DISP_COLOR);  
	aLine3 = new lineObj(LINE3_X1,LINE3_Y,LINE3_X2,LINE3_Y,DISP_COLOR);  
 
	btn1 = new calcButton("1", BTN_COL_2, BTN_ROW_4, BTN_WIDTH1, NUMBER_BTN);
	btn2 = new calcButton("2", BTN_COL_3, BTN_ROW_4, BTN_WIDTH1, NUMBER_BTN);
	btn3 = new calcButton("3", BTN_COL_4, BTN_ROW_4, BTN_WIDTH1, NUMBER_BTN);
	btn4 = new calcButton("4", BTN_COL_2, BTN_ROW_3, BTN_WIDTH1, NUMBER_BTN);
	btn5 = new calcButton("5", BTN_COL_3, BTN_ROW_3, BTN_WIDTH1, NUMBER_BTN);
	btn6 = new calcButton("6", BTN_COL_4, BTN_ROW_3, BTN_WIDTH1, NUMBER_BTN);
	btn7 = new calcButton("7", BTN_COL_2, BTN_ROW_2, BTN_WIDTH1, NUMBER_BTN);
	btn8 = new calcButton("8", BTN_COL_3, BTN_ROW_2, BTN_WIDTH1, NUMBER_BTN);
	btn9 = new calcButton("9", BTN_COL_4, BTN_ROW_2, BTN_WIDTH1, NUMBER_BTN);
	btn0 = new calcButton("0", BTN_COL_2, BTN_ROW_5, BTN_WIDTH1, NUMBER_BTN);

	btnPlus = new calcButton("+", BTN_COL_1, BTN_ROW_3, BTN_WIDTH1, EDIT_BTN);
	btnMinus = new calcButton("-", BTN_COL_1, BTN_ROW_2, BTN_WIDTH1, EDIT_BTN);
	btnTimes = new calcButton("x", BTN_COL_1, BTN_ROW_4, BTN_WIDTH1, EDIT_BTN);
	btnDivide = new calcButton("/", BTN_COL_1, BTN_ROW_5, BTN_WIDTH1, EDIT_BTN);

	btnEnter = new calcButton("Enter", BTN_COL_1, BTN_ROW_1, BTN_WIDTH3, EDIT_BTN);

	btnChSgn = new calcButton("-x", BTN_COL_3, BTN_ROW_1, BTN_WIDTH1, EDIT_BTN);
	btnClrX = new calcButton("Cx", BTN_COL_4, BTN_ROW_1, BTN_WIDTH1, EDIT_BTN);
	btnPt = new calcButton(".", BTN_COL_3, BTN_ROW_5, BTN_WIDTH1, NUMBER_BTN);
	btnPi = new calcButton("Pi", BTN_COL_4, BTN_ROW_5, BTN_WIDTH1, NUMBER_BTN);

	btnInvrse = new calcButton("1/x", BTN_COLA_1, BTN_ROWA_4, BTN_WIDTH2, FX_BTN);
	btnRoot = new calcButton("Srt","y^x", BTN_COLA_2, BTN_ROWA_4, BTN_WIDTH2, FX_BTN);
	btnFix = new calcButton("Fix", BTN_COLA_3, BTN_ROWA_4, BTN_WIDTH2, FX_BTN);


	btnSwapXY = new calcButton("y~x","Rdn", BTN_COLA_1, BTN_ROWA_3, BTN_WIDTH2, FX_BTN);
	btnSto = new calcButton(">p",">r", BTN_COLA_2, BTN_ROWA_3, BTN_WIDTH2, FX_BTN);
	btnRcl = new calcButton("Sto","Rcl", BTN_COLA_3, BTN_ROWA_3, BTN_WIDTH2, FX_BTN);


	btnSin = new calcButton("sin","asn",BTN_COLA_1, BTN_ROWA_2, BTN_WIDTH2, FX_BTN);
	btnCos = new calcButton("cos","acs",BTN_COLA_2, BTN_ROWA_2, BTN_WIDTH2, FX_BTN);
	btnTan = new calcButton("tan","atn",BTN_COLA_3, BTN_ROWA_2, BTN_WIDTH2, FX_BTN);

	btnASin = new calcButton("Ln","e^x",BTN_COLA_1, BTN_ROWA_1, BTN_WIDTH2, FX_BTN);
	btnACos = new calcButton("log","t^x",BTN_COLA_2, BTN_ROWA_1, BTN_WIDTH2, FX_BTN);
	btnATan = new secondfxButton("2f",BTN_COLA_3, BTN_ROWA_1, BTN_WIDTH2, EDIT_BTN);

	gSecondFx = false;
}


rpnCalc::~rpnCalc(void) {

  if(degRad) delete degRad;
            
  if(XReg) delete XReg;
  
  if(aLine) delete aLine;
  if(aLine2) delete aLine2;
  
  if(btn1) delete btn1;
  if(btn2) delete btn2;
 if( btn3) delete btn3;
 if( btn4) delete btn4;
  if(btn5) delete btn5;
  if(btn6) delete btn6;
  if(btn7) delete btn7;
  if(btn8) delete btn8;
  if(btn9) delete btn9;
  if(btn0) delete btn0;
  
  if(btnPlus) delete btnPlus;
  if(btnMinus) delete btnMinus;
  if(btnTimes) delete btnTimes;
  if(btnDivide) delete btnDivide;
  
  if(btnEnter) delete btnEnter;
  
  if(btnChSgn) delete btnChSgn;
  if(btnClrX) delete btnClrX;
  if(btnPt) delete btnPt;
  if(btnPi) delete btnPi;
  
  if(btnInvrse) delete btnInvrse;
  if(btnRoot) delete btnRoot;
  if(btnFix) delete btnFix;
  
  
  if(btnSwapXY) delete btnSwapXY;
  if(btnSto) delete btnSto;
  if(btnRcl) delete btnRcl;
  
  
  if(btnSin) delete btnSin;
  if(btnCos) delete btnCos;
  if(btnTan) delete btnTan;
  
  if(btnASin) delete btnASin;
  if(btnACos) delete btnACos;
 if(btnATan) delete btnATan;
}


void  rpnCalc::setup(void) {

  screen->fillScreen(&black);
  loadScreen();
  buttonPressed = false;
}


void rpnCalc::loadScreen(void) {

  setupButtonColors();
  XReg->setTextSize(TEXT_SIZE);
  XReg->setColors(DISP_COLOR, BACK_COLOR);
  XReg->setJustify(TEXT_RIGHT);
  XReg->setPrecision(mCalc.getFixVal());
  addObj(XReg);

  aLine->setColor(DISP_COLOR);
  addObj(aLine);
  aLine2->setColor(DISP_COLOR);
  addObj(aLine2);
  aLine3->setColor(DISP_COLOR);
  addObj(aLine3);
  
  degRad->setColors(DISP_COLOR, &white, BACK_COLOR);
  addObj(degRad);

  addObj(btn1);
  addObj(btn2);
  addObj(btn3);
  addObj(btn4);
  addObj(btn5);
  addObj(btn6);
  addObj(btn7);
  addObj(btn8);
  addObj(btn9);
  addObj(btn0);

  addObj(btnPlus);
  addObj(btnMinus);
  addObj(btnTimes);
  addObj(btnDivide);

  addObj(btnEnter);

  addObj(btnChSgn);
  addObj(btnClrX);
  addObj(btnPt);
  addObj(btnPi);

  addObj(btnInvrse);
  addObj(btnRoot);
  addObj(btnFix);

  addObj(btnSin);
  addObj(btnCos);
  addObj(btnTan);
  
  addObj(btnSwapXY);
  addObj(btnSto);
  addObj(btnRcl);
  
  addObj(btnASin);
  addObj(btnACos);
  addObj(btnATan);
  
  screen->drawRect(BTN_COL_1-3,DISP_Y-3,((BTN_COL_4+BTN_WIDTH1)-BTN_COL_1)+5,22,DISP_COLOR);
 }


void  rpnCalc::loop(void) {

  if (buttonPressed) {
    XReg->setPrecision(mCalc.getFixVal());
    XReg->setValue(mCalc.getX());
    buttonPressed = false;
  }
}


rpnCalc.cpp

#ifndef rpnCalc_h
#define rpnCalc_h

#include "label.h"
#include "lineObj.h"
#include "calcButton.h"
#include "lilOS.h"

extern	lilOS* calcOS;

class rpnCalc : public panel {

  public:
          rpnCalc(lilOS* ourOS,int panelID);
  virtual ~rpnCalc(void);

          void	loadScreen(void);
  virtual void	setup(void);
  virtual void	loop(void);
  
          label*          XReg;
          lineObj*        aLine;
          lineObj*        aLine2;
          lineObj*        aLine3;
          degRadButton*   degRad;
          calcButton*     btn1;
          calcButton*     btn2;
          calcButton*     btn3;
          calcButton*     btn4;
          calcButton*     btn5;
          calcButton*     btn6;
          calcButton*     btn7;
          calcButton*     btn8;
          calcButton*     btn9;
          calcButton*     btn0; 
          calcButton*     btnPlus;
          calcButton*     btnMinus;
          calcButton*     btnTimes;
          calcButton*     btnDivide;
          calcButton*     btnEnter;
          calcButton*     btnChSgn;
          calcButton*     btnClrX;
          calcButton*     btnPt;
          calcButton*     btnPi;
          calcButton*     btnInvrse;
          calcButton*     btnRoot;
          calcButton*     btnFix;
          calcButton*     btnSwapXY;
          calcButton*     btnSto;
          calcButton*     btnRcl;
          calcButton*     btnSin;
          calcButton*     btnCos;
          calcButton*     btnTan;    
          calcButton*     btnASin;
          calcButton*     btnACos;
          secondfxButton* btnATan;
};


#endif


rpnCalc.h

#include "calculator.h"
#include <string.h>
#include <ctype.h>
#include <math.h>


calculator::calculator(void) {

	x = 0;
	y = 0;
	z = 0;
	t = 0;
	for (int i=0;i<10;i++) { sto[i] = 0; }
    fix = 2;
	degrees = true;
    enter = false;
	fixPressed = false;
	stoPressed = false;
	rclPressed = false;
	startEditing();
}


calculator::~calculator(void) { }


void calculator::buttonClick(const char* inButtonID) {
	
	char buttonID[100];
	int i=0;
	
	strcpy(buttonID,inButtonID);
	while (buttonID[i]) {
		buttonID[i] = toupper(buttonID[i]);
		i++;
	}
	
	if (!strcmp(buttonID,"0")) handleNumber(0);
	else if (!strcmp(buttonID,"1")) handleNumber(1);
	else if (!strcmp(buttonID,"2")) handleNumber(2);
	else if (!strcmp(buttonID,"3")) handleNumber(3);
	else if (!strcmp(buttonID,"4")) handleNumber(4);
	else if (!strcmp(buttonID,"5")) handleNumber(5);
	else if (!strcmp(buttonID,"6")) handleNumber(6);
	else if (!strcmp(buttonID,"7")) handleNumber(7);
	else if (!strcmp(buttonID,"8")) handleNumber(8);
	else if (!strcmp(buttonID,"9")) handleNumber(9);
	else if (!strcmp(buttonID,"-X")) x = -x;
	else if (!strcmp(buttonID,".")) { handlePoint(); }
	
	// This is also talked about at the end of this function.
	// Enter is really odd in that it must effect the next keypress.
	// This is why, once called we immedialy exit. Every other keypress
	// will exit out the bottom and clear this flag.
	else if (!strcmp(buttonID,"ENTER")) {
        pushStack();
		point = false;
		editing = false;
        enter = true;
        return;
    }
	
	// Like "ENTER", "FIX" sets a boolean for the next keystroke.
	// So we set boolean flag and bail out.
	// (Its cleared at the end of this function.)
	else if (!strcmp(buttonID,"FIX")) {
        fixPressed = true;
        return;
    }
	
	// Actually, "STO" acts exactly like "FIX" so..
	// Oh, "RCL" too..
	else if (!strcmp(buttonID,"STO")) {
        stoPressed = true;
        return;
    } else if (!strcmp(buttonID,"RCL")) {
        rclPressed = true;
        return;
    }
	
    else if (!strcmp(buttonID,"CLX")||!strcmp(buttonID,"CX")) { handleClx();}
	else if (!strcmp(buttonID,"RDN")) { handleRollDown();}
	else if (!strcmp(buttonID,"+")) { xyFunction(y+x); }
	else if (!strcmp(buttonID,"-")) { xyFunction(y-x); }
	else if (!strcmp(buttonID,"X")) { xyFunction(y*x); }
	else if (!strcmp(buttonID,"/")) { xyFunction(y/x); }
	else if (!strcmp(buttonID,"MOD")) {
		int intX = x;
		int intY = y;
		xyFunction(intX % intY);
	}
	//else if (!strcmp(buttonID,"√X")) { xFunction(sqrt(x)); }
    else if (!strcmp(buttonID,"SRT")) { xFunction(sqrt(x)); }   //Arduino
	else if (!strcmp(buttonID,"Y^X")) { xyFunction(pow(y,x)); }
    else if (!strcmp(buttonID,"X^2")) { xFunction(pow(x,2)); }
	else if (!strcmp(buttonID,"1/X")) { xFunction(1/x); }
	else if (!strcmp(buttonID,"π")) { xFunction(M_PI); }
    else if (!strcmp(buttonID,"PI")) { xFunction(M_PI); }   // arduino
	else if (!strcmp(buttonID,"Y<>X")||(!strcmp(buttonID,"Y~X"))) {
		double temp;
		temp = x;
		x = y;
		y = temp;
		editing = false;
	}
	else if (!strcmp(buttonID,"SIN")) {
		if (degrees) {
			xFunction(sin(deg_2_rad(x)));
		} else {
			xFunction(sin(x));
		}
    }
	else if (!strcmp(buttonID,"COS")) {
		if (degrees) {
			xFunction(cos(deg_2_rad(x)));
		} else {
			xFunction(cos(x));
		}
	}
	else if (!strcmp(buttonID,"TAN")) {
		if (degrees) {
			xFunction(tan(deg_2_rad(x)));
		} else {
			xFunction(tan(x));
		}
	}
	else if (!strcmp(buttonID,"ASIN")||!strcmp(buttonID,"ASN")) {
		if (degrees) {
			xFunction(rad_2_deg(asin(x)));
		} else {
			xFunction(asin(x));
		}
	}
	else if (!strcmp(buttonID,"ACOS")||!strcmp(buttonID,"ACS")) {
		if (degrees) {
			xFunction(rad_2_deg(acos(x)));
		} else {
			xFunction(acos(x));
		}
	}
	else if (!strcmp(buttonID,"ATAN")||!strcmp(buttonID,"ATN")) {
		if (degrees) {
			xFunction(rad_2_deg(atan(x)));
		} else {
			xFunction(atan(x));
		}
	}
	else if (!strcmp(buttonID,"LOG")) { xFunction(log10(x)); }
	else if (!strcmp(buttonID,"10^X")||!strcmp(buttonID,"T^X")) { xFunction(pow(10,x)); }
	else if (!strcmp(buttonID,"LN")) { xFunction(log(x)); }
	else if (!strcmp(buttonID,"E^X")) { xFunction(exp(x)); }
	
	// To rectangular..
    else if (!strcmp(buttonID,"»R")||!strcmp(buttonID,">R")) {
		double radians;
		double distance;
		
		if (degrees) {
			radians = deg_2_rad(y);
		} else {
			radians = y;
		}
		distance = x;
		y = sin(radians) * distance;
		x = cos(radians) * distance;
		editing = false;
	}
	
	// To polar..
	// r = √ (x^2 + y^2)
	//θ = arctan (y/x) where x != 0
	else if (!strcmp(buttonID,"»P")||!strcmp(buttonID,">P")) {
		
		double xDistance = x;
		double yDistance = y;
		
		if (xDistance) {
			x = sqrt(xDistance*xDistance + yDistance*yDistance);
			y = atan(yDistance/xDistance);
		} else {
			x = yDistance;
			y = M_PI/2;
		}
		if (degrees) {
			y = rad_2_deg(y);
		}
		editing = false;
	}
	
	// Enter is wierd!
	// From the HP11C calculator manual, it diables the stack for the -next- keypress.
	// So, we're going to set it when the enter key is pressed, then exit immediatly.
	// On every other keypress, we exit through this route.
	// So it'll be checked cleared automatically.
	//
	// Fix is kinda' the same..
	//
	// Well actually, so is Sto. And Rcl
	
    enter = false;  // And away we go!
	fixPressed = false;
	stoPressed = false;
	rclPressed = false;
}


void calculator::startEditing() {
	
	editing = true;
	point = false;
	multiplyer = 0.1;
}


void calculator::handleNumber(int inNum) {

	if (fixPressed) {
		fix = inNum;
	} else if (stoPressed) {
		sto[inNum] = x;
		editing = false;
	} else if (rclPressed) {
		pushStack();
		x = sto[inNum];
		editing = false;
	} else {
		if (editing) {
			if (point) {
				if(x>=0) {
					x = x + (inNum * multiplyer);
				} else {
					x = x - (inNum * multiplyer);
				}
				multiplyer = multiplyer / 10;
			} else {
				x = x * 10;
				if(x>=0) {
					x = x + inNum;
				} else {
					x = x - inNum;
				}
			}
		} else {
			startEditing();
			if (!enter) {
				pushStack();
			}
			x = inNum;
		}
	}
}


void calculator::handlePoint(void) {
		
	if (!editing) {
		startEditing();
		if (!enter) {
			pushStack();
		}
		x = 0;
	}
	point = true;
}


void calculator::handleClx(void) {
	
	x = 0;
	startEditing();
}

void calculator::handleRollDown(void) {
	
	popStack();
	editing = false;
}


void calculator::pushStack(void) {
    
    t = z;
	z = y;
	y = x;
}


void calculator::popStack(void) {
    
    x = y;
    y = z;
    z = t;
}


void calculator::xyFunction(double result) {
    
    y = result;
    popStack();
    editing = false;
}


void calculator::xFunction(double result) {
    
    x = result;
    editing = false;
}


double calculator::getX() { return x; }
double calculator::getY() { return y; }
double calculator::getZ() { return z; }
double calculator::getT() { return t; }

double calculator::getStoVal(int i) { return sto[i]; }


bool calculator::isEditing(void) { return editing; }


void calculator::setDegrees(bool inDegrees) { degrees = inDegrees; }


bool calculator::toggleDegrees(void) {
	
	degrees = !degrees;
	return degrees;
}


bool calculator::getDegrees(void) { return degrees; }


double calculator::rad_2_deg(double x) { return x*180/M_PI; }


double calculator::deg_2_rad(double x) { return x*M_PI/180; }


int  calculator::getFixVal(void) {
    
    if(editing) {
        if (!point) {
            return 0;
        } else {
            return (-log10(multiplyer));
        }
    } else
        return fix;
}


bool calculator::getFix(void) { return fixPressed; }


bool  calculator::getSto(void) { return stoPressed; }


bool  calculator::getRcl(void) { return rclPressed; }


bool  calculator::getEnter() { return enter; }



calculator.cpp

//
//  calculator.h
//  Mr Snorts
//
//  Created by Jim Lee on 5/12/15.
//  Copyright (c) 2015 ___LEEFTCOAST___. All rights reserved.
//

#ifndef Mr_Snorts_calculator_h
#define Mr_Snorts_calculator_h

#define NUM_STO_REG 10

class calculator {
	
	public:
				calculator(void);
	virtual	~calculator(void);
	
				void		buttonClick(const char* buttonID);
				double	getX(void);
				double	getY(void);
				double	getZ(void);
				double	getT(void);
				double	getStoVal(int i);
				void		setDegrees(bool inDegrees);
				bool		toggleDegrees(void);
				bool		getDegrees(void);
				double	rad_2_deg(double x);
				double	deg_2_rad(double x);
				int		getFixVal(void);
				bool		getFix();
				bool		getSto();
				bool		getRcl();
				bool		getEnter();
				bool		isEditing(void);
	
protected:
				void    startEditing(void);
				void    handleNumber(int inNum);
				void    handlePoint(void);
				void    handleClx(void);
				void    handleRollDown(void);
				void    pushStack(void);
				void    popStack(void);
				void    xyFunction(double result);
				void    xFunction(double result);

	
				double	t;          // Like the old HP11C
				double	z;
				double	y;
				double	x;
				double	sto[NUM_STO_REG];   // 10 storage registers 0..9
				int		fix;
				bool		editing;
				bool		point;
				bool		degrees;
				bool		enter;
				bool		fixPressed;
				bool		stoPressed;
				bool		rclPressed;
				double	multiplyer;
};

#endif


calculator.h

#include "label.h"
#include <resizeBuff.h>


char  temp[TEMP_BUFF_SIZE];


label::label() : drawObj() { initLabel(); }


// These next two actually fit our rectangle to the text.
label::label(char* inText)
	: drawObj() {

	initLabel();
	setValue(inText);
	setSize(getTextWidth(),getTextHeight());
}


label::label(char* inText, int inSize) 
	: drawObj() {

	initLabel();
	setValue(inText);
	setTextSize(inSize);
	setSize(getTextWidth(),getTextHeight());
}


label::label(int inLocX, int inLocY, int inWidth,int inHeight)
	: drawObj(inLocX,inLocY,inWidth,inHeight) { initLabel(); }


label::label(int inLocX, int inLocY, int inWidth,int inHeight, char* inText)
	: drawObj(inLocX,inLocY,inWidth,inHeight) {
	
	initLabel();
	setValue(inText);
}


label::label(int inLocX, int inLocY, int inWidth,int inHeight, char* inText,int textSize)
	: drawObj(inLocX,inLocY,inWidth,inHeight) {

	initLabel();
	setValue(inText);
	setTextSize(textSize);
}


label::label(rect* inRect,char* inText,int textSize)
	: drawObj(inRect) {

	initLabel();
	setValue(inText);
	setTextSize(textSize);
}


// We don't call initLabel() in this one. Everyting comes from the copied label.
// So be sure we check everything.
label::label(label* aLabel)
	: drawObj(aLabel) {
	
	buff = NULL;								// Best to have this initialized!
	setValue(aLabel->buff);
	setTextSize(aLabel->textSize);
	setJustify(aLabel->justify);
	setColors(&aLabel->textColor,&aLabel->backColor);
	transp = aLabel->transp;
	setPrecision(aLabel->prec);
	needRefresh = true;
}	

	
label::~label() { resizeBuff(0,&buff); }


void label::initLabel(void) {

  textSize = DEF_TEXT_SIZE;
  setColors(&black,&white);
  setJustify(TEXT_LEFT);
  buff = NULL;
  prec = DEF_PRECISION;
  needRefresh = true;
}


void label::setTextSize(int inSize) {

  textSize = inSize;
  needRefresh = true;
}


void label::setJustify(int inJustify) {

  justify = inJustify;
  needRefresh = true;
}


void label::setColors(colorObj* tColor, colorObj* bColor) {

  textColor.setColor(tColor);
  backColor.setColor(bColor);
  transp = false;           // we set both.
  needRefresh = true;
}


void label::setColors(colorObj* tColor) {

	setColors(tColor,&backColor);
	transp = true;
}
  

void label::setPrecision(int inPrec) {

  if (inPrec>=0) {
    prec = min(MAX_PREC,inPrec);	// No limit and the temp buffer explodes.
    needRefresh = true;
  }
}


void label::setValue(int val) {
  
  snprintf (temp,TEMP_BUFF_SIZE,"%d",val);
  setValue(temp);
  needRefresh = true;
}


void label::setValue(unsigned long val) {

  snprintf (temp,TEMP_BUFF_SIZE,"%lu",val);
  setValue(temp);
  needRefresh = true;
}


void label::setValue(double val) {
   
  dtostrf(val,0,prec,temp);
  setValue(temp);
  needRefresh = true;
}


void label::setValue(float val) {
  double dVal = val;
  setValue(dVal); 
}


void label::setValue(char* str) {

	int numChars;

	if (!str) {
		if (resizeBuff(1,&buff)) {
			buff[0] = '\0';
		}
	} else {
		numChars = strlen(str) + 1;
		if (resizeBuff(numChars,&buff)) {
			strcpy (buff,str);
		}
	}
	needRefresh = true;
}


// We want to know how long the string is.. (*** REMEBER NOT COUNTING '\0' ***)
int label::getNumChars(void) { return strlen(buff); }


// We want to know how many chars can we display?
int label::getViewChars(void) { return width/(CHAR_WIDTH*textSize); }

	
// We asked above how much you have. Hand it over!	(They better add one for the \0!)	
void label::getText(char* inBuff) { strcpy(inBuff,buff); }
				
				
int label::getTextWidth(void) { return(CHAR_WIDTH*textSize*strlen(buff)); }


int label::getTextHeight(void) { return(CHAR_HEIGHT*textSize); }


void label::drawSelf(void) {

	int	charDif; 
   int	numCharsDisp; 
	
	if (buff) {																			// Sanity. If we have anything to display..
		numCharsDisp = getViewChars();											// Save off how many chars we can display.
		if (transp) {																	// If we don't draw background bits..
			screen->setTextColor(&textColor);									// We just set the one color as a flag for this.
		} else {																			// Else, we DO want to draw the background bits.
			screen->setTextColor(&textColor,&backColor);						// We set BOTH colors as a flag for both.
		}
		screen->setTextSize(textSize);											// Set the text size.
		screen->setTextWrap(false);												// Turn off wrap. It just makes a mess of everything.
		screen->setCursor(x,y);														// Move the cursor to our XY location.
		charDif =  numCharsDisp - strlen(buff);								// Calculate the total amount of blanks we'll need.
		if (charDif==0) {																// If its a perfect fit..
			screen->drawText(buff);													// Just draw it out. EASY PEASY! (And we're done)
		} else if (charDif>0) {														// Else, we'll need some padding..
			switch (justify) {														// Left, Right, Center will be handled differently.
				case TEXT_LEFT :														// ** LEFT **
					screen->drawText(buff);											// Draw the text.
					for(int i=1;i<=charDif;i++) screen->drawText(" ");		// Add the padding.
				  break;																	// And that's it.
				case TEXT_RIGHT :														// ** RIGHT **
				  for(int i=1;i<=charDif;i++) screen->drawText(" ");		// First we add the padding.
				  screen->drawText(buff);											// Then draw the text.
				  break;																	// And we're done.
				case TEXT_CENTER :													// ** CENTER **
					int leadSp = charDif/2;											// Do integer divide by 2 for the lead blank count.
					int trailSp = charDif-leadSp;									// Subtract the lead count from the blank count for the trailing count.
				  for(int i=1;i<=leadSp;i++) screen->drawText(" ");		// Add the lead padding.
				  screen->drawText(buff);											// Draw the string.
				  for(int i=1;i<=trailSp;i++) screen->drawText(" ");		// Add the trailing padding.
				  break;																	// And again, we're done.
				}
		} else {                      											// Else the string needs truncation..
			if (numCharsDisp<(TEMP_BUFF_SIZE-1)) {								// Make sure we have enough room to maneuver.
				switch (justify) {													// Left, Right, Center will be handled differently.
					case TEXT_LEFT :													// ** LEFT **
						temp[0] = '\0';												// Clear the temp buffer.
						strncat(temp,buff,numCharsDisp);							// Stamp in the characters to display.
						screen->drawText(temp);										// Draw the string.
					break;																// And we're done.
					case TEXT_RIGHT :													// ** RIGHT**						
						screen->drawText((char*)&(buff[-charDif])); 			// Just draw the text starting after the clipped portion.
					break;
					case TEXT_CENTER :												// ** CENTER **
						int firstChar = -charDif/2;								// Calculate first char to display.
						temp[0] = '\0';												// "Clear" the temp buffer.
						strncat(temp,&buff[firstChar],numCharsDisp);			// Stamp in the characters to display.
						screen->drawText(temp);										// Draw the string.
					break;																// And we're done.
				}
			} else {
				screen->drawText("Overflow");										// Our temp buffer is just to small!
			}
		}
	}
}









label.cpp

#ifndef label_h
#define label_h

#include "drawObj.h"
#include "colorObj.h"

#define DEF_TEXT_SIZE	1	// If not set, what size do we want?
#define CHAR_WIDTH		6	// Actual size is 6 * text size.
#define CHAR_HEIGHT		8	// Actual size is 8 * text size.
#define DEF_PRECISION	2	// Number of digits past decimal point.

#define MAX_PREC			12					// #chars - 3 '-','0','.'. The calculator can disp 16.
#define TEMP_BUFF_SIZE	41 + MAX_PREC	// Temp buff for doing text formatting and things.
						  							// Think about what you'll need here. Its important!
						  							// float can get to 3.4xx E+38 add '-', '.' & \0 
						  							// gives 41 chars.

enum {
  TEXT_RIGHT,
  TEXT_LEFT,
  TEXT_CENTER
};


class label : public drawObj {

	public :
  				label();
  				label(char* inText);
  				label(char* inText, int inSize);
  				label(int inLocX, int inLocY, int inWidth,int inHeight);
  				label(int inLocX, int inLocY, int inWidth,int inHeight, char* inText);
  				label(int inLocX, int inLocY, int inWidth,int inHeight, char* inText,int textSize);
  				label(rect* inRect,char* inText,int textSize=1);
  				label(label* aLabel);
	virtual	~label(void);
  
  				void 	setTextSize(int size);  // 1,2,3.. - Ends up as multiples of 8 pixals.
  				void 	setJustify(int inJustify);
  				void 	setColors(colorObj* tColor);
				void 	setColors(colorObj* tColor, colorObj* bColor);
  				void 	setPrecision(int inPrec);
	virtual	void 	setValue(int val);
  				void 	setValue(unsigned long val);
  				void 	setValue(float val);
  				void 	setValue(double val);
  				void 	setValue(char* str);
				int	getNumChars(void);		// We want to know how long the string is..
				int	getViewChars(void);		// We want to know how many chars can we display?
				void	getText(char* inBuff);	// We asked above how much you have. Hand it over.
  				int 	getTextWidth(void);		// How wide in pixels is our text?
  				int 	getTextHeight(void);		// How tall in pixels are the charactors?
  
	virtual	void drawSelf(void);

//private :
	void initLabel(void);
  
	int		textSize;
	int		justify;
	colorObj	backColor;
	colorObj textColor;
	bool		transp;
	char*    buff;
	int      prec;      // For formatting floats.
};

#endif



label.h

#include "liveText.h"

liveText::liveText(int x,int y,int width,int height,int framerateMs,bool inLoop)  
  : label(x,y,width,height),
  idler(),
  colorMultiMap(),
  timeObj(framerateMs) {

  loop        = inLoop;
  maxTime     = 0;
  frame       = 0;
  holding     = false;
}


liveText::~liveText(void) { }


// Add in a color to out timed color map.
void  liveText::addAColor(int timeMs,colorObj* color) { 

	hookup();											// We add colors at the start. Good hookup() time!
	start();												// And a great place to start our timer too!
	if (timeMs>maxTime) {							// If this is beyond our max time..
		maxTime = timeMs;								// Set our max time to fit.
	}
	colorMultiMap::addColor(timeMs,color);		// Pop it into the color map.
}



void liveText::hold(void) { holding = true; }

 
void liveText::release(bool reset) {

  holding = false;    // Take off the breaks.. 
  if (reset) {
    frame = 0;
  }
  setCalcColor();     // Just in case we get a draw call.
}


void  liveText::setCalcColor(void) {
  
	bool		savedTransp;
	colorObj	aColor;
	
	aColor = map(frame);		// Calculate the color.
	savedTransp = transp;	// Save off our transparent setting.
	setColors(&aColor);		// set the color it.
	transp = savedTransp;	// Restore the transp setting.
}


void liveText::idle(void) {
  
  
	if (ding()&&!holding) {							// First check the timer.
		start();											// Reset the timer from now. Allows hold to work.
		if (frame<maxTime) {							// We still have frames to go?
			setCalcColor();							// Set the color;
			frame = frame + (getTime()/1000.0);	// Step the frame counter. Units are ms.
		} else {											// We're done with our frames.
			if (loop) {									// If we loop, we start over.
				frame = 0;								// If so, reset the frame thing.
			} else {										// If we don't loop.
				setCalcColor();						// Set the last color;
				hold();									// We hold.
			}
		}
	}
}



liveText.cpp

#ifndef liveText_h
#define liveText_h

#include <timeObj.h>
#include <idlers.h>
#include <colorObj.h>
#include "label.h"

// Live text is text that can change over time in the background. This could be blinking?
// Or color changes or fade out. You pretty much have complete control over the line of text
// as one line. You don't have a char by char control here. Just color over time on a string.
// 
// You have your standard x,y,length, height paramiters. Then you have framerateMs.

// framerateMs : sets how long between changes it waits. This is not a perfect clock. 
// Things can effect it like the program doing something else somewhere else. But it 
// does the best it can and really all this is for is just looks & sizzle. So it should
// be fine.
//
// Loop : Tells us true - this should go on over and over forever. Or false - Do it once and stop.
//
// How long does the animation go on for? No parameter for that. Ah! This is the cool bit.
// The colorMultiMap sets this.
//
// addAColor() takes a time & color. Time is an integer representing milisoncds
// and color is a coloObj. You want your first color to start at time 0. Then you
// add them whatever color you want at wheatever time. It will sort them out in
// time order and blend over time from color to color.
// 
// For example : Show a string for 4 seconds then fade to black over 1 second.
// 
// addAColor(0,&white);
// addAColor(4000,&white);
// addAColor(5000,&black);
//
// That will do it.
//
// hold() and release() are for triggering starts and stops of animation.
// release() can reset the animation to 0 frame for you if you'd like.
//
// NOTE : Best to use this over solid colors. Trying to animate on a .bmp
// bakckground is a flashy mess. Too slow.


class liveText : public label,
                 public idler, 
                 public colorMultiMap,
                 public timeObj {

  public:
				liveText(int x,int y, int width, int height,int framerateMs=100,bool loop=false);
	virtual	~liveText(void);
                
				void		addAColor(int timeMs,colorObj* color);
				void		hold(void);
				void		release(bool reset=true);

	virtual	void		idle(void);
				void		setCalcColor(void);
  
				bool		loop;
				int		maxTime;
				int		frame;
				bool		holding;
};

#endif


liveText.h

#include "backColorObj.h"

backColorObj::backColorObj(void) { }
backColorObj::~backColorObj(void) { }
void backColorObj::setBackColor(colorObj* aColor) { setColor(aColor); }
void backColorObj::setBackColor(byte r,byte g,byte b) { setColor(r,g,b); }

backColorObj.cpp

#ifndef backColorObj_h
#define backColorObj_h

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

class backColorObj :	public colorObj {

	public:
				backColorObj(void);
	virtual	~backColorObj(void);
	
				void		setBackColor(colorObj* aColor);
				void		setBackColor(byte r,byte g,byte b);
};

#endif

backColorObj.h


#include "ballObj.h"
#include "brickObj.h"
#include "breakout.h"

gameCompass ourCompass;


gameCompass::gameCompass(void) {

  courses[0].y = -2 ; courses[0].x = 0;
  courses[1].y = -2 ; courses[1].x = 1;
  courses[2].y = -3 ; courses[2].x = 2;
  courses[3].y = -2 ; courses[3].x = 2;
  courses[4].y = -2 ; courses[4].x = 3;

  courses[9].y = 2 ; courses[9].x = 0;
  courses[8].y = 2 ; courses[8].x = 1;
  courses[7].y = 3 ; courses[7].x = 2;
  courses[6].y = 2 ; courses[6].x = 2;
  courses[5].y = 2 ; courses[5].x = 3;

  courses[10].y = 2 ; courses[10].x = -1;
  courses[11].y = 3 ; courses[11].x = -2;
  courses[12].y = 2 ; courses[12].x = -2;
  courses[13].y = 2 ; courses[13].x = -3;

  courses[17].y = -2 ; courses[17].x = -1;
  courses[16].y = -3 ; courses[16].x = -2;
  courses[15].y = -2 ; courses[15].x = -2;
  courses[14].y = -2 ; courses[14].x = -3;
}


gameCompass::~gameCompass(void) {  }


point gameCompass::adjustCourse(int dy, int dx, courseChange change) {

  point aPoint;
  bool  foundPoint;
  int   index;

  aPoint.y = dy;    // Defualt, no change.
  aPoint.x = dx;
  index = 0;
  foundPoint = false;
  while (!foundPoint && index < COMPASS_POINTS) {
    foundPoint = (courses[index].y == dy && courses[index].x == dx);
    if (!foundPoint) {
      index++;
    }
  }
  if (foundPoint) {
    switch (change) {
      case clockwise :
        if (index != 4 && index != 13) {
          index++;
          if (index >= COMPASS_POINTS) {
            index = 0;
          }
          aPoint.y = courses[index].y;
          aPoint.x = courses[index].x;
        }
        break;
      case counterClockwise :
        if (index != 5 && index != 14) {
          index--;
          if (index < 0) {
            index = COMPASS_POINTS - 1;
          }
          aPoint.y = courses[index].y;
          aPoint.x = courses[index].x;
        }
        break;
    }
  }
  return aPoint;
}




// ************



ballObj::ballObj(paddleObj* inPaddle)
  : drawObj(BALL_X, BALL_Y, BALL_DIA, BALL_DIA) {

	thePaddle = inPaddle;
	ballLost = true;
}


ballObj::~ballObj(void) {  }


int ballObj::middleX(void) { return x+width/2; }


void ballObj::reset(void) {

  deltaY  = abs(BALL_DY);    // Always start heading down.
  deltaX = BALL_DX;
  framePerPix = BALL_FPM;

  yCount = 0;
  xCount = 0;
  frameCount = 0;
  drawObj::setLocation(BALL_X, BALL_Y);
  ballLost = false;
  soundStartBall();
}


void ballObj::setLocation(int inX, int inY) {

  boolean   clearSkies;
  boolean   done;
  point     newCourse;
  rect      ourNewSelf;
  int       index;
  boolean   theTouch;
  
  if (!ballLost) {
    clearSkies = true;

    // Fist we check the walls..
    if (inX >= TFT_W - width) { // Hit right wall
    	soundHitWall();
      deltaX = -deltaX;
      clearSkies = false;
    }
    if (inX <= width) { // Hit left wall
    	soundHitWall();
      deltaX = -deltaX;
      clearSkies = false;
    }
    if (inY >= (GAME_H-24) - height) {        // Hit bottom wall
      ballLost = true;                			// The ball was LOST!!
      screen->fillRect(x,y,width,height,this);
      clearSkies = false;
    }
    if (inY <= GAME_TOP+8 - height) { // Hit top wall
    	soundHitWall();
      deltaY = -deltaY;
      clearSkies = false;
    }

    // Then we check the paddle.
    if (y + height <= thePaddle->y && inY + height >= thePaddle->y) { // We're at the paddle level!
      if (!(inX > thePaddle->maxX() || inX + width < thePaddle->minX())) { // Paddle hit!!
			soundHitPaddel();
        	deltaY = -abs(deltaY);                                      // So as to not get stuck. Force and upward movement.
        
        if (middleX() > thePaddle->middleX()) {
          newCourse = ourCompass.adjustCourse(deltaY, deltaX, clockwise);
          deltaY = newCourse.y;
          deltaX = newCourse.x;
        } else if (middleX() < thePaddle->middleX()) {
          newCourse = ourCompass.adjustCourse(deltaY, deltaX, counterClockwise);
          deltaY = newCourse.y;
          deltaX = newCourse.x;
        }
        clearSkies = false;
      }
    }

    // Now we check the bricks!
    ourNewSelf.setRect(this);
    ourNewSelf.setLocation(inX,inY);
    theTouch = false;
    index = 0;
    done = false;
    while(!done) {                      // find the first brick we hit.
      if (index>=TOTAL_BRICKS) {
        done = true;
      } else {
        theTouch = ourNewSelf.overlap((rect*)brickList[index]);
        if (theTouch) {
          brickList[index]->hit();
          done = true;
        }
        index++;
      }
    }
    if (theTouch) {
      deltaY = -deltaY;
      clearSkies = false;
    }
    if (clearSkies) {
      drawObj::setLocation(inX, inY);
    }
  }
}


void ballObj::eraseSelf(void){ 

	if (lastX>0 && lastY>0) {
		screen->fillRoundRect(lastX,lastY,width,height,width/3,this);
	}
}


void ballObj::drawSelf(void) {

	colorObj	aColor(LC_RED);
	screen->fillRoundRect(x,y,width,height,width/3,&aColor);
}


void ballObj::ballFrame(void) {

  int newX;
  int newY;

  if (!ballLost) {
    if (frameCount == 0) {
      if (xCount < abs(deltaX)) {
        newX = x + deltaX;
        xCount++;
      } else {
        newX = x;
      }
      if (yCount < abs(deltaY)) {
        newY = y + deltaY;
        yCount++;
      } else {
        newY = y;
      }
      if (xCount >= abs(deltaX) && yCount >= abs(deltaY)) {
        xCount = 0;
        yCount = 0;
      }
      setLocation(newX, newY);
    }
    frameCount++;
    if (frameCount == framePerPix) {
      frameCount = 0;
    }
  }
}


ballObj.cpp

#ifndef ballObj_h
#define ballObj_h

#include "backColorObj.h"
#include "paddleObj.h"
#include "breakout.h"


#define COMPASS_POINTS  18

enum courseChange { clockwise, counterClockwise };

class gameCompass {

  public:
          gameCompass(void);
  virtual ~gameCompass(void);

    point adjustCourse(int dy,int dx,courseChange change);
  
    point courses[COMPASS_POINTS];
};


class ballObj :	public drawObj,
						public backColorObj {

  public:
          ballObj(paddleObj* inPaddle);
  virtual ~ballObj(void);

          void	reset(void);
  virtual void setLocation(int inX, int inY);
  virtual void eraseSelf(void);
  virtual void drawSelf(void);
          void ballFrame(void);
          int	middleX(void);
    
    int   deltaY;       // Our vector..
    int   deltaX;
    int   framePerPix;
    
    int		yCount;       // How we're doing onlong that vector..
    int		xCount;
    int		frameCount;
    boolean ballLost;

    paddleObj*  thePaddle;
};

#endif


ballObj.h

#include <resizeBuff.h>
#include "drawObj.h"
#include "offscreen.h"
#include "breakout.h"
#include "paddleObj.h"
#include "ballObj.h"
#include "brickObj.h"
#include "toneObj.h"
#include "lilOS.h"

// ********* beepSounds ********

int	tonePin = -1;


void soundHitWall(void) {
	
	toneObj aTone(tonePin);

	aTone.play(1000,50);
}

void soundHitPaddel(void) {
	
	toneObj aTone(tonePin);

	aTone.play(750,50);
}


void soundHitBrick(void) {

	toneObj aTone(tonePin);

	aTone.play(1750,20);
}



void soundBallLost(void) {
	
	toneObj aTone(tonePin);

	aTone.play(500,35);
	while(aTone.isPlaying()) idle();
	aTone.play(250,35);
	while(aTone.isPlaying()) idle();
	aTone.play(1250,75);
}


void soundWinner(void) {
	
	toneObj	aTone(tonePin);
	int		eNote;
	tune		aTune;
	
	eNote = 100;
	for (int i=1;i<=4;i++) {
		aTune.addNote(NOTE_D4,eNote);
		aTune.addNote(NOTE_G4,eNote);
		aTune.addNote(NOTE_B5,eNote);
	}
	for (int i=1;i<=4;i++) {
		aTune.addNote(NOTE_E4,eNote);
		aTune.addNote(NOTE_G4,eNote);
		aTune.addNote(NOTE_C5,eNote);
	}
	for (int i=1;i<=4;i++) {
		aTune.addNote(NOTE_FS4,eNote);
		aTune.addNote(NOTE_A5,eNote);
		aTune.addNote(NOTE_D5,eNote);
	}
	aTune.addNote(NOTE_B5,eNote*2);
	aTune.addNote(NOTE_G4,eNote);
	aTune.addNote(NOTE_D4,eNote);
	aTune.addNote(NOTE_E4,eNote*2);
	aTune.addNote(NOTE_D4,eNote*2);
	aTune.addNote(NOTE_E4,eNote*2);
	aTune.addNote(NOTE_G4,eNote*6);
	aTune.startTune(&aTone);
	while(aTune.playing()) idle();
}


void soundZwoop(void) {

	toneObj	aTone(tonePin);

	
	for (int i = NOTE_C4;i<NOTE_C5;i++) {
		aTone.play(i,2);
		while(aTone.isPlaying()) idle();
	}
	
	while(aTone.isPlaying()) idle();
}

	
void soundGameOver(void) {

	toneObj	aTone(tonePin);
	
	aTone.play(NOTE_G3,1000);
	while(aTone.isPlaying()) idle();
	aTone.play(NOTE_C2,750);
	while(aTone.isPlaying()) idle();
}


void soundStartBall(void) {

	toneObj	aTone(tonePin);
	
	aTone.play(NOTE_G6,30);
	while(aTone.isPlaying()) idle();
	aTone.play(NOTE_C5,30);
}


// ******************************

breakout::breakout(lilOS* ourOS,int ourAppID)
  : panel(ourOS,ourAppID) {

	if (ourOS) {
		tonePin = ourOS->getTonePin();
		setupBrickBitmaps();
	}
	frameTimer    = new timeObj(FRAME_MS);
	paddleTimer   = new timeObj(PADDLE_MS);
	textTimer     = new timeObj(TEXT_MS);
	oldLoc        = -10;
	brickIndex    = 0;        // It was originally written to run once.
}


breakout::~breakout(void) {	// I think the brick list is leaking memory.

	if(greenBmp) { delete greenBmp; }
	if(purpBmp) { delete purpBmp; }
	if(redBmp) { delete redBmp; }
	if(frameTimer) { delete frameTimer; }
	if(paddleTimer) { delete paddleTimer; }
	if(textTimer) { delete textTimer; }
}


// We need three bitmaps for doing the bars to knock out.
void breakout::setupBrickBitmaps(void) {
	
	char*			folderPtr;
	char*			pathPtr;
	int			pathLen;
	offscreen	vPort; 
	bmpObj*		BMPobj;
	
	folderPtr = NULL;
	pathPtr	 = NULL;
	greenBmp = new bitmap(BRICK_W,BRICK_H);				// Allocate the bitmaps.
	purpBmp	= new bitmap(BRICK_W,BRICK_H);
	redBmp	= new bitmap(BRICK_W,BRICK_H);
	if (greenBmp && purpBmp && redBmp) {							// If we got all three..
		folderPtr = mOSPtr->getPanelFolder(mPanelID);			// Ask the OS for our folder path.
		pathLen = strlen(folderPtr);									// Num chars in this path..
		pathLen = pathLen + 13;											// Add about 13 more for the file name.
		if (resizeBuff(pathLen,&pathPtr)) {							// If we can allocate room for the full pathname.
			strcpy(pathPtr,folderPtr);									// Start with the folder path.
			strcat(pathPtr,"grnBar.bmp");								// Add the file name.
			BMPobj = new bmpObj(0,0,BRICK_W,BRICK_H,pathPtr);	// Create the bmpObj.
			if (BMPobj) {													// If we can read this file..
				vPort.beginDraw(greenBmp);								// Set up to offscreen drawing to the bitmap.
				BMPobj->draw(); 											// Draw to it..
				vPort.endDraw();											// Restore normal drawing.
				delete(BMPobj);											// Recycle the .bmp file object.
			}
			strcpy(pathPtr,folderPtr);									// Restart with the folder path.
			strcat(pathPtr,"purpBar.bmp");							// Add the file name.
			BMPobj = new bmpObj(0,0,BRICK_W,BRICK_H,pathPtr);
			if (BMPobj) {													// If we can read this file..
				vPort.beginDraw(purpBmp);								// Set up to offscreen drawing to the bitmap.
				BMPobj->draw(); 											// Draw to it..
				vPort.endDraw();											// Restore normal drawing.
				delete(BMPobj);											// Recycle the .bmp file object.
			}
			strcpy(pathPtr,folderPtr);									// Restart with the folder path. Again, sigh..
			strcat(pathPtr,"redBar.bmp");								// Add the file name.
			BMPobj = new bmpObj(0,0,BRICK_W,BRICK_H,pathPtr);
			if (BMPobj) {													// If we can read this file..
				vPort.beginDraw(redBmp);								// Set up to offscreen drawing to the bitmap.
				BMPobj->draw(); 											// Draw to it..
				vPort.endDraw();											// Restore normal drawing.
				delete(BMPobj);											// Recycle the .bmp file object.
			}
			resizeBuff(0,&pathPtr);										// Recycle reuse.
		}
	}
}
		


void breakout::setup(void) {

  backColor.setColor(&black);
  screen->fillScreen(&backColor);
  screen->drawRect(0,GAME_TOP,TFT_W,GAME_H,&white);   // Damn, looks good leave it!

  paddle = new paddleObj(54,PADDLE_Y,PADDLE_WIDTH,PADDLE_HEIGHT);
  paddle->setBackColor(&backColor);
  addObj(paddle);

  message = new label(MESSAGE_X,MESSAGE_Y,MESSAGE_W,MESSAGE_H);
  message->setColors(&yellow,&backColor);
  message->setJustify(TEXT_CENTER);
  addObj(message);

  numBallsTxt = new label(BALLS_TXT_X,BALLS_Y,BALLS_TXT_W,BALLS_H);
  numBallsTxt->setColors(&white,&backColor);
  numBallsTxt->setJustify(TEXT_RIGHT);
  numBallsTxt->setValue("Balls:");
  addObj(numBallsTxt);
    
  numBallsNum = new label(BALLS_NUM_X,BALLS_Y,BALLS_NUM_W,BALLS_H);
  numBallsNum->setColors(&backColor,&backColor); // Not yet..
  numBallsNum->setJustify(TEXT_LEFT);
  numBallsNum->setValue(" ");
  addObj(numBallsNum);

  ballNumCMap.addColor(NUM_BALLS,&green);
  ballNumCMap.addColor(2,&yellow);
  ballNumCMap.addColor(1,&red);

  theBall = new ballObj(paddle);
  theBall->setBackColor(&backColor);
  addObj(theBall);
  
  
  fillBricks();
  setState(preGame);
}


void breakout::fillBricks(void) {

  brickObj* aBrick;
  int       y;
  int       offset;

  offset = (TFT_W-(NUM_BRICKS*BRICK_W))/2;
  y = BOTTOM_BRICK;
  for(byte j=0;j<2;j++) {
    for(byte i=0;i<NUM_BRICKS;i++) {
      aBrick = new brickObj((i*BRICK_W)+offset,y);
      aBrick->setColor(greenBmp);
      aBrick->setBackColor(&backColor);
      addObj(aBrick);
    }
    y = y-BRICK_H;
  }
  for(byte j=0;j<2;j++) {
    for(byte i=0;i<NUM_BRICKS;i++) {
      aBrick = new brickObj((i*BRICK_W)+offset,y);
      aBrick->setColor(purpBmp);
      aBrick->setBackColor(&backColor);
      addObj(aBrick);
    }
    y = y-BRICK_H;
  }
  for(byte j=0;j<2;j++) {
    for(byte i=0;i<NUM_BRICKS;i++) {
      aBrick = new brickObj((i*BRICK_W)+offset,y);
      aBrick->setColor(redBmp);
      aBrick->setBackColor(&backColor);
      addObj(aBrick);
    }
    y = y-BRICK_H;
  }
}


void breakout::doPaddle(void) {

  int newLoc;
  point touchPt;
  
  if (paddleTimer->ding()) {
    paddleTimer->stepTime();
    if(screen->touched()) {
      touchPt = screen->getPoint();
      newLoc = touchPt.x - PADDLE_HWIDTH;
      if (newLoc<=0) {
        newLoc = 1; 
      } else if (newLoc>=TFT_W-PADDLE_WIDTH) {
        newLoc = TFT_W-PADDLE_WIDTH-1;
      }
      if (newLoc!=oldLoc) {
        paddle->setLocation(newLoc,PADDLE_Y);
        oldLoc = newLoc;
      }
    }
  }
}


void breakout::doBall(void) {

  if (frameTimer->ding()) {
    frameTimer->stepTime();
    theBall->ballFrame();
    if (theBall->ballLost) {
        ballCount--;
        if (ballCount) {
          setState(lostBall);
        } else {
          setState(gameOver);
        }
    } else {
      if (!bricks()) {
        setState(gameWin);
      }
    }
  }
}


void breakout::showBallNum(int balls) {

  colorObj  aColor;

  if (balls) {
    aColor = ballNumCMap.map(balls);
    numBallsNum->setColors(&aColor,&backColor);
    numBallsNum->setValue(ballCount);
  } else {
    numBallsNum->setValue(" ");
  }
}


void breakout::setState(gameStates state) {

  switch(state) {
    case preGame :
      soundZwoop();
      while(screen->touched()) delay(10);
      paddleTimer->start();
      ballCount = NUM_BALLS;
      showBallNum(ballCount);
      theBall->setLocation(BALL_X,BALL_Y);
      resetBricks();
      message->setValue("Tap to start");
      while(!paddleTimer->ding());
      doPaddle();
      savedPaddleX = paddle->x;
      frameTimer->start();
      break;
    case inPLay :
      message->setValue(" ");
      theBall->reset();
      frameTimer->start();
      break;
    case lostBall :
      message->setValue("BALL LOST!!");
      showBallNum(ballCount);
      textTimer->start();
      soundBallLost();
      break;
    case gameOver :
      message->setValue("GAME OVER!!");
      showBallNum(ballCount);
      soundGameOver();
      textTimer->start();
      break;
    case gameWin :
      theBall->eraseSelf();
      message->setValue("WINNER!!");
      soundWinner();
      textTimer->start();
      break;
  }
  gameState = state;
}
  

void breakout::loop(void) {

  doPaddle();
  switch(gameState) {
    case preGame :
        if (screen->touched()) {
          sleep(500);
          setState(inPLay);
          doBall();
        }
      break;
    case inPLay : doBall(); break;
    case lostBall :
      if (textTimer->ding()) {
        setState(inPLay);
      }
      break;
    case gameOver :
      if (textTimer->ding()) {
        setState(preGame);
      }
      break;
    case gameWin :
      if (textTimer->ding()) {
        setState(preGame);
      }
      break;
  }
}


breakout.cpp

#ifndef breakout_h
#define breakout_h

#include "toneObj.h"
#include "label.h"
#include "lilOS.h"

#include "paddleObj.h"
#include "ballObj.h"
#include "brickObj.h"

#define TFT_W         240
#define TFT_H         320

#define GAME_TOP      24
#define GAME_H        TFT_H-GAME_TOP

#define PADDLE_WIDTH  20
#define PADDLE_HWIDTH 10

#define PADDLE_HEIGHT 4
#define PADDLE_Y      GAME_H-40

#define PADDLE_MS 20
#define FRAME_MS  10
#define TEXT_MS   1500

#define MESSAGE_X 1
#define MESSAGE_Y GAME_TOP + 170
#define MESSAGE_W TFT_W - 2
#define MESSAGE_H 8

#define BALLS_TXT_X TFT_W - 100 //40
#define BALLS_TXT_W 72
#define BALLS_Y     GAME_H - 10
#define BALLS_H     8
#define BALLS_NUM_X BALLS_TXT_X + BALLS_TXT_W + 2
#define BALLS_NUM_W 16

// --------------------
#define NUM_BALLS 4

#define BALL_X    120
#define BALL_Y    GAME_TOP + 130
#define BALL_DIA  6
#define BALL_FPM  2   // Frames / move
#define BALL_DY   -2
#define BALL_DX   0

// --------------------

#define BRICK_W       34
#define BRICK_H       12
#define NUM_BRICKS    238/BRICK_W
#define BOTTOM_BRICK  GAME_TOP + 96
#define BRICK_ROWS    6
#define TOTAL_BRICKS  NUM_BRICKS*BRICK_ROWS


extern void soundHitWall(void);
extern void soundBallLost(void);
extern void soundHitPaddel(void);
extern void soundHitBrick(void);
extern void soundZwoop(void);
extern void soundGameOver(void);
extern void soundStartBall(void);


class ballObj;

class breakout :  public panel {

	public:

	enum		gameStates { preGame, inPLay, lostBall, gameOver, gameWin };

				breakout(lilOS* ourOS,int ourAppID);
	virtual	~breakout(void);

	virtual	void setup(void);
				void setupBrickBitmaps(void);
				void fillBricks(void);
				void doPaddle(void);
				void doBall(void);
				void showBallNum(int balls);
				void setState(gameStates state);
	virtual	void loop(void);

				bitmap*			greenBmp;
				bitmap*			purpBmp;
				bitmap*			redBmp;
				paddleObj*		paddle;
				ballObj*			theBall;
				label*			message;
				label*			numBallsTxt;
				label*			numBallsNum;
				colorMultiMap	ballNumCMap;
				timeObj*			frameTimer;
				timeObj*			paddleTimer;
				timeObj*			textTimer;
				colorObj			backColor;
				gameStates		gameState;
				int				oldLoc;
				int				savedPaddleX;
				int				ballCount;
};

#endif


breakout.h

#include "brickObj.h"

brickObj* brickList[TOTAL_BRICKS];  // Move these two into.. The breakout class?
int       brickIndex = 0;


void resetBricks(void) {

  brickObj* aBrick;
  
  for(int i=0;i<TOTAL_BRICKS;i++) {
    aBrick = brickList[i];
    if (aBrick) aBrick->reset();
  }
}


bool bricks(void) {

  brickObj* aBrick;

  for(int i=0;i<TOTAL_BRICKS;i++) {
    aBrick = brickList[i];
    if (aBrick) {
      if (aBrick->x>0) return true;
    }
  }
  return false;
}



brickObj::brickObj(int inX,int inY)
	: drawObj(inX,inY,BRICK_W,BRICK_H) {

	homeX = inX;
	homeY = inY;
	brickList[brickIndex++] = this;
}


brickObj::~brickObj(void) {  }


void brickObj::setColor(bitmap* inBitmap) { ourBMap = inBitmap; }


void brickObj::hit(void) {

  screen->fillRect(x,y,width,height,&white);	// A flash!
  soundHitBrick();
  delay(20);											// Nasty delay.
  screen->fillRect(x,y,width,height,this);	// Erased, from exsistance.
  drawObj::setLocation(-100,-100);				// We're outta' here!
}


void brickObj::reset(void) {  drawObj::setLocation(homeX,homeY); }


void brickObj::drawSelf(void) {
  
  if (x>0 && y>0) {
    screen->blit(x,y,ourBMap);
  }
}


brickObj.cpp

#ifndef brickObj_h
#define brickObj_h

#include "backColorObj.h"
#include "breakout.h"


extern int  brickIndex;

class brickObj :	public drawObj,
						public backColorObj {

public:
			brickObj(int inX,int inY);
virtual	~brickObj(void);

			void  setColor(bitmap* inBitmap);
			void  hit(void);
			void  reset(void);
virtual	void	drawSelf(void);
    		
			bitmap*	ourBMap;
			int		homeX;
			int		homeY;
};

extern brickObj* brickList[];
extern void resetBricks(void);
extern boolean bricks(void);

#endif


brickObj.h

#include "paddleObj.h"

paddleObj::paddleObj(int x, int y, int width,int height) 
  :drawObj(x,y,width,height) { }	// Was true. I think that's wrong.

paddleObj::~paddleObj(void) {  }

void paddleObj::eraseSelf(void) { 
	
	if (lastX>0&&lastY>0) {
		screen->fillRect(lastX,lastY,width,height,this);
	}
}

void paddleObj::drawSelf(void) { screen->fillRect(x,y, width, height, &white); }

int paddleObj::middleX(void) { return x+width/2; }


paddleObj.cpp

#ifndef paddleObj_h
#define paddleObj_h

#include "drawObj.h"
#include "backColorObj.h"

class paddleObj : public drawObj,
						public backColorObj {

  public:
          paddleObj(int x,int y,int width,int height);
  virtual ~paddleObj(void);

  virtual void eraseSelf(void);
  virtual void drawSelf(void);
          int  middleX(void);
};

#endif


paddleObj.h

#include "toneObj.h"
#include "Arduino.h"
//#include "debug.h"


// ***************************************************************************************
// Your classic tone playing object. This can tell you when the tone is finished.
// ***************************************************************************************


toneObj::toneObj(int inPin) {

	mPin = inPin;
	setTime(.01,true);	// A bit of a hack. Currently timeObj has three states, preset, running and expired. This forces expired.
}


toneObj::~toneObj(void) {  }
				
				
void toneObj::play(int inHz,int inMs) {
	
	if (mPin>=0) {
		if (inHz>0) {
			tone(mPin,inHz,inMs);
		} else {
			noTone(mPin);
		}
		setTime(inMs,true);
	}
}


bool toneObj::isPlaying(void) { return !ding(); }
				


// ***************************************************************************************
// Play a tune. basically a list of notes and rests. Use a toneObj above to play them.
// This would be a note..
// ***************************************************************************************


note::note(int inHz,int inMs)
	: linkListObj() {
	
	mHz = inHz;
	mMs = inMs;
}


note::~note(void) { }

			
note* note::getNext(void) { return (note*) linkListObj::getNext(); }


void note::playSelf(toneObj* inTone,float timeMult) { inTone->play(mHz,round(mMs*timeMult)); }
				

		
// ***************************************************************************************
// And here is the note list, or tune. Single voice.
// ***************************************************************************************

	
tune::tune(void)
	: linkList() {
	
	mTimeMult 	= 1;
	mPlaying 	= NULL;
	mTone			= NULL;
}


tune::~tune(void) {  }
 
 

void tune::addNote(int inHz,int inMs) {

	hookup();
	note* newNote = new note(inHz,inMs);
	addToEnd(newNote);
}


void tune::adjustSpeed(float inTimeMult) { mTimeMult = inTimeMult; }

	
void tune::startTune(toneObj* inTone,int inIndex) {

	if (inTone && inIndex>=0) {
		mTone = inTone;
		mPlaying = (note*)getByIndex(inIndex);
		if (mPlaying) {
			if (mPlaying) mPlaying->playSelf(mTone,mTimeMult);
		}
	}
}


int tune::stopTune(void) {

	int index;
	
	if (mTone) mTone->play(0,0);
	index = findIndex(mPlaying);
	mPlaying = NULL;
	return index;
}


bool tune::playing(void) { return mPlaying!=NULL; }


void tune::idle(void) {

	if (playing() && mTone) {
		if (!mTone->isPlaying()) {
			mPlaying = mPlaying->getNext();
			if (mPlaying) {
				mPlaying->playSelf(mTone,mTimeMult);
			}
		}
	}
}

      	      
//
//
//
/*
WriteVarLen(long value) {

	long buffer;
	
	buffer = value & 0x7f;
	while((value >>= 7) > 0) {
		buffer <<= 8;
		buffer |= 0x80;
		buffer += (value & 0x7f);
	}
	while (1) {
 		putc(buffer,outfile);
 		if(buffer & 0x80) {
 			buffer >>= 8;
 		} else
 			break;
 		}
 	}
}


unsigned long ReadVarLen(void) {

	unsigned long	value;
	byte				c;

	if((value = getc(infile)) & 0x80) {
 		value &= 0x7f;
 		do {
  			value = (value << 7) + ((c = getc(infile))) & 0x7f);
  		} while (c & 0x80);
 	}
	return(value);
}
*/

toneObj.cpp

#ifndef toneObj_h
#define toneObj_h

#include "timeObj.h"
#include "lists.h"
#include "idlers.h"

// The notes!

#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A2  55
#define NOTE_AS2 58
#define NOTE_B2  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A3  110
#define NOTE_AS3 117
#define NOTE_B3  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A4  220
#define NOTE_AS4 233
#define NOTE_B4  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A5  440
#define NOTE_AS5 466
#define NOTE_B5  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A6  880
#define NOTE_AS6 932
#define NOTE_B6  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A7  1760
#define NOTE_AS7 1865
#define NOTE_B7  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A8  3520
#define NOTE_AS8 3729
#define NOTE_B8  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978



// ***************************************************************************************
// Your classic tone playing object. This can tell you when the tone is finished.
// ***************************************************************************************

class toneObj : public	timeObj {

	public:
				toneObj(int inPin);
	virtual	~toneObj(void);
				
	virtual	void	play(int inHz,int inMs);
	virtual	bool	isPlaying(void);
				
				int	mPin;
};


// ***************************************************************************************
// Play a tune. basically a list of notes and rests. Use a toneObj above to play them.
// This would be a note..
// ***************************************************************************************

class note :	public linkListObj {

	public:
				note(int inHz,int inMs);
				~note(void);
			
				note* getNext(void);
				void	playSelf(toneObj* inTone,float timeMult);
				
				int	mHz;
				int	mMs;
};

				
// ***************************************************************************************
// And here is the note list, or tune. Single voice.
// ***************************************************************************************

class tune :   public idler,
               public linkList {

   public:
            tune();
   virtual  ~tune(void);

            void  addNote(int inHz,int inMs);
            void	adjustSpeed(float inTimeMult=1);
            void  startTune(toneObj* inTone,int inIndex=0);
            int  	stopTune(void);
            bool  playing(void);
   virtual  void  idle(void);

            float    mTimeMult;
            toneObj*	mTone;
            note*    mPlaying;
};

#endif