X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f6bcfd974ef26faf6f91a62cac09827e09463fd1..baf736e1f34666a81706bbef3b0c80ed59869859:/src/motif/glcanvas.cpp?ds=sidebyside

diff --git a/src/motif/glcanvas.cpp b/src/motif/glcanvas.cpp
index 0c1f9780d2..776eb9746c 100644
--- a/src/motif/glcanvas.cpp
+++ b/src/motif/glcanvas.cpp
@@ -7,7 +7,7 @@
 // Created:     1995, 1999
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart, Wolfram Gloger
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
@@ -22,7 +22,13 @@
 #include "wx/utils.h"
 #include "wx/app.h"
 
+#ifdef __VMS
+# pragma message disable nosimpint
+#endif
 #include <Xm/Xm.h>
+#ifdef __VMS
+# pragma message enable nosimpint
+#endif
 #include "wx/motif/private.h"
 
 #ifdef OLD_MESA
@@ -31,140 +37,357 @@ static int bitcount( unsigned long n )
 {
     int bits;
     for (bits=0; n>0;) {
-        if(n & 1) bits++;
-        n = n >> 1;
+	if(n & 1) bits++;
+	n = n >> 1;
     }
     return bits;
 }
 #endif
 
+/*
+ * GLContext implementation
+ */
+
+IMPLEMENT_CLASS(wxGLContext,wxObject)
+
+wxGLContext::wxGLContext( bool WXUNUSED(isRGB), wxWindow *win, 
+                          const wxPalette& WXUNUSED(palette) )
+{
+    m_window = win;
+    // m_widget = win->m_wxwindow;
+
+    wxGLCanvas *gc = (wxGLCanvas*) win;
+    XVisualInfo *vi = (XVisualInfo *) gc->m_vi;
+    
+    wxCHECK_RET( vi, "invalid visual for OpenGl" );
+    
+    m_glContext = glXCreateContext( (Display *)m_window->GetXDisplay(), vi,
+                                    None, GL_TRUE);
+  
+    wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
+}
+
+wxGLContext::wxGLContext( 
+               bool WXUNUSED(isRGB), wxWindow *win, 
+               const wxPalette& WXUNUSED(palette),
+               const wxGLContext *other        /* for sharing display lists */
+)
+{
+    m_window = win;
+    // m_widget = win->m_wxwindow;
+
+    wxGLCanvas *gc = (wxGLCanvas*) win;
+    XVisualInfo *vi = (XVisualInfo *) gc->m_vi;
+    
+    wxCHECK_RET( vi, "invalid visual for OpenGl" );
+    
+    if( other != 0 )
+        m_glContext = glXCreateContext( (Display *)m_window->GetXDisplay(), vi, 
+                                        other->m_glContext, GL_TRUE );
+    else
+        m_glContext = glXCreateContext( (Display *)m_window->GetXDisplay(), vi,
+                                        None, GL_TRUE );
+    
+    wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
+}
+
+wxGLContext::~wxGLContext()
+{
+    if (!m_glContext) return;
+    
+    if (m_glContext == glXGetCurrentContext())
+    {
+        glXMakeCurrent( (Display*) m_window->GetXDisplay(), None, NULL);
+    }
+	
+    glXDestroyContext( (Display*) m_window->GetXDisplay(), m_glContext );
+}
+
+void wxGLContext::SwapBuffers()
+{
+    if (m_glContext)
+    {
+        Display* display = (Display*) m_window->GetXDisplay();
+        glXSwapBuffers(display, (Window) m_window->GetXWindow());
+    }
+}
+
+void wxGLContext::SetCurrent()
+{
+    if (m_glContext) 
+    { 
+        Display* display = (Display*) m_window->GetXDisplay();
+        glXMakeCurrent(display, (Window) m_window->GetXWindow(), 
+                       m_glContext );;
+    }
+}
+
+void wxGLContext::SetColour(const char *colour)
+{
+    wxColour *the_colour = wxTheColourDatabase->FindColour(colour);
+    if(the_colour) {
+	GLboolean b;
+	glGetBooleanv(GL_RGBA_MODE, &b);
+	if(b) {
+	    glColor3ub(the_colour->Red(),
+		       the_colour->Green(),
+		       the_colour->Blue());
+	} else {
+	    GLint pix = (GLint)the_colour->m_pixel;
+	    if(pix == -1) {
+		XColor exact_def;
+		exact_def.red = (unsigned short)the_colour->Red() << 8;
+		exact_def.green = (unsigned short)the_colour->Green() << 8;
+		exact_def.blue = (unsigned short)the_colour->Blue() << 8;
+		exact_def.flags = DoRed | DoGreen | DoBlue;
+		if(!XAllocColor((Display*) m_window->GetXDisplay(),
+                  (Colormap) wxTheApp->GetMainColormap(m_window->GetXDisplay()),
+                  &exact_def)) {
+		    wxDebugMsg("wxGLCanvas: cannot allocate color\n");
+		    return;
+		}
+		pix = the_colour->m_pixel = exact_def.pixel;
+	    }
+	    glIndexi(pix);
+	}
+    }
+}
+
+void wxGLContext::SetupPixelFormat()
+{
+}
+
+void wxGLContext::SetupPalette( const wxPalette& WXUNUSED(palette) )
+{
+}
+
+wxPalette wxGLContext::CreateDefaultPalette()
+{
+    return wxNullPalette;
+}
+
+
+
+
 /*
  * GLCanvas implementation
  */
 
 IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)
 
-wxGLCanvas::wxGLCanvas(wxWindow *parent,
-                       wxWindowID id,
-                       const wxPoint& pos,
-                       const wxSize& size,
-                       long style,
-                       const wxString& name,
-                       int *attrib_list, const wxPalette& palette)
-          : wxScrolledWindow(parent, id, pos, size, style, name)
+BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
+//    EVT_SIZE(wxGLCanvas::OnSize)
+END_EVENT_TABLE()
+
+
+wxGLCanvas::wxGLCanvas( wxWindow *parent, wxWindowID id,
+                        const wxPoint& pos, const wxSize& size, 
+			long style, const wxString& name,
+                        int *attribList, 
+			const wxPalette& palette )
+: wxScrolledWindow(parent, id, pos, size, style, name)
+{
+    Create( parent, NULL, NULL, id, pos, size, style, name, attribList, palette );
+}
+
+wxGLCanvas::wxGLCanvas( wxWindow *parent, 
+                        const wxGLContext *shared,
+                        wxWindowID id,
+                        const wxPoint& pos, const wxSize& size, 
+			long style, const wxString& name,
+                        int *attribList, 
+			const wxPalette& palette )
+: wxScrolledWindow(parent, id, pos, size, style, name)
+{			
+    Create( parent, shared, NULL, id, pos, size, style, name, attribList, palette );
+}
+
+wxGLCanvas::wxGLCanvas( wxWindow *parent, 
+                        const wxGLCanvas *shared,
+                        wxWindowID id,
+                        const wxPoint& pos, const wxSize& size, 
+			long style, const wxString& name,
+                        int *attribList, 
+			const wxPalette& palette )
+: wxScrolledWindow(parent, id, pos, size, style, name)
+{			
+    Create( parent, NULL, shared, id, pos, size, style, name, attribList, palette );
+}
+
+
+/*
+bool wxGLCanvas::Create(wxWindow *parent,
+  const wxGLContext *shared, const wxGLCanvas *shared_context_of,
+  wxWindowID id = -1, const wxPoint& pos,
+  const wxSize& size, long style, 
+  const wxString& name, int *attribList, const wxPalette& palette):
+    wxScrolledWindow(parent, id, pos, size, style, name)
+*/
+
+bool wxGLCanvas::Create( wxWindow *parent, 
+                         const wxGLContext *shared,
+                         const wxGLCanvas *shared_context_of,
+                         wxWindowID id,
+                         const wxPoint& pos, const wxSize& size, 
+			 long style, const wxString& name,
+                         int *attribList, 
+			 const wxPalette& palette)
 {
     XVisualInfo *vi, vi_templ;
     XWindowAttributes xwa;
     int val, n;
 
+    m_sharedContext = (wxGLContext*)shared;  // const_cast
+    m_sharedContextOf = (wxGLCanvas*)shared_context_of;  // const_cast
+    m_glContext = (wxGLContext*) NULL;
+
     Display* display = (Display*) GetXDisplay();
 
-    glx_cx = 0;
     // Check for the presence of the GLX extension
     if(!glXQueryExtension(display, NULL, NULL)) {
-        wxDebugMsg("wxGLCanvas: GLX extension is missing\n");
-        return;
+	wxDebugMsg("wxGLCanvas: GLX extension is missing\n");
+	return false;
     }
 
-    if(attrib_list) {
-        // Get an appropriate visual
-        vi = glXChooseVisual(display, DefaultScreen(display), attrib_list);
-        if(!vi) return;
+    if(attribList) {
+      int data[512], arg=0, p=0;
+       
+      while( (attribList[arg]!=0) && (p<512) )
+      {
+        switch( attribList[arg++] )
+        {
+          case WX_GL_RGBA: data[p++] = GLX_RGBA; break;
+          case WX_GL_BUFFER_SIZE:
+            data[p++]=GLX_BUFFER_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_LEVEL:
+            data[p++]=GLX_LEVEL; data[p++]=attribList[arg++]; break;
+          case WX_GL_DOUBLEBUFFER: data[p++] = GLX_DOUBLEBUFFER; break;
+          case WX_GL_STEREO: data[p++] = GLX_STEREO; break;
+          case WX_GL_AUX_BUFFERS:
+            data[p++]=GLX_AUX_BUFFERS; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_RED:
+            data[p++]=GLX_RED_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_GREEN:
+            data[p++]=GLX_GREEN_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_BLUE:
+            data[p++]=GLX_BLUE_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_ALPHA:
+            data[p++]=GLX_ALPHA_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_DEPTH_SIZE: 
+            data[p++]=GLX_DEPTH_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_STENCIL_SIZE: 
+            data[p++]=GLX_STENCIL_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_ACCUM_RED:
+            data[p++]=GLX_ACCUM_RED_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_ACCUM_GREEN:
+            data[p++]=GLX_ACCUM_GREEN_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_ACCUM_BLUE:
+            data[p++]=GLX_ACCUM_BLUE_SIZE; data[p++]=attribList[arg++]; break;
+          case WX_GL_MIN_ACCUM_ALPHA:
+            data[p++]=GLX_ACCUM_ALPHA_SIZE; data[p++]=attribList[arg++]; break;
+          default:
+            break;
+        }
+      }       
+      data[p] = 0; 
 
-        // Here we should make sure that vi is the same visual as the
-        // one used by the xwindow drawable in wxCanvas.  However,
-        // there is currently no mechanism for this in wx_canvs.cc.
+      attribList = (int*) data;
+      // Get an appropriate visual
+      vi = glXChooseVisual(display, DefaultScreen(display), attribList);
+      if(!vi) return false;
+      
+      // Here we should make sure that vi is the same visual as the
+      // one used by the xwindow drawable in wxCanvas.  However,
+      // there is currently no mechanism for this in wx_canvs.cc.
     } else {
-        // By default, we use the visual of xwindow
-        XGetWindowAttributes(display, (Window) GetXWindow(), &xwa);
-        vi_templ.visualid = XVisualIDFromVisual(xwa.visual);
-        vi = XGetVisualInfo(display, VisualIDMask, &vi_templ, &n);
-        if(!vi) return;
-        glXGetConfig(display, vi, GLX_USE_GL, &val);
-        if(!val) return;
-        // Basically, this is it.  It should be possible to use vi
-        // in glXCreateContext() below.  But this fails with Mesa.
-        // I notified the Mesa author about it; there may be a fix.
+	// By default, we use the visual of xwindow
+        // NI: is this really senseful ? opengl in e.g. color index mode ?
+	XGetWindowAttributes(display, (Window) GetXWindow(), &xwa);
+	vi_templ.visualid = XVisualIDFromVisual(xwa.visual);
+	vi = XGetVisualInfo(display, VisualIDMask, &vi_templ, &n);
+	if(!vi) return false;
+	glXGetConfig(display, vi, GLX_USE_GL, &val);
+	if(!val) return false;
+	// Basically, this is it.  It should be possible to use vi
+	// in glXCreateContext() below.  But this fails with Mesa.
+	// I notified the Mesa author about it; there may be a fix.
 #ifdef OLD_MESA
-        // Construct an attribute list matching the visual
-        int a_list[32];
-        n = 0;
-        if(vi->c_class==TrueColor || vi->c_class==DirectColor) { // RGBA visual
-            a_list[n++] = GLX_RGBA;
-            a_list[n++] = GLX_RED_SIZE;
-            a_list[n++] = bitcount(vi->red_mask);
-            a_list[n++] = GLX_GREEN_SIZE;
-            a_list[n++] = bitcount(vi->green_mask);
-            a_list[n++] = GLX_BLUE_SIZE;
-            a_list[n++] = bitcount(vi->blue_mask);
-            glXGetConfig(display, vi, GLX_ALPHA_SIZE, &val);
-            a_list[n++] = GLX_ALPHA_SIZE;
-            a_list[n++] = val;
-        } else { // Color index visual
-            glXGetConfig(display, vi, GLX_BUFFER_SIZE, &val);
-            a_list[n++] = GLX_BUFFER_SIZE;
-            a_list[n++] = val;
-        }
-        a_list[n] = None;
-        XFree(vi);
-        vi = glXChooseVisual(display, DefaultScreen(display), a_list);
-        if(!vi) return;
+	// Construct an attribute list matching the visual
+	int a_list[32];
+	n = 0;
+	if(vi->c_class==TrueColor || vi->c_class==DirectColor) { // RGBA visual
+	    a_list[n++] = GLX_RGBA;
+	    a_list[n++] = GLX_RED_SIZE;
+	    a_list[n++] = bitcount(vi->red_mask);
+	    a_list[n++] = GLX_GREEN_SIZE;
+	    a_list[n++] = bitcount(vi->green_mask);
+	    a_list[n++] = GLX_BLUE_SIZE;
+	    a_list[n++] = bitcount(vi->blue_mask);
+	    glXGetConfig(display, vi, GLX_ALPHA_SIZE, &val);
+	    a_list[n++] = GLX_ALPHA_SIZE;
+	    a_list[n++] = val;
+	} else { // Color index visual
+	    glXGetConfig(display, vi, GLX_BUFFER_SIZE, &val);
+	    a_list[n++] = GLX_BUFFER_SIZE;
+	    a_list[n++] = val;
+	}
+	a_list[n] = None;
+	// XFree(vi);
+	vi = glXChooseVisual(display, DefaultScreen(display), a_list);
+	if(!vi) return false;
 #endif /* OLD_MESA */
     }
 
+    m_vi = vi;  // safe for later use
+    
+    wxCHECK_MSG( m_vi, FALSE, "required visual couldn't be found" );
+
     // Create the GLX context and make it current
-    glx_cx = glXCreateContext(display, vi, 0, GL_TRUE);
+
+    wxGLContext *share= m_sharedContext;
+    if (share==NULL && m_sharedContextOf) 
+        share = m_sharedContextOf->GetContext();
+
+    m_glContext = new wxGLContext( TRUE, this, wxNullPalette, share );
+
 #ifndef OLD_MESA
-    XFree(vi);
+    // XFree(vi);
 #endif
     SetCurrent();
+
+    return true;
 }
 
 wxGLCanvas::~wxGLCanvas(void)
 {
-    Display* display = (Display*) GetXDisplay();
-    if(glx_cx) glXDestroyContext(display, glx_cx);
+    XVisualInfo *vi = (XVisualInfo *) m_vi;
+    
+    if (vi) XFree( vi );
+    if (m_glContext) delete m_glContext;
+
+    // Display* display = (Display*) GetXDisplay();
+    // if(glx_cx) glXDestroyContext(display, glx_cx);
 }
 
 void wxGLCanvas::SwapBuffers()
 {
-    Display* display = (Display*) GetXDisplay();
-    if(glx_cx) glXSwapBuffers(display, (Window) GetXWindow());
+    if( m_glContext ) m_glContext->SwapBuffers();
+
+    // Display* display = (Display*) GetXDisplay();
+    // if(glx_cx) glXSwapBuffers(display, (Window) GetXWindow());
 }
 
 void wxGLCanvas::SetCurrent()
 {
-    Display* display = (Display*) GetXDisplay();
-    if(glx_cx) glXMakeCurrent(display, (Window) GetXWindow(), glx_cx);
+    if( m_glContext ) m_glContext->SetCurrent();
+
+    // Display* display = (Display*) GetXDisplay();
+    // if(glx_cx) glXMakeCurrent(display, (Window) GetXWindow(), glx_cx);
 }
 
 void wxGLCanvas::SetColour(const char *col)
 {
-    wxColour *the_colour = wxTheColourDatabase->FindColour(col);
-    if(the_colour) {
-        GLboolean b;
-        glGetBooleanv(GL_RGBA_MODE, &b);
-        if(b) {
-            glColor3ub(the_colour->Red(),
-                    the_colour->Green(),
-                    the_colour->Blue());
-        } else {
-            GLint pix = (GLint)the_colour->m_pixel;
-            if(pix == -1) {
-                XColor exact_def;
-                exact_def.red = (unsigned short)the_colour->Red() << 8;
-                exact_def.green = (unsigned short)the_colour->Green() << 8;
-                exact_def.blue = (unsigned short)the_colour->Blue() << 8;
-                exact_def.flags = DoRed | DoGreen | DoBlue;
-                if(!XAllocColor((Display*) GetXDisplay(), (Colormap) wxTheApp->GetMainColormap(GetXDisplay()), &exact_def)) {
-                    wxDebugMsg("wxGLCanvas: cannot allocate color\n");
-                    return;
-                }
-                pix = the_colour->m_pixel = exact_def.pixel;
-            }
-            glIndexi(pix);
-        }
-    }
+    if( m_glContext ) m_glContext->SetColour(col);
 }
 
 #endif