141 lines
4.7 KiB
C++
141 lines
4.7 KiB
C++
#ifndef GCONTEXT_H
|
|
#define GCONTEXT_H
|
|
|
|
/**
|
|
* This class is intended to be the abstract base class
|
|
* for a graphical context for various platforms. Any
|
|
* concrete subclass will need to implement the pure virtual
|
|
* methods to support setting pixels, getting pixel color,
|
|
* setting the drawing mode, and running an event loop to
|
|
* capture mouse and keyboard events directed to the graphics
|
|
* context (or window). Specific expectations for the various
|
|
* methods are documented below.
|
|
*
|
|
* */
|
|
|
|
|
|
// forward reference - needed because runLoop needs a target for events
|
|
class DrawingBase;
|
|
|
|
|
|
class GraphicsContext
|
|
{
|
|
public:
|
|
/*********************************************************
|
|
* Some constants and enums
|
|
*********************************************************/
|
|
// This enumerated type is an argument to setMode and allows
|
|
// us to support two different drawing modes. MODE_NORMAL is
|
|
// also call copy-mode and the affect pixel(s) are set to the
|
|
// color requested. XOR mode will XOR the new color with the
|
|
// existing color so that the change is reversible.
|
|
enum drawMode {MODE_NORMAL, MODE_XOR};
|
|
|
|
// Some colors - for fun
|
|
static const unsigned int BLACK = 0x000000;
|
|
static const unsigned int BLUE = 0x0000FF;
|
|
static const unsigned int GREEN = 0x00FF00;
|
|
static const unsigned int RED = 0xFF0000;
|
|
static const unsigned int CYAN = 0x00FFFF;
|
|
static const unsigned int MAGENTA = 0xFF00FF;
|
|
static const unsigned int YELLOW = 0xFFFF00;
|
|
static const unsigned int GRAY = 0x808080;
|
|
static const unsigned int WHITE = 0xFFFFFF;
|
|
|
|
|
|
/*********************************************************
|
|
* Construction / Destruction
|
|
*********************************************************/
|
|
// Implementations of this class should include a constructor
|
|
// that creates the drawing canvas (window), sets a background
|
|
// color (which may be configurable), sets a default drawing
|
|
// color (which may be configurable), and start with normal
|
|
// (copy) drawing mode.
|
|
|
|
// need a virtual destructor to ensure subclasses will have
|
|
// their destructors called properly. Must be virtual.
|
|
virtual ~GraphicsContext();
|
|
|
|
/*********************************************************
|
|
* Drawing operations
|
|
*********************************************************/
|
|
|
|
// Allows the drawing mode to be changed between normal (copy)
|
|
// and xor. The implementing context should default to normal.
|
|
virtual void setMode(drawMode newMode) = 0;
|
|
|
|
// Set the current color. Implementations should default to white.
|
|
// color is 24-bit RGB value
|
|
virtual void setColor(unsigned int color) = 0;
|
|
|
|
// Set pixel to the current color
|
|
virtual void setPixel(int x, int y) = 0;
|
|
|
|
// Get 24-bit RGB pixel color at specified location
|
|
// unsigned int will likely be 32-bit on 32-bit systems, and
|
|
// possible 64-bit on some 64-bit systems. In either case,
|
|
// it is large enough to hold a 16-bit color.
|
|
virtual unsigned int getPixel(int x, int y) = 0;
|
|
|
|
// This should reset entire context to the current background
|
|
virtual void clear()=0;
|
|
|
|
// These are the naive implementations that use setPixel,
|
|
// but are overridable should a context have a better-
|
|
// performing version available.
|
|
|
|
/* will need to be provided by the concrete
|
|
* implementation.
|
|
*
|
|
* Parameters:
|
|
* x0, y0 - origin of line
|
|
* x1, y1 - end of line
|
|
*
|
|
* Returns: void
|
|
*/
|
|
virtual void drawLine(int x0, int y0, int x1, int y1);
|
|
|
|
/* will need to be provided by the concrete
|
|
* implementation.
|
|
*
|
|
* Parameters:
|
|
* x0, y0 - origin/center of circle
|
|
* radius - radius of circle
|
|
*
|
|
* Returns: void
|
|
*/
|
|
virtual void drawCircle(int x0, int y0, unsigned int radius);
|
|
|
|
|
|
/*********************************************************
|
|
* Event loop operations
|
|
*********************************************************/
|
|
|
|
// Run Event loop. This routine will receive events from
|
|
// the implementation and pass them along to the drawing. It
|
|
// will return when the window is closed or other implementation-
|
|
// specific sequence.
|
|
virtual void runLoop(DrawingBase* drawing) = 0;
|
|
|
|
// This method will end the current loop if one is running
|
|
// a default version is supplied
|
|
virtual void endLoop();
|
|
|
|
|
|
/*********************************************************
|
|
* Utility operations
|
|
*********************************************************/
|
|
|
|
// returns the width of the window
|
|
virtual int getWindowWidth() = 0;
|
|
|
|
// returns the height of the window
|
|
virtual int getWindowHeight() = 0;
|
|
|
|
protected:
|
|
// this flag is used to control whether the event loop
|
|
// continues to run.
|
|
bool run;
|
|
};
|
|
|
|
#endif |