]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/glcanvas.cpp
merged 2.2 branch
[wxWidgets.git] / src / gtk / glcanvas.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: glcanvas.cpp
3 // Purpose: wxGLCanvas, for using OpenGL/Mesa with wxWindows and GTK
4 // Author: Robert Roebling
5 // Modified by:
6 // Created: 17/08/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "glcanvas.h"
14 #endif
15
16 #include "wx/setup.h"
17
18 #if wxUSE_GLCANVAS
19
20 #include "wx/glcanvas.h"
21
22 #include "wx/frame.h"
23 #include "wx/colour.h"
24 #include "wx/module.h"
25 #include "wx/app.h"
26
27 extern "C" {
28 #include "gtk/gtk.h"
29 #include "gdk/gdk.h"
30 #include "gdk/gdkx.h"
31 }
32
33 #include "wx/gtk/win_gtk.h"
34
35 //---------------------------------------------------------------------------
36 // global data
37 //---------------------------------------------------------------------------
38
39 XVisualInfo *g_vi = (XVisualInfo*) NULL;
40
41 //-----------------------------------------------------------------------------
42 // idle system
43 //-----------------------------------------------------------------------------
44
45 extern void wxapp_install_idle_handler();
46 extern bool g_isIdle;
47
48 //---------------------------------------------------------------------------
49 // wxGLContext
50 //---------------------------------------------------------------------------
51
52 IMPLEMENT_CLASS(wxGLContext,wxObject)
53
54 wxGLContext::wxGLContext( bool WXUNUSED(isRGB), wxWindow *win, const wxPalette& WXUNUSED(palette) )
55 {
56 m_window = win;
57 m_widget = win->m_wxwindow;
58
59 wxGLCanvas *gc = (wxGLCanvas*) win;
60 XVisualInfo *vi = (XVisualInfo *) gc->m_vi;
61
62 wxCHECK_RET( vi, "invalid visual for OpenGl" );
63
64 m_glContext = glXCreateContext( GDK_DISPLAY(), vi, None, GL_TRUE );
65
66 wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
67 }
68
69 wxGLContext::wxGLContext(
70 bool WXUNUSED(isRGB), wxWindow *win,
71 const wxPalette& WXUNUSED(palette),
72 const wxGLContext *other /* for sharing display lists */
73 )
74 {
75 m_window = win;
76 m_widget = win->m_wxwindow;
77
78 wxGLCanvas *gc = (wxGLCanvas*) win;
79 XVisualInfo *vi = (XVisualInfo *) gc->m_vi;
80
81 wxCHECK_RET( vi, "invalid visual for OpenGl" );
82
83 if( other != 0 )
84 m_glContext = glXCreateContext( GDK_DISPLAY(), vi, other->m_glContext, GL_TRUE );
85 else
86 m_glContext = glXCreateContext( GDK_DISPLAY(), vi, None, GL_TRUE );
87
88 wxCHECK_RET( m_glContext, "Couldn't create OpenGl context" );
89 }
90
91 wxGLContext::~wxGLContext()
92 {
93 if (!m_glContext) return;
94
95 if (m_glContext == glXGetCurrentContext())
96 {
97 glXMakeCurrent( GDK_DISPLAY(), None, NULL);
98 }
99
100 glXDestroyContext( GDK_DISPLAY(), m_glContext );
101 }
102
103 void wxGLContext::SwapBuffers()
104 {
105 if (m_glContext)
106 {
107 GdkWindow *window = GTK_PIZZA(m_widget)->bin_window;
108 glXSwapBuffers( GDK_DISPLAY(), GDK_WINDOW_XWINDOW( window ) );
109 }
110 }
111
112 void wxGLContext::SetCurrent()
113 {
114 if (m_glContext)
115 {
116 GdkWindow *window = GTK_PIZZA(m_widget)->bin_window;
117 glXMakeCurrent( GDK_DISPLAY(), GDK_WINDOW_XWINDOW(window), m_glContext );
118 }
119 }
120
121 void wxGLContext::SetColour(const char *colour)
122 {
123 float r = 0.0;
124 float g = 0.0;
125 float b = 0.0;
126 wxColour *col = wxTheColourDatabase->FindColour(colour);
127 if (col)
128 {
129 r = (float)(col->Red()/256.0);
130 g = (float)(col->Green()/256.0);
131 b = (float)(col->Blue()/256.0);
132 glColor3f( r, g, b);
133 }
134 }
135
136 void wxGLContext::SetupPixelFormat()
137 {
138 }
139
140 void wxGLContext::SetupPalette( const wxPalette& WXUNUSED(palette) )
141 {
142 }
143
144 wxPalette wxGLContext::CreateDefaultPalette()
145 {
146 return wxNullPalette;
147 }
148
149 //-----------------------------------------------------------------------------
150 // "realize" from m_wxwindow
151 //-----------------------------------------------------------------------------
152
153 static gint
154 gtk_glwindow_realized_callback( GtkWidget * WXUNUSED(widget), wxGLCanvas *win )
155 {
156 wxGLContext *share= win->m_sharedContext;
157 if (share==NULL && win->m_sharedContextOf) share=win->m_sharedContextOf->GetContext();
158
159 win->m_glContext = new wxGLContext( TRUE, win, wxNullPalette, share );
160
161 return FALSE;
162 }
163
164 //-----------------------------------------------------------------------------
165 // "map" from m_wxwindow
166 //-----------------------------------------------------------------------------
167
168 static gint
169 gtk_glwindow_map_callback( GtkWidget * WXUNUSED(widget), wxGLCanvas *win )
170 {
171 if (win->m_glContext/* && win->m_exposed*/)
172 {
173 wxPaintEvent event( win->GetId() );
174 event.SetEventObject( win );
175 win->GetEventHandler()->ProcessEvent( event );
176
177 win->m_exposed = FALSE;
178 win->GetUpdateRegion().Clear();
179 }
180
181 return FALSE;
182 }
183
184 //-----------------------------------------------------------------------------
185 // "expose_event" of m_wxwindow
186 //-----------------------------------------------------------------------------
187
188 static void
189 gtk_glwindow_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxGLCanvas *win )
190 {
191 if (g_isIdle)
192 wxapp_install_idle_handler();
193
194 win->m_exposed = TRUE;
195
196 win->GetUpdateRegion().Union( gdk_event->area.x,
197 gdk_event->area.y,
198 gdk_event->area.width,
199 gdk_event->area.height );
200 }
201
202 //-----------------------------------------------------------------------------
203 // "draw" of m_wxwindow
204 //-----------------------------------------------------------------------------
205
206 static void
207 gtk_glwindow_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxGLCanvas *win )
208 {
209 if (g_isIdle)
210 wxapp_install_idle_handler();
211
212 win->m_exposed = TRUE;
213
214 win->GetUpdateRegion().Union( rect->x, rect->y,
215 rect->width, rect->height );
216 }
217
218 //-----------------------------------------------------------------------------
219 // "size_allocate" of m_wxwindow
220 //-----------------------------------------------------------------------------
221
222 static void
223 gtk_glcanvas_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxGLCanvas *win )
224 {
225 if (g_isIdle)
226 wxapp_install_idle_handler();
227
228 if (!win->m_hasVMT)
229 return;
230
231 wxSizeEvent event( wxSize(win->m_width,win->m_height), win->GetId() );
232 event.SetEventObject( win );
233 win->GetEventHandler()->ProcessEvent( event );
234 }
235
236 //---------------------------------------------------------------------------
237 // wxGlCanvas
238 //---------------------------------------------------------------------------
239
240 IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)
241
242 BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
243 EVT_SIZE(wxGLCanvas::OnSize)
244 END_EVENT_TABLE()
245
246 wxGLCanvas::wxGLCanvas( wxWindow *parent, wxWindowID id,
247 const wxPoint& pos, const wxSize& size,
248 long style, const wxString& name,
249 int *attribList,
250 const wxPalette& palette )
251 {
252 Create( parent, NULL, NULL, id, pos, size, style, name, attribList, palette );
253 }
254
255 wxGLCanvas::wxGLCanvas( wxWindow *parent,
256 const wxGLContext *shared,
257 wxWindowID id,
258 const wxPoint& pos, const wxSize& size,
259 long style, const wxString& name,
260 int *attribList,
261 const wxPalette& palette )
262 {
263 Create( parent, shared, NULL, id, pos, size, style, name, attribList, palette );
264 }
265
266 wxGLCanvas::wxGLCanvas( wxWindow *parent,
267 const wxGLCanvas *shared,
268 wxWindowID id,
269 const wxPoint& pos, const wxSize& size,
270 long style, const wxString& name,
271 int *attribList,
272 const wxPalette& palette )
273 {
274 Create( parent, NULL, shared, id, pos, size, style, name, attribList, palette );
275 }
276
277 bool wxGLCanvas::Create( wxWindow *parent,
278 const wxGLContext *shared,
279 const wxGLCanvas *shared_context_of,
280 wxWindowID id,
281 const wxPoint& pos, const wxSize& size,
282 long style, const wxString& name,
283 int *attribList,
284 const wxPalette& palette)
285 {
286 m_sharedContext = (wxGLContext*)shared; // const_cast
287 m_sharedContextOf = (wxGLCanvas*)shared_context_of; // const_cast
288 m_glContext = (wxGLContext*) NULL;
289
290 m_exposed = FALSE;
291 m_noExpose = TRUE;
292 m_nativeSizeEvent = TRUE;
293
294 if (!attribList)
295 {
296 int data[] = { GLX_RGBA,
297 GLX_DOUBLEBUFFER,
298 GLX_DEPTH_SIZE, 1, // use largest available depth buffer
299 GLX_RED_SIZE, 1,
300 GLX_GREEN_SIZE, 1,
301 GLX_BLUE_SIZE, 1,
302 GLX_ALPHA_SIZE, 0,
303 None };
304 attribList = (int*) data;
305 }
306 else
307 {
308 int data[512], arg=0, p=0;
309
310 while( (attribList[arg]!=0) && (p<512) )
311 {
312 switch( attribList[arg++] )
313 {
314 case WX_GL_RGBA: data[p++] = GLX_RGBA; break;
315 case WX_GL_DOUBLEBUFFER: data[p++] = GLX_DOUBLEBUFFER; break;
316 case WX_GL_DEPTH_SIZE:
317 data[p++]=GLX_DEPTH_SIZE; data[p++]=attribList[arg++]; break;
318 case WX_GL_MIN_RED:
319 data[p++]=GLX_RED_SIZE; data[p++]=attribList[arg++]; break;
320 case WX_GL_MIN_GREEN:
321 data[p++]=GLX_GREEN_SIZE; data[p++]=attribList[arg++]; break;
322 case WX_GL_MIN_BLUE:
323 data[p++]=GLX_BLUE_SIZE; data[p++]=attribList[arg++]; break;
324 default:
325 break;
326 }
327 }
328 data[p] = 0;
329
330 attribList = (int*) data;
331 }
332
333
334 Display *dpy = GDK_DISPLAY();
335
336 XVisualInfo *vi = glXChooseVisual( dpy, DefaultScreen(dpy), attribList );
337
338 m_vi = vi; // safe for later use
339
340 wxCHECK_MSG( m_vi, FALSE, "required visual couldn't be found" );
341
342 GdkVisual *visual = gdkx_visual_get( vi->visualid );
343 GdkColormap *colormap = gdk_colormap_new( gdkx_visual_get(vi->visualid), TRUE );
344
345 gtk_widget_push_colormap( colormap );
346 gtk_widget_push_visual( visual );
347
348 wxScrolledWindow::Create( parent, id, pos, size, style, name );
349
350 m_glWidget = m_wxwindow;
351
352 gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
353
354 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
355 GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );
356
357 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
358 GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this );
359
360 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
361 GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer)this );
362
363 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
364 GTK_SIGNAL_FUNC(gtk_glwindow_draw_callback), (gpointer)this );
365
366 gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
367 GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer)this );
368
369 gtk_widget_pop_visual();
370 gtk_widget_pop_colormap();
371
372 return TRUE;
373 }
374
375 wxGLCanvas::~wxGLCanvas()
376 {
377 XVisualInfo *vi = (XVisualInfo *) m_vi;
378
379 if (vi) XFree( vi );
380 if (m_glContext) delete m_glContext;
381 }
382
383 void wxGLCanvas::SwapBuffers()
384 {
385 if (m_glContext) m_glContext->SwapBuffers();
386 }
387
388 void wxGLCanvas::OnSize(wxSizeEvent& WXUNUSED(event))
389 {
390 int width, height;
391 GetClientSize( &width, &height );
392
393 if (m_glContext && GTK_WIDGET_REALIZED(m_glWidget) )
394 {
395 SetCurrent();
396
397 glViewport(0, 0, (GLint)width, (GLint)height );
398 glMatrixMode(GL_PROJECTION);
399 glLoadIdentity();
400 glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
401 glMatrixMode(GL_MODELVIEW);
402 }
403 }
404
405 void wxGLCanvas::SetCurrent()
406 {
407 if (m_glContext) m_glContext->SetCurrent();
408 }
409
410 void wxGLCanvas::SetColour( const char *colour )
411 {
412 if (m_glContext) m_glContext->SetColour( colour );
413 }
414
415 void wxGLCanvas::OnInternalIdle()
416 {
417 if (m_glContext && m_exposed)
418 {
419 wxPaintEvent event( GetId() );
420 event.SetEventObject( this );
421 GetEventHandler()->ProcessEvent( event );
422
423 m_exposed = FALSE;
424 GetUpdateRegion().Clear();
425 }
426
427 wxWindow::OnInternalIdle();
428 }
429
430 #endif
431 // wxUSE_GLCANVAS
432