lab4 start

Lab4/gcontext.h

@@ -0,0 +1,141 @@
+#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