1. test for thr_setconcurrency() added to configure

[wxWidgets.git] / utils / glcanvas / gtk / glcanvas.cpp

diff --git a/utils/glcanvas/gtk/glcanvas.cpp b/utils/glcanvas/gtk/glcanvas.cpp
index c1085b2914c9fb28226ed0b7d9fb91ce4fa28c1f..71d8228192e7daa9dce8a3fb770df4e2c301f55c 100644 (file)
--- a/utils/glcanvas/gtk/glcanvas.cpp
+++ b/utils/glcanvas/gtk/glcanvas.cpp
@@ -34,6 +34,13 @@ extern "C" {
 
 XVisualInfo *g_vi = (XVisualInfo*) NULL;
 
 
 XVisualInfo *g_vi = (XVisualInfo*) NULL;
 

+//-----------------------------------------------------------------------------
+// idle system
+//-----------------------------------------------------------------------------
+
+extern void wxapp_install_idle_handler();
+extern bool g_isIdle;
+

 //---------------------------------------------------------------------------
 // wxGLContext
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
 // wxGLContext
 //---------------------------------------------------------------------------


@@ -43,11 +50,14 @@ IMPLEMENT_CLASS(wxGLContext,wxObject)
 wxGLContext::wxGLContext( bool WXUNUSED(isRGB), wxWindow *win, const wxPalette& WXUNUSED(palette) )
 {
     m_window = win;
 wxGLContext::wxGLContext( bool WXUNUSED(isRGB), wxWindow *win, const wxPalette& WXUNUSED(palette) )
 {
     m_window = win;

-    m_widget = ((wxGLCanvas*)win)->m_glWidget;
-  
-    wxCHECK_RET( g_vi, "invalid visual for OpenGl" );
+    m_widget = win->m_wxwindow;
+
+    wxGLCanvas *gc = (wxGLCanvas*) win;
+    XVisualInfo *vi = (XVisualInfo *) gc->m_vi;

     
     

-    m_glContext = glXCreateContext( GDK_DISPLAY(), g_vi, None, GL_TRUE );
+    wxCHECK_RET( vi, "invalid visual for OpenGl" );
+    
+    m_glContext = glXCreateContext( GDK_DISPLAY(), vi, None, GL_TRUE );

   
     wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
 }
   
     wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
 }


@@ -59,15 +69,17 @@ wxGLContext::wxGLContext(
 )
 {
     m_window = win;
 )
 {
     m_window = win;

-    m_widget = ((wxGLCanvas*)win)->m_glWidget;
-  
-    wxCHECK_RET( g_vi, "invalid visual for OpenGl" );
+    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 )
     
     if( other != 0 )

-      m_glContext = glXCreateContext( GDK_DISPLAY(), g_vi, other->m_glContext,
-                                      GL_TRUE );
+        m_glContext = glXCreateContext( GDK_DISPLAY(), vi, other->m_glContext, GL_TRUE );

     else
     else

-      m_glContext = glXCreateContext( GDK_DISPLAY(), g_vi, None, GL_TRUE );
+        m_glContext = glXCreateContext( GDK_DISPLAY(), vi, None, GL_TRUE );

     
     wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
 }
     
     wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
 }


@@ -88,7 +100,8 @@ void wxGLContext::SwapBuffers()
 {
     if (m_glContext)
     {
 {
     if (m_glContext)
     {

-        glXSwapBuffers( GDK_DISPLAY(), GDK_WINDOW_XWINDOW( m_widget->window ) );
+        GdkWindow *window = GTK_PIZZA(m_widget)->bin_window;
+        glXSwapBuffers( GDK_DISPLAY(), GDK_WINDOW_XWINDOW( window ) );

     }
 }
 
     }
 }
 


@@ -96,7 +109,8 @@ void wxGLContext::SetCurrent()
 {
     if (m_glContext) 
     { 
 {
     if (m_glContext) 
     { 

-        glXMakeCurrent( GDK_DISPLAY(), GDK_WINDOW_XWINDOW(m_widget->window), m_glContext );
+        GdkWindow *window = GTK_PIZZA(m_widget)->bin_window;
+        glXMakeCurrent( GDK_DISPLAY(), GDK_WINDOW_XWINDOW(window), m_glContext );

     }
 }
 
     }
 }
 


@@ -129,49 +143,87 @@ wxPalette wxGLContext::CreateDefaultPalette()
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------

-// "expose_event" of m_glWidget
+// "realize" from m_wxwindow
+//-----------------------------------------------------------------------------
+
+static gint
+gtk_glwindow_realized_callback( GtkWidget * WXUNUSED(widget), wxGLCanvas *win )
+{
+    win->m_glContext = new wxGLContext( TRUE, win, wxNullPalette, win->m_sharedContext );
+
+    return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "map" from m_wxwindow
+//-----------------------------------------------------------------------------
+
+static gint
+gtk_glwindow_map_callback( GtkWidget * WXUNUSED(widget), wxGLCanvas *win )
+{
+    if (win->m_glContext/* && win->m_exposed*/)
+    {
+        wxPaintEvent event( win->GetId() );
+        event.SetEventObject( win );
+        win->GetEventHandler()->ProcessEvent( event );
+
+        win->m_exposed = FALSE;
+        win->GetUpdateRegion().Clear();
+    }
+
+    return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "expose_event" of m_wxwindow

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

-static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
+static void 
+gtk_glwindow_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxGLCanvas *win )

 {
 {

-    if (!win->m_hasVMT) return;
+    if (g_isIdle) 
+        wxapp_install_idle_handler();
+
+    win->m_exposed = TRUE;

 
     win->GetUpdateRegion().Union( gdk_event->area.x,
 
     win->GetUpdateRegion().Union( gdk_event->area.x,

-                               gdk_event->area.y,
-                               gdk_event->area.width,
-                               gdk_event->area.height );
+                                  gdk_event->area.y,
+                                  gdk_event->area.width,
+                                  gdk_event->area.height );
+}

 
 

-    if (gdk_event->count > 0) return;
+//-----------------------------------------------------------------------------
+// "draw" of m_wxwindow
+//-----------------------------------------------------------------------------

 
 

-/*
-    printf( "OnExpose from " );
-    if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
-        printf( win->GetClassInfo()->GetClassName() );
-    printf( ".\n" );
-*/
+static void 
+gtk_glwindow_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxGLCanvas *win )
+{
+    if (g_isIdle) 
+        wxapp_install_idle_handler();

 
 

-    wxPaintEvent event( win->GetId() );
-    event.SetEventObject( win );
-    win->GetEventHandler()->ProcessEvent( event );
+    win->m_exposed = TRUE;

 
 

-    win->GetUpdateRegion().Clear();
+    win->GetUpdateRegion().Union( rect->x, rect->y,
+                                  rect->width, rect->height );

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------

-// "draw" of m_glWidget
+// "size_allocate" of m_wxwindow

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

-static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
+static void 
+gtk_glcanvas_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxGLCanvas *win )

 {
 {

-    if (!win->m_hasVMT) return;
+    if (g_isIdle)
+        wxapp_install_idle_handler();

 
 

-    win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
+    if (!win->m_hasVMT)
+        return;

 
 

-    wxPaintEvent event( win->GetId() );
+    wxSizeEvent event( wxSize(win->m_width,win->m_height), win->GetId() );

     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );
     event.SetEventObject( win );
     win->GetEventHandler()->ProcessEvent( event );

-
-    win->GetUpdateRegion().Clear();

 }
 
 //---------------------------------------------------------------------------
 }
 
 //---------------------------------------------------------------------------


@@ -212,15 +264,22 @@ bool wxGLCanvas::Create( wxWindow *parent,
                          int *attribList, 
                         const wxPalette& palette)
 {
                          int *attribList, 
                         const wxPalette& palette)
 {

+    m_sharedContext = (wxGLContext*)shared;  // const_cast
+    m_glContext = (wxGLContext*) NULL;
+    
+    m_exposed = FALSE;
+    m_noExpose = TRUE;
+    m_nativeSizeEvent = TRUE;
+    

     if (!attribList)
     {
         int data[] = { GLX_RGBA, 
                       GLX_DOUBLEBUFFER, 
     if (!attribList)
     {
         int data[] = { GLX_RGBA, 
                       GLX_DOUBLEBUFFER, 

-                      GLX_DEPTH_SIZE, 1,  /* use largest available depth buffer */
+                      GLX_DEPTH_SIZE, 1,  // use largest available depth buffer

                       GLX_RED_SIZE, 1, 
                       GLX_GREEN_SIZE, 1, 
                       GLX_BLUE_SIZE, 1, 
                       GLX_RED_SIZE, 1, 
                       GLX_GREEN_SIZE, 1, 
                       GLX_BLUE_SIZE, 1, 

-                      GLX_ALPHA_SIZE, 1, 
+                      GLX_ALPHA_SIZE, 0, 

                       None };
        attribList = (int*) data;
     }
                       None };
        attribList = (int*) data;
     }


@@ -251,55 +310,55 @@ bool wxGLCanvas::Create( wxWindow *parent,
       attribList = (int*) data;
     }
     
       attribList = (int*) data;
     }
     

+    

     Display *dpy = GDK_DISPLAY();
     
     Display *dpy = GDK_DISPLAY();
     

-    g_vi = glXChooseVisual( dpy, DefaultScreen(dpy), attribList );
+    XVisualInfo *vi = glXChooseVisual( dpy, DefaultScreen(dpy), attribList );
+    
+    m_vi = vi;  // safe for later use

     
     

-    GdkVisual *visual = gdkx_visual_get( g_vi->visualid );
-    GdkColormap *colormap = gdk_colormap_new( gdkx_visual_get(g_vi->visualid), TRUE );
+    wxCHECK_MSG( m_vi, FALSE, "required visual couldn't be found" );
+
+    GdkVisual *visual = gdkx_visual_get( vi->visualid );
+    GdkColormap *colormap = gdk_colormap_new( gdkx_visual_get(vi->visualid), TRUE );

     
     gtk_widget_push_colormap( colormap );
     gtk_widget_push_visual( visual );
     
     gtk_widget_push_colormap( colormap );
     gtk_widget_push_visual( visual );

-    
-    m_glWidget = gtk_myfixed_new();
-    
-    gtk_widget_pop_visual();
-    gtk_widget_pop_colormap();
-    
+

     wxScrolledWindow::Create( parent, id, pos, size, style, name );
     wxScrolledWindow::Create( parent, id, pos, size, style, name );

-  
-    GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
-    GTK_WIDGET_SET_FLAGS( m_glWidget, GTK_CAN_FOCUS );
+
+    m_glWidget = m_wxwindow;

     
     

-    gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), m_glWidget, 0, 0, m_width, m_height );
+    gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
+    
+    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
+                            GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );

 
 

-    gtk_signal_connect( GTK_OBJECT(m_glWidget), "expose_event",
-      GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
+                            GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this );

 
 

-    gtk_signal_connect( GTK_OBJECT(m_glWidget), "draw",
-      GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
-      
-    /* connect to key press and mouse handlers etc. */  
-    ConnectWidget( m_glWidget );
-    
+    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
+        GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer)this );

 
 

-    /* must be realized for OpenGl output */
-    gtk_widget_realize( m_glWidget );
- 
-    gtk_widget_show( m_glWidget );
-    
-    m_glContext = new wxGLContext( TRUE, this, palette, shared );
-    
-    XFree( g_vi );
-    g_vi = (XVisualInfo*) NULL;
+    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
+        GTK_SIGNAL_FUNC(gtk_glwindow_draw_callback), (gpointer)this );
+       
+    gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
+        GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer)this );

 
 

-    gdk_window_set_back_pixmap( m_glWidget->window, None, 0 );
-     
+    gtk_widget_pop_visual();
+    gtk_widget_pop_colormap();
+    

     return TRUE;
 }
 
 wxGLCanvas::~wxGLCanvas()
 {
     return TRUE;
 }
 
 wxGLCanvas::~wxGLCanvas()
 {

+    XVisualInfo *vi = (XVisualInfo *) m_vi;
+    
+    if (vi)
+        XFree( vi );
+    

     if (m_glContext) delete m_glContext;
 }
 
     if (m_glContext) delete m_glContext;
 }
 


@@ -312,10 +371,10 @@ void wxGLCanvas::OnSize(wxSizeEvent& WXUNUSED(event))
 {
     int width, height;
     GetClientSize( &width, &height );
 {
     int width, height;
     GetClientSize( &width, &height );

+    

     if (m_glContext && GTK_WIDGET_REALIZED(m_glWidget) )
     {
         SetCurrent(); 
     if (m_glContext && GTK_WIDGET_REALIZED(m_glWidget) )
     {
         SetCurrent(); 

-//        gdk_window_set_back_pixmap( gtk_widget_get_parent_window(m_glWidget), None, 0 );

        
         glViewport(0, 0, (GLint)width, (GLint)height );
         glMatrixMode(GL_PROJECTION);
        
         glViewport(0, 0, (GLint)width, (GLint)height );
         glMatrixMode(GL_PROJECTION);


@@ -335,84 +394,17 @@ void wxGLCanvas::SetColour( const char *colour )
     if (m_glContext) m_glContext->SetColour( colour );
 }
 
     if (m_glContext) m_glContext->SetColour( colour );
 }
 

-void wxGLCanvas::DoSetSize( int x, int y, int width, int height, int sizeFlags )
+void wxGLCanvas::OnInternalIdle()

 {
 {

-    if (m_resizing) return; // I don't like recursions
-    m_resizing = TRUE;
-
-    if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
-    {
-        // don't set the size for children of wxNotebook, just take the values.
-        m_x = x;
-        m_y = y;
-        m_width = width;
-        m_height = height;
-    }
-    else
+    if (m_glContext && m_exposed)

     {
     {

-        int old_width = m_width;
-        int old_height = m_height;
+        wxPaintEvent event( GetId() );
+        event.SetEventObject( this );
+        GetEventHandler()->ProcessEvent( event );

 
 

-        if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
-        {
-            if (x != -1) m_x = x;
-            if (y != -1) m_y = y;
-            if (width != -1) m_width = width;
-            if (height != -1) m_height = height;
-        }
-        else
-        {
-            m_x = x;
-            m_y = y;
-            m_width = width;
-            m_height = height;
-        }
-
-        if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
-        {
-             if (width == -1) m_width = 80;
-        }
-
-        if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
-        {
-             if (height == -1) m_height = 26;
-        }
-
-        if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
-        if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
-        if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
-        if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
-
-        gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow), 
-                             m_widget, 
-                             m_x, 
-                             m_y,
-                             m_width,
-                             m_height );
-
-        gtk_myfixed_set_size( GTK_MYFIXED(m_wxwindow), 
-                             m_glWidget,
-                             m_x, 
-                             m_y,
-                             m_width,
-                             m_height );
+        m_exposed = FALSE;
+        GetUpdateRegion().Clear();

     }
     }

-
-    m_sizeSet = TRUE;
-
-    wxSizeEvent event( wxSize(m_width,m_height), GetId() );
-    event.SetEventObject( this );
-    GetEventHandler()->ProcessEvent( event );
-
-    m_resizing = FALSE;
-}
-
-GtkWidget *wxGLCanvas::GetConnectWidget()
-{
-    return m_glWidget;
-}
-
-bool wxGLCanvas::IsOwnGtkWindow( GdkWindow *window )
-{
-    return (window == m_glWidget->window);
+    
+    wxWindow::OnInternalIdle();

 }
 }