Updated BeOS support (Philippe Houdoin)

1 files changed, 855 insertions, 664 deletions

diff --git a/src/mesa/drivers/beos/GLView.cpp b/src/mesa/drivers/beos/GLView.cpp
index 56c1b7773b..b96b4e8289 100644
--- a/src/mesa/drivers/beos/GLView.cpp
+++ b/src/mesa/drivers/beos/GLView.cpp
@@ -1,4 +1,4 @@
-/* $Id: GLView.cpp,v 1.5 2000/11/17 21:01:26 brianp Exp $ */
+/* $Id: GLView.cpp,v 1.6 2002/09/19 16:19:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -27,6 +27,9 @@
 
 /*
  * $Log: GLView.cpp,v $
+ * Revision 1.6  2002/09/19 16:19:45  brianp
+ * Updated BeOS support (Philippe Houdoin)
+ *
  * Revision 1.5  2000/11/17 21:01:26  brianp
  * Minor header file changes to silence warnings.
  * Added _mesa_enable_sw_extensions(), called by software-only drivers
@@ -70,14 +73,39 @@
  * Initial revision
  */
 
-
+#include "glheader.h"
 
 #include <assert.h>
 #include <stdio.h>
-#include <GLView.h>
-#include "../src/context.h"
+
+extern "C" {
+
+#include "context.h"
+#include "colormac.h"
+#include "depth.h"
 #include "extensions.h"
+#include "macros.h"
+#include "matrix.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+#include "texformat.h"
+#include "texstore.h"
+#include "array_cache/acache.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
+#include "swrast/s_context.h"
+#include "swrast/s_depth.h"
+#include "swrast/s_lines.h"
+#include "swrast/s_triangle.h"
+#include "swrast/s_trispan.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
+
+}	// extern "C"
 
+#include <GLView.h>
 
 // BeOS component ordering for B_RGBA32 bitmap format
 #define BE_RCOMP 2
@@ -85,6 +113,13 @@
 #define BE_BCOMP 0
 #define BE_ACOMP 3
 
+#define PACK_B_RGBA32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
+							(color[RCOMP] << 16) | (color[ACOMP] << 24))
+
+#define PACK_B_RGB32(color) (color[BCOMP] | (color[GCOMP] << 8) | \
+							(color[RCOMP] << 16) | 0xFF000000)
+
+#define FLIP(coord) (LIBGGI_MODE(ggi_ctx->ggi_visual)->visible.y-(coord) - 1) 
 
 //
 // This object hangs off of the BGLView object.  We have to use
@@ -92,317 +127,705 @@
 // can't add new members to it).  Instead we just put all our data
 // in this class and use BGLVIew::m_gc to point to it.
 //
-class AuxInfo
+class MesaDriver
 {
 public:
-   AuxInfo();
-   ~AuxInfo();
-   void Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b);
+	MesaDriver();
+	~MesaDriver();
+	void Init(BGLView * bglview, GLcontext * c, GLvisual * v, GLframebuffer * b);
 
-   void MakeCurrent();
-   void SwapBuffers() const;
-   void CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const;
+	void LockGL();
+	void UnlockGL();
+	void SwapBuffers() const;
+	void CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const;
+	void Draw(BRect updateRect) const;
 
 private:
-   AuxInfo(const AuxInfo &rhs);  // copy constructor illegal
-   AuxInfo &operator=(const AuxInfo &rhs);  // assignment oper. illegal
-
-   GLcontext *mContext;
-   GLvisual *mVisual;
-   GLframebuffer *mBuffer;
-
-   BGLView *mBGLView;
-   BBitmap *mBitmap;
-
-   GLubyte mClearColor[4];  // buffer clear color
-   GLuint mClearIndex;      // buffer clear color index
-   GLint mBottom;           // used for flipping Y coords
-   GLint mWidth, mHeight;   // size of buffer
-
-   // Mesa device driver functions
-   static void UpdateState(GLcontext *ctx);
-   static void ClearIndex(GLcontext *ctx, GLuint index);
-   static void ClearColor(GLcontext *ctx, GLubyte r, GLubyte g,
-                          GLubyte b, GLubyte a);
-   static GLbitfield Clear(GLcontext *ctx, GLbitfield mask,
+	MesaDriver(const MesaDriver &rhs);  // copy constructor illegal
+	MesaDriver &operator=(const MesaDriver &rhs);  // assignment oper. illegal
+
+	GLcontext * 	m_glcontext;
+	GLvisual * 		m_glvisual;
+	GLframebuffer *	m_glframebuffer;
+
+	BGLView *		m_bglview;
+	BBitmap *		m_bitmap;
+
+	GLubyte 		m_clear_color[4];  // buffer clear color
+	GLuint 			m_clear_index;      // buffer clear color index
+	GLint 			m_bottom;           // used for flipping Y coords
+	GLuint 			m_width;
+	GLuint			m_height;
+	
+   // Mesa Device Driver functions
+   static void 		UpdateState(GLcontext *ctx, GLuint new_state);
+   static void 		ClearIndex(GLcontext *ctx, GLuint index);
+   static void 		ClearColor(GLcontext *ctx, const GLchan color[4]);
+   static void 		Clear(GLcontext *ctx, GLbitfield mask,
                                 GLboolean all, GLint x, GLint y,
                                 GLint width, GLint height);
-   static void ClearFront(GLcontext *ctx, GLboolean all, GLint x, GLint y,
+   static void 		ClearFront(GLcontext *ctx, GLboolean all, GLint x, GLint y,
                           GLint width, GLint height);
-   static void ClearBack(GLcontext *ctx, GLboolean all, GLint x, GLint y,
+   static void 		ClearBack(GLcontext *ctx, GLboolean all, GLint x, GLint y,
                          GLint width, GLint height);
-   static void Index(GLcontext *ctx, GLuint index);
-   static void Color(GLcontext *ctx, GLubyte r, GLubyte g,
+   static void 		Index(GLcontext *ctx, GLuint index);
+   static void 		Color(GLcontext *ctx, GLubyte r, GLubyte g,
                      GLubyte b, GLubyte a);
-   static GLboolean SetDrawBuffer(GLcontext *ctx, GLenum mode);
-   static void SetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
+   static void 		SetBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
                              GLenum mode);
-   static void GetBufferSize(GLcontext *ctgx, GLuint *width,
+   static void 		GetBufferSize(GLframebuffer * framebuffer, GLuint *width,
                              GLuint *height);
-   static const GLubyte *GetString(GLcontext *ctx, GLenum name);
+   static const GLubyte *	GetString(GLcontext *ctx, GLenum name);
 
    // Front-buffer functions
-   static void WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
                                   GLint x, GLint y,
                                   CONST GLubyte rgba[][4],
                                   const GLubyte mask[]);
-   static void WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  CONST GLubyte rgba[][3],
                                  const GLubyte mask[]);
-   static void WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
                                       GLint x, GLint y,
                                       const GLchan color[4],
                                       const GLubyte mask[]);
-   static void WriteRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteRGBAPixelsFront(const GLcontext *ctx, GLuint n,
                                     const GLint x[], const GLint y[],
                                     CONST GLubyte rgba[][4],
                                     const GLubyte mask[]);
-   static void WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
                                         const GLint x[], const GLint y[],
                                         const GLchan color[4],
                                         const GLubyte mask[]);
-   static void WriteCI32SpanFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteCI32SpanFront(const GLcontext *ctx, GLuint n,
                                   GLint x, GLint y,
                                   const GLuint index[], const GLubyte mask[]);
-   static void WriteCI8SpanFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteCI8SpanFront(const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  const GLubyte index[], const GLubyte mask[]);
-   static void WriteMonoCISpanFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteMonoCISpanFront(const GLcontext *ctx, GLuint n,
                                     GLint x, GLint y,
                                     GLuint colorIndex, const GLubyte mask[]);
-   static void WriteCI32PixelsFront(const GLcontext *ctx,
+   static void 		WriteCI32PixelsFront(const GLcontext *ctx,
                                     GLuint n, const GLint x[], const GLint y[],
                                     const GLuint index[], const GLubyte mask[]);
-   static void WriteMonoCIPixelsFront(const GLcontext *ctx, GLuint n,
+   static void 		WriteMonoCIPixelsFront(const GLcontext *ctx, GLuint n,
                                       const GLint x[], const GLint y[],
                                       GLuint colorIndex, const GLubyte mask[]);
-   static void ReadCI32SpanFront(const GLcontext *ctx,
+   static void 		ReadCI32SpanFront(const GLcontext *ctx,
                                  GLuint n, GLint x, GLint y, GLuint index[]);
-   static void ReadRGBASpanFront(const GLcontext *ctx, GLuint n,
+   static void 		ReadRGBASpanFront(const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  GLubyte rgba[][4]);
-   static void ReadCI32PixelsFront(const GLcontext *ctx,
+   static void 		ReadCI32PixelsFront(const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    GLuint indx[], const GLubyte mask[]);
-   static void ReadRGBAPixelsFront(const GLcontext *ctx,
+   static void 		ReadRGBAPixelsFront(const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    GLubyte rgba[][4], const GLubyte mask[]);
 
    // Back buffer functions
-   static void WriteRGBASpanBack(const GLcontext *ctx, GLuint n,
+   static void 		WriteRGBASpanBack(const GLcontext *ctx, GLuint n,
                                   GLint x, GLint y,
                                   CONST GLubyte rgba[][4],
                                   const GLubyte mask[]);
-   static void WriteRGBSpanBack(const GLcontext *ctx, GLuint n,
+   static void 		WriteRGBSpanBack(const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  CONST GLubyte rgba[][3],
                                  const GLubyte mask[]);
-   static void WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
+   static void 		WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
                                      GLint x, GLint y,
                                      const GLchan color[4],
                                      const GLubyte mask[]);
-   static void WriteRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+   static void 		WriteRGBAPixelsBack(const GLcontext *ctx, GLuint n,
                                    const GLint x[], const GLint y[],
                                    CONST GLubyte rgba[][4],
                                    const GLubyte mask[]);
-   static void WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+   static void 		WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
                                        const GLint x[], const GLint y[],
                                        const GLchan color[4],
                                        const GLubyte mask[]);
-   static void WriteCI32SpanBack(const GLcontext *ctx, GLuint n,
+   static void 		WriteCI32SpanBack(const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  const GLuint index[], const GLubyte mask[]);
-   static void WriteCI8SpanBack(const GLcontext *ctx, GLuint n, GLint x, GLint y,
+   static void 		WriteCI8SpanBack(const GLcontext *ctx, GLuint n, GLint x, GLint y,
                                 const GLubyte index[], const GLubyte mask[]);
-   static void WriteMonoCISpanBack(const GLcontext *ctx, GLuint n,
+   static void 		WriteMonoCISpanBack(const GLcontext *ctx, GLuint n,
                                    GLint x, GLint y, GLuint colorIndex,
                                    const GLubyte mask[]);
-   static void WriteCI32PixelsBack(const GLcontext *ctx,
+   static void 		WriteCI32PixelsBack(const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    const GLuint index[], const GLubyte mask[]);
-   static void WriteMonoCIPixelsBack(const GLcontext *ctx,
+   static void 		WriteMonoCIPixelsBack(const GLcontext *ctx,
                                      GLuint n, const GLint x[], const GLint y[],
                                      GLuint colorIndex, const GLubyte mask[]);
-   static void ReadCI32SpanBack(const GLcontext *ctx,
+   static void 		ReadCI32SpanBack(const GLcontext *ctx,
                                 GLuint n, GLint x, GLint y, GLuint index[]);
-   static void ReadRGBASpanBack(const GLcontext *ctx, GLuint n,
+   static void 		ReadRGBASpanBack(const GLcontext *ctx, GLuint n,
                                 GLint x, GLint y,
                                 GLubyte rgba[][4]);
-   static void ReadCI32PixelsBack(const GLcontext *ctx,
+   static void 		ReadCI32PixelsBack(const GLcontext *ctx,
                                   GLuint n, const GLint x[], const GLint y[],
                                   GLuint indx[], const GLubyte mask[]);
-   static void ReadRGBAPixelsBack(const GLcontext *ctx,
+   static void 		ReadRGBAPixelsBack(const GLcontext *ctx,
                                   GLuint n, const GLint x[], const GLint y[],
                                   GLubyte rgba[][4], const GLubyte mask[]);
 
 };
 
+//------------------------------------------------------------------
+// Public interface methods
+//------------------------------------------------------------------
 
 
-AuxInfo::AuxInfo()
+//
+// Input:  rect - initial rectangle
+//         name - window name
+//         resizingMode - example: B_FOLLOW_NONE
+//         mode - usually 0 ?
+//         options - Bitwise-OR of BGL_* tokens
+//
+BGLView::BGLView(BRect rect, char *name,
+                 ulong resizingMode, ulong mode,
+                 ulong options)
+   :BView(rect, name, resizingMode, mode | B_WILL_DRAW | B_FRAME_EVENTS) //  | B_FULL_UPDATE_ON_RESIZE)
 {
-   mContext = NULL;
-   mVisual = NULL;
-   mBuffer = NULL;
-   mBGLView = NULL;
-   mBitmap = NULL;
-   mClearColor[BE_RCOMP] = 0;
-   mClearColor[BE_GCOMP] = 0;
-   mClearColor[BE_BCOMP] = 0;
-   mClearColor[BE_ACOMP] = 0;
-   mClearIndex = 0;
+   const GLboolean rgbFlag = (options & BGL_RGB) == BGL_RGB;
+   const GLboolean alphaFlag = (options & BGL_ALPHA) == BGL_ALPHA;
+   const GLboolean dblFlag = (options & BGL_DOUBLE) == BGL_DOUBLE;
+   const GLboolean stereoFlag = false;
+   const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
+   const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
+   const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
+   const GLint index = (options & BGL_INDEX) ? 32 : 0;
+   const GLint red = (options & BGL_RGB) ? 8 : 0;
+   const GLint green = (options & BGL_RGB) ? 8 : 0;
+   const GLint blue = (options & BGL_RGB) ? 8 : 0;
+   const GLint alpha = (options & BGL_RGB) ? 8 : 0;
+
+   if (!rgbFlag) {
+      fprintf(stderr, "Mesa Warning: color index mode not supported\n");
+   }
+
+   // Allocate auxiliary data object
+   MesaDriver * md = new MesaDriver;
+
+   // examine option flags and create gl_context struct
+   GLvisual * visual = _mesa_create_visual( rgbFlag,
+                                            dblFlag,
+                                            stereoFlag,
+                                            red, green, blue, alpha,
+                                            index,
+                                            depth,
+                                            stencil,
+                                            accum, accum, accum, accum,
+                                            1
+                                            );
+
+	// create core context
+	__GLimports imports;
+	_mesa_init_default_imports(&imports, md);
+	GLcontext * ctx = _mesa_create_context( visual, NULL, &imports);
+
+
+   // create core framebuffer
+   GLframebuffer * buffer = _mesa_create_framebuffer(visual,
+                                              depth > 0 ? GL_TRUE : GL_FALSE,
+                                              stencil > 0 ? GL_TRUE: GL_FALSE,
+                                              accum > 0 ? GL_TRUE : GL_FALSE,
+                                              alphaFlag
+                                              );
+
+   _mesa_enable_sw_extensions(ctx);
+   _mesa_enable_1_3_extensions(ctx);
+
+   /* Initialize the software rasterizer and helper modules.
+       */
+
+	_swrast_CreateContext(ctx);
+	_ac_CreateContext(ctx);
+	_tnl_CreateContext(ctx);
+	_swsetup_CreateContext(ctx);
+	
+	_swsetup_Wakeup(ctx);
+
+   md->Init(this, ctx, visual, buffer );
+
+   // Hook aux data into BGLView object
+   m_gc = md;
 }
 
 
-AuxInfo::~AuxInfo()
+BGLView::~BGLView()
 {
+   printf("BGLView destructor\n");
+   MesaDriver * md = (MesaDriver *) m_gc;
+   assert(md);
+   delete md;
+}
 
-   _mesa_destroy_visual(mVisual);
-   _mesa_destroy_framebuffer(mBuffer);
-   _mesa_destroy_context(mContext);
+void BGLView::LockGL()
+{
+   MesaDriver * md = (MesaDriver *) m_gc;
+   assert(md);
+   md->LockGL();
 }
 
+void BGLView::UnlockGL()
+{
+   MesaDriver * md = (MesaDriver *) m_gc;
+   assert(md);
+   md->UnlockGL();
+}
 
-void AuxInfo::Init(BGLView *bglView, GLcontext *c, GLvisual *v, GLframebuffer *b)
+void BGLView::SwapBuffers()
 {
-   mBGLView = bglView;
-   mContext = c;
-   mVisual = v;
-   mBuffer = b;
+   MesaDriver * md = (MesaDriver *) m_gc;
+   assert(md);
+   md->SwapBuffers();
 }
 
 
-void AuxInfo::MakeCurrent()
+void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height)
 {
-   UpdateState(mContext);
-   _mesa_make_current(mContext, mBuffer);
+   MesaDriver * md = (MesaDriver *) m_gc;
+   assert(md);
+   md->CopySubBuffer(x, y, width, height);
 }
 
 
-void AuxInfo::SwapBuffers() const
+BView *	BGLView::EmbeddedView()
 {
-   if (mBitmap) {
-      mBGLView->DrawBitmap(mBitmap, BPoint(0, 0));
-   }
+   // XXX to do
+	return NULL;
+}
+
+status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
+{
+   // XXX to do
+	printf("BGLView::CopyPixelsOut() not implemented yet!\n");
+	return B_UNSUPPORTED;
 }
 
 
-void AuxInfo::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const
+status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
+{
+   // XXX to do
+	printf("BGLView::CopyPixelsIn() not implemented yet!\n");
+	return B_UNSUPPORTED;
+}
+
+void BGLView::ErrorCallback(unsigned long errorCode) // GLenum errorCode)
+{
+   // XXX to do
+	printf("BGLView::ErrorCallback() not implemented yet!\n");
+	return;
+}
+
+void BGLView::Draw(BRect updateRect)
+{
+   // printf("BGLView::Draw()\n");
+   MesaDriver * md = (MesaDriver *) m_gc;
+   assert(md);
+   md->Draw(updateRect);
+}
+
+void BGLView::AttachedToWindow()
+{
+   BView::AttachedToWindow();
+
+   // don't paint window background white when resized
+   SetViewColor(B_TRANSPARENT_32_BIT);
+}
+
+void BGLView::AllAttached()
+{
+   BView::AllAttached();
+//   printf("BGLView AllAttached\n");
+}
+
+void BGLView::DetachedFromWindow()
+{
+   BView::DetachedFromWindow();
+}
+
+void BGLView::AllDetached()
+{
+   BView::AllDetached();
+//   printf("BGLView AllDetached");
+}
+
+void BGLView::FrameResized(float width, float height)
+{
+   return BView::FrameResized(width, height);
+}
+
+status_t BGLView::Perform(perform_code d, void *arg)
+{
+   return BView::Perform(d, arg);
+}
+
+
+status_t BGLView::Archive(BMessage *data, bool deep) const
+{
+   return BView::Archive(data, deep);
+}
+
+void BGLView::MessageReceived(BMessage *msg)
+{
+   BView::MessageReceived(msg);
+}
+
+void BGLView::SetResizingMode(uint32 mode)
+{
+   BView::SetResizingMode(mode);
+}
+
+void BGLView::Show()
+{
+//   printf("BGLView Show\n");
+   BView::Show();
+}
+
+void BGLView::Hide()
+{
+//   printf("BGLView Hide\n");
+   BView::Hide();
+}
+
+BHandler *BGLView::ResolveSpecifier(BMessage *msg, int32 index,
+                                    BMessage *specifier, int32 form,
+                                    const char *property)
 {
-   if (mBitmap) {
+   return BView::ResolveSpecifier(msg, index, specifier, form, property);
+}
+
+status_t BGLView::GetSupportedSuites(BMessage *data)
+{
+   return BView::GetSupportedSuites(data);
+}
+
+void BGLView::DirectConnected( direct_buffer_info *info )
+{
+   // XXX to do
+}
+
+void BGLView::EnableDirectMode( bool enabled )
+{
+   // XXX to do
+}
+
+
+
+//---- private methods ----------
+
+void BGLView::_ReservedGLView1() {}
+void BGLView::_ReservedGLView2() {}
+void BGLView::_ReservedGLView3() {}
+void BGLView::_ReservedGLView4() {}
+void BGLView::_ReservedGLView5() {}
+void BGLView::_ReservedGLView6() {}
+void BGLView::_ReservedGLView7() {}
+void BGLView::_ReservedGLView8() {}
+
+#if 0
+BGLView::BGLView(const BGLView &v)
+	: BView(v)
+{
+   // XXX not sure how this should work
+   printf("Warning BGLView::copy constructor not implemented\n");
+}
+#endif
+
+
+BGLView &BGLView::operator=(const BGLView &v)
+{
+   printf("Warning BGLView::operator= not implemented\n");
+	return *this;
+}
+
+void BGLView::dither_front()
+{
+   // no-op
+}
+
+bool BGLView::confirm_dither()
+{
+   // no-op
+   return false;
+}
+
+void BGLView::draw(BRect r)
+{
+   // XXX no-op ???
+}
+
+/* Direct Window stuff */
+void BGLView::drawScanline( int x1, int x2, int y, void *data )
+{
+   // no-op
+}
+
+void BGLView::scanlineHandler(struct rasStateRec *state,
+                              GLint x1, GLint x2)
+{
+   // no-op
+}
+
+void BGLView::lock_draw()
+{
+   // no-op
+}
+
+void BGLView::unlock_draw()
+{
+   // no-op
+}
+
+bool BGLView::validateView()
+{
+   // no-op
+   return true;
+}
+
+// #pragma mark -
+
+MesaDriver::MesaDriver()
+{
+   m_glcontext 		= NULL;
+   m_glvisual		= NULL;
+   m_glframebuffer 	= NULL;
+   m_bglview 		= NULL;
+   m_bitmap 		= NULL;
+
+   m_clear_color[BE_RCOMP] = 0;
+   m_clear_color[BE_GCOMP] = 0;
+   m_clear_color[BE_BCOMP] = 0;
+   m_clear_color[BE_ACOMP] = 0;
+
+   m_clear_index = 0;
+}
+
+
+MesaDriver::~MesaDriver()
+{
+   _mesa_destroy_visual(m_glvisual);
+   _mesa_destroy_framebuffer(m_glframebuffer);
+   _mesa_destroy_context(m_glcontext);
+
+}
+
+
+void MesaDriver::Init(BGLView * bglview, GLcontext * ctx, GLvisual * visual, GLframebuffer * framebuffer)
+{
+	m_bglview 		= bglview;
+	m_glcontext 	= ctx;
+	m_glvisual 		= visual;
+	m_glframebuffer = framebuffer;
+
+	MesaDriver * md = (MesaDriver *) ctx->DriverCtx;
+	struct swrast_device_driver * swdd = _swrast_GetDeviceDriverReference( ctx );
+	TNLcontext * tnl = TNL_CONTEXT(ctx);
+
+	assert(md->m_glcontext == ctx );
+
+	ctx->Driver.GetString = MesaDriver::GetString;
+	ctx->Driver.UpdateState = MesaDriver::UpdateState;
+	ctx->Driver.GetBufferSize = MesaDriver::GetBufferSize;
+	ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;
+
+	ctx->Driver.Accum = _swrast_Accum;
+	ctx->Driver.Bitmap = _swrast_Bitmap;
+	ctx->Driver.ClearIndex = MesaDriver::ClearIndex;
+	ctx->Driver.ClearColor = MesaDriver::ClearColor;
+	ctx->Driver.Clear = MesaDriver::Clear;
+	ctx->Driver.CopyPixels = _swrast_CopyPixels;
+   	ctx->Driver.DrawPixels = _swrast_DrawPixels;
+   	ctx->Driver.ReadPixels = _swrast_ReadPixels;
+
+   	ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
+   	ctx->Driver.TexImage1D = _mesa_store_teximage1d;
+   	ctx->Driver.TexImage2D = _mesa_store_teximage2d;
+   	ctx->Driver.TexImage3D = _mesa_store_teximage3d;
+   	ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
+   	ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
+   	ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
+   	ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
+
+   	ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
+   	ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
+   	ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
+   	ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
+   	ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
+   	ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
+   	ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
+   	ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
+   	ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
+
+   	ctx->Driver.BaseCompressedTexFormat = _mesa_base_compressed_texformat;
+   	ctx->Driver.CompressedTextureSize = _mesa_compressed_texture_size;
+   	ctx->Driver.GetCompressedTexImage = _mesa_get_compressed_teximage;
+
+	swdd->SetBuffer = MesaDriver::SetBuffer;
+
+	tnl->Driver.RunPipeline = _tnl_run_pipeline;
+
+	_swsetup_Wakeup(ctx);
+}
+
+
+void MesaDriver::LockGL()
+{
+	m_bglview->LockLooper();
+
+   UpdateState(m_glcontext, 0);
+   _mesa_make_current(m_glcontext, m_glframebuffer);
+}
+
+
+void MesaDriver::UnlockGL()
+{
+	m_bglview->UnlockLooper();
+   // Could call _mesa_make_current(NULL, NULL) but it would just
+   // hinder performance
+}
+
+
+void MesaDriver::SwapBuffers() const
+{
+	// _mesa_swap_buffers();
+
+	if (m_bitmap) {
+		m_bglview->LockLooper();
+		m_bglview->DrawBitmap(m_bitmap, BPoint(0, 0));
+		m_bglview->UnlockLooper();
+	};
+}
+
+
+void MesaDriver::CopySubBuffer(GLint x, GLint y, GLuint width, GLuint height) const
+{
+   if (m_bitmap) {
       // Source bitmap and view's bitmap are same size.
       // Source and dest rectangle are the same.
       // Note (x,y) = (0,0) is the lower-left corner, have to flip Y
       BRect srcAndDest;
       srcAndDest.left = x;
       srcAndDest.right = x + width - 1;
-      srcAndDest.bottom = mBottom - y;
+      srcAndDest.bottom = m_bottom - y;
       srcAndDest.top = srcAndDest.bottom - height + 1;
-      mBGLView->DrawBitmap(mBitmap, srcAndDest, srcAndDest);
+      m_bglview->DrawBitmap(m_bitmap, srcAndDest, srcAndDest);
    }
 }
 
 
-void AuxInfo::UpdateState( GLcontext *ctx )
+void MesaDriver::Draw(BRect updateRect) const
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
+   if (m_bitmap)
+      m_bglview->DrawBitmap(m_bitmap, updateRect, updateRect);
+}
 
-   assert(aux->mContext == ctx );
 
-   ctx->Driver.UpdateState = AuxInfo::UpdateState;
-   ctx->Driver.SetDrawBuffer = AuxInfo::SetDrawBuffer;
-   ctx->Driver.SetReadBuffer = AuxInfo::SetReadBuffer;
-   ctx->Driver.ClearIndex = AuxInfo::ClearIndex;
-   ctx->Driver.ClearColor = AuxInfo::ClearColor;
-   ctx->Driver.GetBufferSize = AuxInfo::GetBufferSize;
-   ctx->Driver.GetString = AuxInfo::GetString;
-   ctx->Driver.Clear = AuxInfo::Clear;
+void MesaDriver::UpdateState( GLcontext *ctx, GLuint new_state )
+{
+	struct swrast_device_driver *	swdd = _swrast_GetDeviceDriverReference( ctx );
+
+	_swrast_InvalidateState( ctx, new_state );
+	_swsetup_InvalidateState( ctx, new_state );
+	_ac_InvalidateState( ctx, new_state );
+	_tnl_InvalidateState( ctx, new_state );
 
-   if (ctx->Color.DrawBuffer == GL_FRONT) {
+	if (ctx->Color.DrawBuffer == GL_FRONT) {
       /* read/write front buffer */
-      ctx->Driver.WriteRGBASpan = AuxInfo::WriteRGBASpanFront;
-      ctx->Driver.WriteRGBSpan = AuxInfo::WriteRGBSpanFront;
-      ctx->Driver.WriteRGBAPixels = AuxInfo::WriteRGBAPixelsFront;
-      ctx->Driver.WriteMonoRGBASpan = AuxInfo::WriteMonoRGBASpanFront;
-      ctx->Driver.WriteMonoRGBAPixels = AuxInfo::WriteMonoRGBAPixelsFront;
-      ctx->Driver.WriteCI32Span = AuxInfo::WriteCI32SpanFront;
-      ctx->Driver.WriteCI8Span = AuxInfo::WriteCI8SpanFront;
-      ctx->Driver.WriteMonoCISpan = AuxInfo::WriteMonoCISpanFront;
-      ctx->Driver.WriteCI32Pixels = AuxInfo::WriteCI32PixelsFront;
-      ctx->Driver.WriteMonoCIPixels = AuxInfo::WriteMonoCIPixelsFront;
-      ctx->Driver.ReadRGBASpan = AuxInfo::ReadRGBASpanFront;
-      ctx->Driver.ReadRGBAPixels = AuxInfo::ReadRGBAPixelsFront;
-      ctx->Driver.ReadCI32Span = AuxInfo::ReadCI32SpanFront;
-      ctx->Driver.ReadCI32Pixels = AuxInfo::ReadCI32PixelsFront;
+      swdd->WriteRGBASpan = MesaDriver::WriteRGBASpanFront;
+      swdd->WriteRGBSpan = MesaDriver::WriteRGBSpanFront;
+      swdd->WriteRGBAPixels = MesaDriver::WriteRGBAPixelsFront;
+      swdd->WriteMonoRGBASpan = MesaDriver::WriteMonoRGBASpanFront;
+      swdd->WriteMonoRGBAPixels = MesaDriver::WriteMonoRGBAPixelsFront;
+      swdd->WriteCI32Span = MesaDriver::WriteCI32SpanFront;
+      swdd->WriteCI8Span = MesaDriver::WriteCI8SpanFront;
+      swdd->WriteMonoCISpan = MesaDriver::WriteMonoCISpanFront;
+      swdd->WriteCI32Pixels = MesaDriver::WriteCI32PixelsFront;
+      swdd->WriteMonoCIPixels = MesaDriver::WriteMonoCIPixelsFront;
+      swdd->ReadRGBASpan = MesaDriver::ReadRGBASpanFront;
+      swdd->ReadRGBAPixels = MesaDriver::ReadRGBAPixelsFront;
+      swdd->ReadCI32Span = MesaDriver::ReadCI32SpanFront;
+      swdd->ReadCI32Pixels = MesaDriver::ReadCI32PixelsFront;
    }
    else {
       /* read/write back buffer */
-      ctx->Driver.WriteRGBASpan = AuxInfo::WriteRGBASpanBack;
-      ctx->Driver.WriteRGBSpan = AuxInfo::WriteRGBSpanBack;
-      ctx->Driver.WriteRGBAPixels = AuxInfo::WriteRGBAPixelsBack;
-      ctx->Driver.WriteMonoRGBASpan = AuxInfo::WriteMonoRGBASpanBack;
-      ctx->Driver.WriteMonoRGBAPixels = AuxInfo::WriteMonoRGBAPixelsBack;
-      ctx->Driver.WriteCI32Span = AuxInfo::WriteCI32SpanBack;
-      ctx->Driver.WriteCI8Span = AuxInfo::WriteCI8SpanBack;
-      ctx->Driver.WriteMonoCISpan = AuxInfo::WriteMonoCISpanBack;
-      ctx->Driver.WriteCI32Pixels = AuxInfo::WriteCI32PixelsBack;
-      ctx->Driver.WriteMonoCIPixels = AuxInfo::WriteMonoCIPixelsBack;
-      ctx->Driver.ReadRGBASpan = AuxInfo::ReadRGBASpanBack;
-      ctx->Driver.ReadRGBAPixels = AuxInfo::ReadRGBAPixelsBack;
-      ctx->Driver.ReadCI32Span = AuxInfo::ReadCI32SpanBack;
-      ctx->Driver.ReadCI32Pixels = AuxInfo::ReadCI32PixelsBack;
+      swdd->WriteRGBASpan = MesaDriver::WriteRGBASpanBack;
+      swdd->WriteRGBSpan = MesaDriver::WriteRGBSpanBack;
+      swdd->WriteRGBAPixels = MesaDriver::WriteRGBAPixelsBack;
+      swdd->WriteMonoRGBASpan = MesaDriver::WriteMonoRGBASpanBack;
+      swdd->WriteMonoRGBAPixels = MesaDriver::WriteMonoRGBAPixelsBack;
+      swdd->WriteCI32Span = MesaDriver::WriteCI32SpanBack;
+      swdd->WriteCI8Span = MesaDriver::WriteCI8SpanBack;
+      swdd->WriteMonoCISpan = MesaDriver::WriteMonoCISpanBack;
+      swdd->WriteCI32Pixels = MesaDriver::WriteCI32PixelsBack;
+      swdd->WriteMonoCIPixels = MesaDriver::WriteMonoCIPixelsBack;
+      swdd->ReadRGBASpan = MesaDriver::ReadRGBASpanBack;
+      swdd->ReadRGBAPixels = MesaDriver::ReadRGBAPixelsBack;
+      swdd->ReadCI32Span = MesaDriver::ReadCI32SpanBack;
+      swdd->ReadCI32Pixels = MesaDriver::ReadCI32PixelsBack;
     }
 }
 
 
-void AuxInfo::ClearIndex(GLcontext *ctx, GLuint index)
+void MesaDriver::ClearIndex(GLcontext *ctx, GLuint index)
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   aux->mClearIndex = index;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   md->m_clear_index = index;
 }
 
 
-void AuxInfo::ClearColor(GLcontext *ctx, GLubyte r, GLubyte g,
-                         GLubyte b, GLubyte a)
+void MesaDriver::ClearColor(GLcontext *ctx, const GLchan color[4])
+						// GLubyte r, GLubyte g,
+                        // GLubyte b, GLubyte a)
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   aux->mClearColor[BE_RCOMP] = r;
-   aux->mClearColor[BE_GCOMP] = g;
-   aux->mClearColor[BE_BCOMP] = b;
-   aux->mClearColor[BE_ACOMP] = a;
-   assert(aux->mBGLView);
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   md->m_clear_color[BE_RCOMP] = color[0];
+   md->m_clear_color[BE_GCOMP] = color[1];
+   md->m_clear_color[BE_BCOMP] = color[2];
+   md->m_clear_color[BE_ACOMP] = color[3];
+   assert(md->m_bglview);
 }
 
 
-GLbitfield AuxInfo::Clear(GLcontext *ctx, GLbitfield mask,
+void MesaDriver::Clear(GLcontext *ctx, GLbitfield mask,
                                GLboolean all, GLint x, GLint y,
                                GLint width, GLint height)
 {
    if (mask & DD_FRONT_LEFT_BIT)
-      ClearFront(ctx, all, x, y, width, height);
+		ClearFront(ctx, all, x, y, width, height);
    if (mask & DD_BACK_LEFT_BIT)
-      ClearBack(ctx, all, x, y, width, height);
-   return mask & ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT);
+		ClearBack(ctx, all, x, y, width, height);
+
+	mask &= ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT);
+	if (mask)
+		_swrast_Clear( ctx, mask, all, x, y, width, height );
+
+   return;
 }
 
 
-void AuxInfo::ClearFront(GLcontext *ctx,
+void MesaDriver::ClearFront(GLcontext *ctx,
                          GLboolean all, GLint x, GLint y,
                          GLint width, GLint height)
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
 
-   bglview->SetHighColor(aux->mClearColor[BE_RCOMP],
-                         aux->mClearColor[BE_GCOMP],
-                         aux->mClearColor[BE_BCOMP],
-                         aux->mClearColor[BE_ACOMP]);
-   bglview->SetLowColor(aux->mClearColor[BE_RCOMP],
-                        aux->mClearColor[BE_GCOMP],
-                        aux->mClearColor[BE_BCOMP],
-                        aux->mClearColor[BE_ACOMP]);
+   bglview->SetHighColor(md->m_clear_color[BE_RCOMP],
+                         md->m_clear_color[BE_GCOMP],
+                         md->m_clear_color[BE_BCOMP],
+                         md->m_clear_color[BE_ACOMP]);
+   bglview->SetLowColor(md->m_clear_color[BE_RCOMP],
+                        md->m_clear_color[BE_GCOMP],
+                        md->m_clear_color[BE_BCOMP],
+                        md->m_clear_color[BE_ACOMP]);
    if (all) {
       BRect b = bglview->Bounds();
       bglview->FillRect(b);
@@ -412,40 +835,40 @@ void AuxInfo::ClearFront(GLcontext *ctx,
       BRect b;
       b.left = x;
       b.right = x + width;
-      b.bottom = aux->mHeight - y - 1;
+      b.bottom = md->m_height - y - 1;
       b.top = b.bottom - height;
       bglview->FillRect(b);
    }
 
    // restore drawing color
 #if 0
-   bglview->SetHighColor(aux->mColor[BE_RCOMP],
-                         aux->mColor[BE_GCOMP],
-                         aux->mColor[BE_BCOMP],
-                         aux->mColor[BE_ACOMP]);
-   bglview->SetLowColor(aux->mColor[BE_RCOMP],
-                        aux->mColor[BE_GCOMP],
-                        aux->mColor[BE_BCOMP],
-                        aux->mColor[BE_ACOMP]);
+   bglview->SetHighColor(md->mColor[BE_RCOMP],
+                         md->mColor[BE_GCOMP],
+                         md->mColor[BE_BCOMP],
+                         md->mColor[BE_ACOMP]);
+   bglview->SetLowColor(md->mColor[BE_RCOMP],
+                        md->mColor[BE_GCOMP],
+                        md->mColor[BE_BCOMP],
+                        md->mColor[BE_ACOMP]);
 #endif
 }
 
 
-void AuxInfo::ClearBack(GLcontext *ctx,
+void MesaDriver::ClearBack(GLcontext *ctx,
                         GLboolean all, GLint x, GLint y,
                         GLint width, GLint height)
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
-   BBitmap *bitmap = aux->mBitmap;
+   BBitmap *bitmap = md->m_bitmap;
    assert(bitmap);
    GLuint *start = (GLuint *) bitmap->Bits();
-   const GLuint *clearPixelPtr = (const GLuint *) aux->mClearColor;
+   const GLuint *clearPixelPtr = (const GLuint *) md->m_clear_color;
    const GLuint clearPixel = *clearPixelPtr;
 
    if (all) {
-      const int numPixels = aux->mWidth * aux->mHeight;
+      const int numPixels = md->m_width * md->m_height;
       if (clearPixel == 0) {
          memset(start, 0, numPixels * 4);
       }
@@ -457,68 +880,66 @@ void AuxInfo::ClearBack(GLcontext *ctx,
    }
    else {
       // XXX untested
-      start += y * aux->mWidth + x;
+      start += y * md->m_width + x;
       for (int i = 0; i < height; i++) {
          for (int j = 0; j < width; j++) {
             start[j] = clearPixel;
          }
-         start += aux->mWidth;
+         start += md->m_width;
       }
    }
 }
 
 
-GLboolean AuxInfo::SetDrawBuffer(GLcontext *ctx, GLenum buffer)
-{
-   if (buffer == GL_FRONT_LEFT)
-      return GL_TRUE;
-   else if (buffer == GL_BACK_LEFT)
-      return GL_TRUE;
-   else
-      return GL_FALSE;
-}
-
-void AuxInfo::SetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
-                            GLenum buffer)
+void MesaDriver::SetBuffer(GLcontext *ctx, GLframebuffer *buffer,
+                            GLenum mode)
 {
-   /* XXX to do */
+   /* TODO */
+	(void) ctx;
+	(void) buffer;
+	(void) mode;
 }
 
-void AuxInfo::GetBufferSize(GLcontext *ctx, GLuint *width,
+void MesaDriver::GetBufferSize(GLframebuffer * framebuffer, GLuint *width,
                             GLuint *height)
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   GET_CURRENT_CONTEXT(ctx);
+   if (!ctx)
+		return;
+
+   MesaDriver * md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
+
    BRect b = bglview->Bounds();
-   *width = (GLuint) (b.right - b.left + 1);
-   *height = (GLuint) (b.bottom - b.top + 1);
-   aux->mBottom = (GLint) b.bottom;
+   *width = (GLuint) b.IntegerWidth() + 1; // (b.right - b.left + 1);
+   *height = (GLuint) b.IntegerHeight() + 1; // (b.bottom - b.top + 1);
+   md->m_bottom = (GLint) b.bottom;
 
-   if (ctx->Visual->DBflag) {
-      if (*width != aux->mWidth || *height != aux->mHeight) {
+   if (ctx->Visual.doubleBufferMode) {
+      if (*width != md->m_width || *height != md->m_height) {
          // allocate new size of back buffer bitmap
-         if (aux->mBitmap)
-            delete aux->mBitmap;
+         if (md->m_bitmap)
+            delete md->m_bitmap;
          BRect rect(0.0, 0.0, *width - 1, *height - 1);
-         aux->mBitmap = new BBitmap(rect, B_RGBA32);
+         md->m_bitmap = new BBitmap(rect, B_RGBA32);
       }
    }
    else
    {
-      aux->mBitmap = NULL;
+      md->m_bitmap = NULL;
    }
 
-   aux->mWidth = *width;
-   aux->mHeight = *height;
+   md->m_width = *width;
+   md->m_height = *height;
 }
 
 
-const GLubyte *AuxInfo::GetString(GLcontext *ctx, GLenum name)
+const GLubyte *MesaDriver::GetString(GLcontext *ctx, GLenum name)
 {
    switch (name) {
       case GL_RENDERER:
-         return (const GLubyte *) "Mesa BeOS";
+         return (const GLubyte *) "Mesa BGLView (software)";
       default:
          // Let core library handle all other cases
          return NULL;
@@ -536,15 +957,15 @@ static void Plot(BGLView *bglview, int x, int y)
 }
 
 
-void AuxInfo::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  CONST GLubyte rgba[][4],
                                  const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
-   int flippedY = aux->mBottom - y;
+   int flippedY = md->m_bottom - y;
    if (mask) {
       for (GLuint i = 0; i < n; i++) {
          if (mask[i]) {
@@ -561,15 +982,15 @@ void AuxInfo::WriteRGBASpanFront(const GLcontext *ctx, GLuint n,
    }
 }
 
-void AuxInfo::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
                                 GLint x, GLint y,
                                 CONST GLubyte rgba[][3],
                                 const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
-   int flippedY = aux->mBottom - y;
+   int flippedY = md->m_bottom - y;
    if (mask) {
       for (GLuint i = 0; i < n; i++) {
          if (mask[i]) {
@@ -586,15 +1007,15 @@ void AuxInfo::WriteRGBSpanFront(const GLcontext *ctx, GLuint n,
    }
 }
 
-void AuxInfo::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
                                      GLint x, GLint y,
                                      const GLchan color[4],
                                      const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
-   int flippedY = aux->mBottom - y;
+   int flippedY = md->m_bottom - y;
    bglview->SetHighColor(color[RCOMP], color[GCOMP], color[BCOMP]);
    if (mask) {
       for (GLuint i = 0; i < n; i++) {
@@ -610,69 +1031,69 @@ void AuxInfo::WriteMonoRGBASpanFront(const GLcontext *ctx, GLuint n,
    }
 }
 
-void AuxInfo::WriteRGBAPixelsFront(const GLcontext *ctx,
+void MesaDriver::WriteRGBAPixelsFront(const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    CONST GLubyte rgba[][4],
                                    const GLubyte mask[] )
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
    if (mask) {
       for (GLuint i = 0; i < n; i++) {
          if (mask[i]) {
             bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]);
-            Plot(bglview, x[i], aux->mBottom - y[i]);
+            Plot(bglview, x[i], md->m_bottom - y[i]);
          }
       }
    }
    else {
       for (GLuint i = 0; i < n; i++) {
          bglview->SetHighColor(rgba[i][0], rgba[i][1], rgba[i][2]);
-         Plot(bglview, x[i], aux->mBottom - y[i]);
+         Plot(bglview, x[i], md->m_bottom - y[i]);
       }
    }
 }
 
 
-void AuxInfo::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBAPixelsFront(const GLcontext *ctx, GLuint n,
                                        const GLint x[], const GLint y[],
                                        const GLchan color[4],
                                        const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BGLView *bglview = aux->mBGLView;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BGLView *bglview = md->m_bglview;
    assert(bglview);
    // plot points using current color
    bglview->SetHighColor(color[RCOMP], color[GCOMP], color[BCOMP]);
    if (mask) {
       for (GLuint i = 0; i < n; i++) {
          if (mask[i]) {
-            Plot(bglview, x[i], aux->mBottom - y[i]);
+            Plot(bglview, x[i], md->m_bottom - y[i]);
          }
       }
    }
    else {
       for (GLuint i = 0; i < n; i++) {
-         Plot(bglview, x[i], aux->mBottom - y[i]);
+         Plot(bglview, x[i], md->m_bottom - y[i]);
       }
    }
 }
 
 
-void AuxInfo::WriteCI32SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+void MesaDriver::WriteCI32SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
                              const GLuint index[], const GLubyte mask[] )
 {
    // XXX to do
 }
 
-void AuxInfo::WriteCI8SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+void MesaDriver::WriteCI8SpanFront( const GLcontext *ctx, GLuint n, GLint x, GLint y,
                             const GLubyte index[], const GLubyte mask[] )
 {
    // XXX to do
 }
 
-void AuxInfo::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
                                     GLint x, GLint y,
                                     GLuint colorIndex, const GLubyte mask[] )
 {
@@ -680,14 +1101,14 @@ void AuxInfo::WriteMonoCISpanFront( const GLcontext *ctx, GLuint n,
 }
 
 
-void AuxInfo::WriteCI32PixelsFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI32PixelsFront( const GLcontext *ctx, GLuint n,
                                     const GLint x[], const GLint y[],
                                     const GLuint index[], const GLubyte mask[] )
 {
    // XXX to do
 }
 
-void AuxInfo::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
                                       const GLint x[], const GLint y[],
                                       GLuint colorIndex, const GLubyte mask[] )
 {
@@ -695,147 +1116,182 @@ void AuxInfo::WriteMonoCIPixelsFront( const GLcontext *ctx, GLuint n,
 }
 
 
-void AuxInfo::ReadCI32SpanFront( const GLcontext *ctx,
+void MesaDriver::ReadCI32SpanFront( const GLcontext *ctx,
                                  GLuint n, GLint x, GLint y, GLuint index[] )
 {
-   // XXX to do
+ 	printf("ReadCI32SpanFront() not implemented yet!\n");
+  // XXX to do
 }
 
 
-void AuxInfo::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
+void MesaDriver::ReadRGBASpanFront( const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y, GLubyte rgba[][4] )
 {
+ 	printf("ReadRGBASpanFront() not implemented yet!\n");
    // XXX to do
 }
 
 
-void AuxInfo::ReadCI32PixelsFront( const GLcontext *ctx,
+void MesaDriver::ReadCI32PixelsFront( const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    GLuint indx[], const GLubyte mask[] )
 {
+ 	printf("ReadCI32PixelsFront() not implemented yet!\n");
    // XXX to do
 }
 
 
-void AuxInfo::ReadRGBAPixelsFront( const GLcontext *ctx,
+void MesaDriver::ReadRGBAPixelsFront( const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    GLubyte rgba[][4], const GLubyte mask[] )
 {
+ 	printf("ReadRGBAPixelsFront() not implemented yet!\n");
    // XXX to do
 }
 
 
 
 
-void AuxInfo::WriteRGBASpanBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteRGBASpanBack(const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  CONST GLubyte rgba[][4],
                                  const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BBitmap *bitmap = aux->mBitmap;
-   assert(bitmap);
-   int row = aux->mBottom - y;
-   GLubyte *pixel = (GLubyte *) bitmap->Bits() + (row * aux->mWidth + x) * 4;
-   if (mask) {
-      for (GLuint i = 0; i < n; i++) {
-         if (mask[i]) {
-            pixel[BE_RCOMP] = rgba[i][RCOMP];
-            pixel[BE_GCOMP] = rgba[i][GCOMP];
-            pixel[BE_BCOMP] = rgba[i][BCOMP];
-            pixel[BE_ACOMP] = rgba[i][ACOMP];
-         }
-         pixel += 4;
-      }
-   }
-   else {
-      for (GLuint i = 0; i < n; i++) {
-         pixel[BE_RCOMP] = rgba[i][RCOMP];
-         pixel[BE_GCOMP] = rgba[i][GCOMP];
-         pixel[BE_BCOMP] = rgba[i][BCOMP];
-         pixel[BE_ACOMP] = rgba[i][ACOMP];
-         pixel += 4;
-      }
-   }
-}
-
-
-void AuxInfo::WriteRGBSpanBack(const GLcontext *ctx, GLuint n,
+	MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+	BBitmap *bitmap = md->m_bitmap;
+
+	static bool already_called = false;
+	if (! already_called) {
+		printf("WriteRGBASpanBack() called.\n");
+		already_called = true;
+	}
+
+	assert(bitmap);
+
+	int row = md->m_bottom - y;
+	uint8 * ptr = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + x * 4;
+ 	uint32 * pixel = (uint32 *) ptr;
+	
+	if (mask) {
+		while(n--) {
+			if (*mask++)
+				*pixel = PACK_B_RGBA32(rgba[0]);
+			pixel++;
+			rgba++;
+		};
+	} else {
+		while(n--) {
+			*pixel++ = PACK_B_RGBA32(rgba[0]);
+			rgba++;
+		};
+	};
+ }
+
+
+void MesaDriver::WriteRGBSpanBack(const GLcontext *ctx, GLuint n,
                                 GLint x, GLint y,
                                 CONST GLubyte rgb[][3],
                                 const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BBitmap *bitmap = aux->mBitmap;
-   assert(bitmap);
-   int row = aux->mBottom - y;
-   GLubyte *pixel = (GLubyte *) bitmap->Bits() + (row * aux->mWidth + x) * 4;
-   if (mask) {
-      for (GLuint i = 0; i < n; i++) {
-         if (mask[i]) {
-            pixel[BE_RCOMP] = rgb[i][RCOMP];
-            pixel[BE_GCOMP] = rgb[i][GCOMP];
-            pixel[BE_BCOMP] = rgb[i][BCOMP];
-            pixel[BE_ACOMP] = 255;
-         }
-         pixel += 4;
-      }
-   }
-   else {
-      for (GLuint i = 0; i < n; i++) {
-         pixel[BE_RCOMP] = rgb[i][RCOMP];
-         pixel[BE_GCOMP] = rgb[i][GCOMP];
-         pixel[BE_BCOMP] = rgb[i][BCOMP];
-         pixel[BE_ACOMP] = 255;
-         pixel += 4;
-      }
-   }
+	MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+	BBitmap *bitmap = md->m_bitmap;
+
+	static bool already_called = false;
+	if (! already_called) {
+		printf("WriteRGBSpanBack() called.\n");
+		already_called = true;
+	}
+
+	assert(bitmap);
+
+	int row = md->m_bottom - y;
+	uint8 * ptr = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + x * 4;
+ 	uint32 * pixel = (uint32 *) ptr;
+	
+	if (mask) {
+		while(n--) {
+			if (*mask++)
+				*pixel = PACK_B_RGB32(rgb[0]);
+			pixel++;
+			rgb++;
+		};
+	} else {
+		while(n--) {
+			*pixel++ = PACK_B_RGB32(rgb[0]);
+			rgb++;
+		};
+	};
 }
 
 
-void AuxInfo::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
+
+
+void MesaDriver::WriteMonoRGBASpanBack(const GLcontext *ctx, GLuint n,
                                     GLint x, GLint y,
                                     const GLchan color[4], const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BBitmap *bitmap = aux->mBitmap;
-   assert(bitmap);
-   int row = aux->mBottom - y;
-   GLuint *pixelPtr = (GLuint *) bitmap->Bits() + row * aux->mWidth + x;
-   GLuint pixel;
-   GLubyte *mColor= (GLubyte *) &pixel;
-   mColor[BE_RCOMP] = color[RCOMP];
-   mColor[BE_GCOMP] = color[GCOMP];
-   mColor[BE_BCOMP] = color[BCOMP];
-   mColor[BE_ACOMP] = color[ACOMP];
-   if (mask) {
-      for (GLuint i = 0; i < n; i++) {
-         if (mask[i])
-            *pixelPtr = pixel;
-         pixelPtr++;
-      }
-   }
-   else {
-      for (GLuint i = 0; i < n; i++) {
-         *pixelPtr++ = pixel;
-      }
-   }
-}
-
-
-void AuxInfo::WriteRGBAPixelsBack(const GLcontext *ctx,
+	MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+	BBitmap *bitmap = md->m_bitmap;
+
+	static bool already_called = false;
+	if (! already_called) {
+		printf("WriteMonoRGBASpanBack() called.\n");
+		already_called = true;
+	}
+
+	assert(bitmap);
+
+	int row = md->m_bottom - y;
+	uint8 * ptr = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + x * 4;
+ 	uint32 * pixel = (uint32 *) ptr;
+	uint32 pixel_color = PACK_B_RGBA32(color);
+	
+	if (mask) {
+		while(n--) {
+			if (*mask++)
+				*pixel = pixel_color;
+			pixel++;
+		};
+	} else {
+		while(n--) {
+			*pixel++ = pixel_color;
+		};
+	};
+}
+
+
+void MesaDriver::WriteRGBAPixelsBack(const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    CONST GLubyte rgba[][4],
                                    const GLubyte mask[] )
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BBitmap *bitmap = aux->mBitmap;
-   assert(bitmap);
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   BBitmap *bitmap = md->m_bitmap;
+
+	static bool already_called = false;
+	if (! already_called) {
+		printf("WriteRGBAPixelsBack() called.\n");
+		already_called = true;
+	}
+
+	assert(bitmap);
+#if 0
+	while(n--) {
+		if (*mask++) {
+			int row = md->m_bottom - *y;
+			uint8 * pixel = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + *x * 4;
+			*((uint32 *) pixel) = PACK_B_RGBA32(rgba[0]);
+		};
+		x++;
+		y++;
+		rgba++;
+	};
+#else
    if (mask) {
       for (GLuint i = 0; i < n; i++) {
          if (mask[i]) {
             GLubyte *pixel = (GLubyte *) bitmap->Bits()
-            + (aux->mBottom - y[i]) * bitmap->BytesPerRow() + x[i] * 4;
+            + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4;
             pixel[BE_RCOMP] = rgba[i][RCOMP];
             pixel[BE_GCOMP] = rgba[i][GCOMP];
             pixel[BE_BCOMP] = rgba[i][BCOMP];
@@ -846,64 +1302,81 @@ void AuxInfo::WriteRGBAPixelsBack(const GLcontext *ctx,
    else {
       for (GLuint i = 0; i < n; i++) {
          GLubyte *pixel = (GLubyte *) bitmap->Bits()
-            + (aux->mBottom - y[i]) * bitmap->BytesPerRow() + x[i] * 4;
+            + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4;
          pixel[BE_RCOMP] = rgba[i][RCOMP];
          pixel[BE_GCOMP] = rgba[i][GCOMP];
          pixel[BE_BCOMP] = rgba[i][BCOMP];
          pixel[BE_ACOMP] = rgba[i][ACOMP];
       }
    }
+#endif
 }
 
 
-void AuxInfo::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoRGBAPixelsBack(const GLcontext *ctx, GLuint n,
                                       const GLint x[], const GLint y[],
                                       const GLchan color[4],
                                       const GLubyte mask[])
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   BBitmap *bitmap = aux->mBitmap;
-   GLuint pixel;
-   GLubyte *mColor= (GLubyte *) &pixel;
-   mColor[BE_RCOMP] = color[RCOMP];
-   mColor[BE_GCOMP] = color[GCOMP];
-   mColor[BE_BCOMP] = color[BCOMP];
-   mColor[BE_ACOMP] = color[ACOMP];
-   assert(bitmap);
+	MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+	BBitmap *bitmap = md->m_bitmap;
+
+	static bool already_called = false;
+	if (! already_called) {
+		printf("WriteMonoRGBAPixelsBack() called.\n");
+		already_called = true;
+	}
+
+	assert(bitmap);
+
+	uint32 pixel_color = PACK_B_RGBA32(color);
+#if 0	
+	while(n--) {
+		if (*mask++) {
+			int row = md->m_bottom - *y;
+			uint8 * pixel = (uint8 *) bitmap->Bits() + (row * bitmap->BytesPerRow()) + *x * 4;
+
+			*((uint32 *) pixel) = pixel_color;
+		};
+		x++;
+		y++;
+	};
+#else
    if (mask) {
       for (GLuint i = 0; i < n; i++) {
          if (mask[i]) {
-            GLuint *pixelPtr = (GLuint *) bitmap->Bits()
-                    + (aux->mBottom - y[i]) * aux->mWidth + x[i];
-            *pixelPtr = pixel;
+         	GLubyte * ptr = (GLubyte *) bitmap->Bits()
+            	+ ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4;
+            *((uint32 *) ptr) = pixel_color;
          }
       }
    }
    else {
-      for (GLuint i = 0; i < n; i++) {
-         GLuint *pixelPtr = (GLuint *) bitmap->Bits()
-                 + (aux->mBottom - y[i]) * aux->mWidth + x[i];
-         *pixelPtr = pixel;
+	  for (GLuint i = 0; i < n; i++) {
+       	GLubyte * ptr = (GLubyte *) bitmap->Bits()
+	           	+ ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4;
+       *((uint32 *) ptr) = pixel_color;
       }
    }
+#endif
 }
 
 
-void AuxInfo::WriteCI32SpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI32SpanBack( const GLcontext *ctx, GLuint n,
                                  GLint x, GLint y,
                                  const GLuint index[], const GLubyte mask[] )
 {
    // XXX to do
 }
 
-void AuxInfo::WriteCI8SpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI8SpanBack( const GLcontext *ctx, GLuint n,
                                 GLint x, GLint y,
                                 const GLubyte index[], const GLubyte mask[] )
 {
    // XXX to do
 }
 
-void AuxInfo::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
                                    GLint x, GLint y,
                                    GLuint colorIndex, const GLubyte mask[] )
 {
@@ -911,14 +1384,14 @@ void AuxInfo::WriteMonoCISpanBack( const GLcontext *ctx, GLuint n,
 }
 
 
-void AuxInfo::WriteCI32PixelsBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteCI32PixelsBack( const GLcontext *ctx, GLuint n,
                                    const GLint x[], const GLint y[],
                                    const GLuint index[], const GLubyte mask[] )
 {
    // XXX to do
 }
 
-void AuxInfo::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
                                      const GLint x[], const GLint y[],
                                      GLuint colorIndex, const GLubyte mask[] )
 {
@@ -926,22 +1399,23 @@ void AuxInfo::WriteMonoCIPixelsBack( const GLcontext *ctx, GLuint n,
 }
 
 
-void AuxInfo::ReadCI32SpanBack( const GLcontext *ctx,
+void MesaDriver::ReadCI32SpanBack( const GLcontext *ctx,
                                 GLuint n, GLint x, GLint y, GLuint index[] )
 {
    // XXX to do
 }
 
 
-void AuxInfo::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
+void MesaDriver::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
                                 GLint x, GLint y, GLubyte rgba[][4] )
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   const BBitmap *bitmap = aux->mBitmap;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   const BBitmap *bitmap = md->m_bitmap;
    assert(bitmap);
-   int row = aux->mBottom - y;
+   int row = md->m_bottom - y;
    const GLubyte *pixel = (GLubyte *) bitmap->Bits()
-                        + row * bitmap->BytesPerRow() + x * 4;
+                        + (row * bitmap->BytesPerRow()) + x * 4;
+
    for (GLuint i = 0; i < n; i++) {
       rgba[i][RCOMP] = pixel[BE_RCOMP];
       rgba[i][GCOMP] = pixel[BE_GCOMP];
@@ -952,7 +1426,7 @@ void AuxInfo::ReadRGBASpanBack( const GLcontext *ctx, GLuint n,
 }
 
 
-void AuxInfo::ReadCI32PixelsBack( const GLcontext *ctx,
+void MesaDriver::ReadCI32PixelsBack( const GLcontext *ctx,
                                    GLuint n, const GLint x[], const GLint y[],
                                    GLuint indx[], const GLubyte mask[] )
 {
@@ -960,319 +1434,36 @@ void AuxInfo::ReadCI32PixelsBack( const GLcontext *ctx,
 }
 
 
-void AuxInfo::ReadRGBAPixelsBack( const GLcontext *ctx,
+void MesaDriver::ReadRGBAPixelsBack( const GLcontext *ctx,
                                   GLuint n, const GLint x[], const GLint y[],
                                   GLubyte rgba[][4], const GLubyte mask[] )
 {
-   AuxInfo *aux = (AuxInfo *) ctx->DriverCtx;
-   const BBitmap *bitmap = aux->mBitmap;
+   MesaDriver *md = (MesaDriver *) ctx->DriverCtx;
+   const BBitmap *bitmap = md->m_bitmap;
    assert(bitmap);
-   for (GLuint i = 0; i < n; i++) {
-      if (y[i] < aux->mHeight) {
-         const GLubyte *pixel = (const GLubyte *) bitmap->Bits()
-            + ((aux->mBottom - y[i]) * aux->mWidth + x[i]) * 4;
+
+   if (mask) {
+      for (GLuint i = 0; i < n; i++) {
+         if (mask[i]) {
+            GLubyte *pixel = (GLubyte *) bitmap->Bits()
+            + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4;
+	         rgba[i][RCOMP] = pixel[BE_RCOMP];
+    	     rgba[i][GCOMP] = pixel[BE_GCOMP];
+        	 rgba[i][BCOMP] = pixel[BE_BCOMP];
+        	 rgba[i][ACOMP] = pixel[BE_ACOMP];
+         };
+      };
+   } else {
+      for (GLuint i = 0; i < n; i++) {
+         GLubyte *pixel = (GLubyte *) bitmap->Bits()
+            + ((md->m_bottom - y[i]) * bitmap->BytesPerRow()) + x[i] * 4;
          rgba[i][RCOMP] = pixel[BE_RCOMP];
          rgba[i][GCOMP] = pixel[BE_GCOMP];
          rgba[i][BCOMP] = pixel[BE_BCOMP];
          rgba[i][ACOMP] = pixel[BE_ACOMP];
-      }
-   }
-}
-
-
-
-
-//------------------------------------------------------------------
-// Public interface methods
-//------------------------------------------------------------------
-
-
-//
-// Input:  rect - initial rectangle
-//         name - window name
-//         resizingMode - example: B_FOLLOW_NONE
-//         mode - usually 0 ?
-//         options - Bitwise-OR of BGL_* tokens
-//
-BGLView::BGLView(BRect rect, char *name,
-                 ulong resizingMode, ulong mode,
-                 ulong options)
-   :BView(rect, name, resizingMode, mode)
-{
-   const GLboolean rgbFlag = (options & BGL_RGB) == BGL_RGB;
-   const GLboolean alphaFlag = (options & BGL_ALPHA) == BGL_ALPHA;
-   const GLboolean dblFlag = (options & BGL_DOUBLE) == BGL_DOUBLE;
-   const GLboolean stereoFlag = false;
-   const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
-   const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
-   const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
-   const GLint index = (options & BGL_INDEX) ? 32 : 0;
-   const GLint red = (options & BGL_RGB) ? 8 : 0;
-   const GLint green = (options & BGL_RGB) ? 8 : 0;
-   const GLint blue = (options & BGL_RGB) ? 8 : 0;
-   const GLint alpha = (options & BGL_RGB) ? 8 : 0;
-
-   if (!rgbFlag) {
-      fprintf(stderr, "Mesa Warning: color index mode not supported\n");
-   }
-
-   // Allocate auxiliary data object
-   AuxInfo *aux = new AuxInfo;
-
-   // examine option flags and create gl_context struct
-   GLvisual *visual = _mesa__create_visual( rgbFlag,
-                                            dblFlag,
-                                            stereoFlag,
-                                            red, green, blue, alpha,
-                                            index,
-                                            depth,
-                                            stencil,
-                                            accum, accum, accum, accum,
-                                            1
-                                            );
-
-   // create core framebuffer
-   GLframebuffer *buffer = _mesa_create_framebuffer(visual,
-                                              depth > 0 ? GL_TRUE : GL_FALSE,
-                                              stencil > 0 ? GL_TRUE: GL_FALSE,
-                                              accum > 0 ? GL_TRUE : GL_FALSE,
-                                              alphaFlag
-                                              );
-
-   // create core context
-   const GLboolean direct = GL_TRUE;
-   GLcontext *ctx = _mesa_create_context( visual, NULL, aux, direct );
-
-   _mesa_enable_sw_extensions(ctx);
-
-   aux->Init(this, ctx, visual, buffer );
-
-   // Hook aux data into BGLView object
-   m_gc = aux;
-}
-
-
-BGLView::~BGLView()
-{
-   printf("BGLView destructor\n");
-   AuxInfo *aux = (AuxInfo *) m_gc;
-   assert(aux);
-   delete aux;
-}
-
-void BGLView::LockGL()
-{
-   AuxInfo *aux = (AuxInfo *) m_gc;
-   assert(aux);
-   aux->MakeCurrent();
-}
-
-void BGLView::UnlockGL()
-{
-   AuxInfo *aux = (AuxInfo *) m_gc;
-   assert(aux);
-   // Could call _mesa_make_current(NULL, NULL) but it would just
-   // hinder performance
-}
-
-void BGLView::SwapBuffers()
-{
-   AuxInfo *aux = (AuxInfo *) m_gc;
-   assert(aux);
-   aux->SwapBuffers();
-}
-
-
-void BGLView::CopySubBufferMESA(GLint x, GLint y, GLuint width, GLuint height)
-{
-   AuxInfo *aux = (AuxInfo *) m_gc;
-   assert(aux);
-   aux->CopySubBuffer(x, y, width, height);
-}
-
-
-BView *BGLView::EmbeddedView()
-{
-   // XXX to do
-
-}
-
-status_t BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
-{
-   // XXX to do
-}
-
-
-status_t BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
-{
-   // XXX to do
-}
-
-void BGLView::ErrorCallback(GLenum errorCode)
-{
-   // XXX to do
-}
-
-void BGLView::Draw(BRect updateRect)
-{
-//   printf("BGLView draw\n");
-   // XXX to do
-}
-
-void BGLView::AttachedToWindow()
-{
-   BView::AttachedToWindow();
-
-   // don't paint window background white when resized
-   SetViewColor(B_TRANSPARENT_32_BIT);
-}
-
-void BGLView::AllAttached()
-{
-   BView::AllAttached();
-//   printf("BGLView AllAttached\n");
-}
-
-void BGLView::DetachedFromWindow()
-{
-   BView::DetachedFromWindow();
-}
-
-void BGLView::AllDetached()
-{
-   BView::AllDetached();
-//   printf("BGLView AllDetached");
-}
-
-void BGLView::FrameResized(float width, float height)
-{
-   return BView::FrameResized(width, height);
-}
-
-status_t BGLView::Perform(perform_code d, void *arg)
-{
-   return BView::Perform(d, arg);
+      };
+   };
 }
 
 
-status_t BGLView::Archive(BMessage *data, bool deep) const
-{
-   return BView::Archive(data, deep);
-}
-
-void BGLView::MessageReceived(BMessage *msg)
-{
-   BView::MessageReceived(msg);
-}
-
-void BGLView::SetResizingMode(uint32 mode)
-{
-   BView::SetResizingMode(mode);
-}
-
-void BGLView::Show()
-{
-//   printf("BGLView Show\n");
-   BView::Show();
-}
-
-void BGLView::Hide()
-{
-//   printf("BGLView Hide\n");
-   BView::Hide();
-}
-
-BHandler *BGLView::ResolveSpecifier(BMessage *msg, int32 index,
-                                    BMessage *specifier, int32 form,
-                                    const char *property)
-{
-   return BView::ResolveSpecifier(msg, index, specifier, form, property);
-}
-
-status_t BGLView::GetSupportedSuites(BMessage *data)
-{
-   return BView::GetSupportedSuites(data);
-}
-
-void BGLView::DirectConnected( direct_buffer_info *info )
-{
-   // XXX to do
-}
-
-void BGLView::EnableDirectMode( bool enabled )
-{
-   // XXX to do
-}
-
-
-
-//---- private methods ----------
-
-void BGLView::_ReservedGLView1() {}
-void BGLView::_ReservedGLView2() {}
-void BGLView::_ReservedGLView3() {}
-void BGLView::_ReservedGLView4() {}
-void BGLView::_ReservedGLView5() {}
-void BGLView::_ReservedGLView6() {}
-void BGLView::_ReservedGLView7() {}
-void BGLView::_ReservedGLView8() {}
-
-#if 0
-BGLView::BGLView(const BGLView &v)
-	: BView(v)
-{
-   // XXX not sure how this should work
-   printf("Warning BGLView::copy constructor not implemented\n");
-}
-#endif
-
-
-BGLView &BGLView::operator=(const BGLView &v)
-{
-   printf("Warning BGLView::operator= not implemented\n");
-}
-
-void BGLView::dither_front()
-{
-   // no-op
-}
-
-bool BGLView::confirm_dither()
-{
-   // no-op
-   return false;
-}
-
-void BGLView::draw(BRect r)
-{
-   // XXX no-op ???
-}
-
-/* Direct Window stuff */
-void BGLView::drawScanline( int x1, int x2, int y, void *data )
-{
-   // no-op
-}
-
-void BGLView::scanlineHandler(struct rasStateRec *state,
-                              GLint x1, GLint x2)
-{
-   // no-op
-}
-
-void BGLView::lock_draw()
-{
-   // no-op
-}
-
-void BGLView::unlock_draw()
-{
-   // no-op
-}
-
-bool BGLView::validateView()
-{
-   // no-op
-   return true;
-}