c67dffc8ee8017c48cfb6ddc50a096b108c95879
[occt.git] / src / OpenGl / OpenGl_Window.cxx
1 // Created on: 2011-09-20
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and / or modify it
8 // under the terms of the GNU Lesser General Public version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <OpenGl_GlCore11.hxx>
17
18 #include <InterfaceGraphic.hxx>
19
20 #include <OpenGl_Window.hxx>
21
22 #include <OpenGl_Context.hxx>
23 #include <OpenGl_Display.hxx>
24
25 #include <Aspect_GraphicDeviceDefinitionError.hxx>
26 #include <TCollection_AsciiString.hxx>
27
28 IMPLEMENT_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared)
29 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Window,MMgt_TShared)
30
31 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
32
33 namespace
34 {
35   static const TEL_COLOUR THE_DEFAULT_BG_COLOR = { { 0.F, 0.F, 0.F, 1.F } };
36
37 #if defined(_WIN32)
38
39   // WGL_ARB_pixel_format
40 #ifndef WGL_NUMBER_PIXEL_FORMATS_ARB
41   #define WGL_NUMBER_PIXEL_FORMATS_ARB            0x2000
42   #define WGL_DRAW_TO_WINDOW_ARB                  0x2001
43   #define WGL_DRAW_TO_BITMAP_ARB                  0x2002
44   #define WGL_ACCELERATION_ARB                    0x2003
45   #define WGL_NEED_PALETTE_ARB                    0x2004
46   #define WGL_NEED_SYSTEM_PALETTE_ARB             0x2005
47   #define WGL_SWAP_LAYER_BUFFERS_ARB              0x2006
48   #define WGL_SWAP_METHOD_ARB                     0x2007
49   #define WGL_NUMBER_OVERLAYS_ARB                 0x2008
50   #define WGL_NUMBER_UNDERLAYS_ARB                0x2009
51   #define WGL_TRANSPARENT_ARB                     0x200A
52   #define WGL_TRANSPARENT_RED_VALUE_ARB           0x2037
53   #define WGL_TRANSPARENT_GREEN_VALUE_ARB         0x2038
54   #define WGL_TRANSPARENT_BLUE_VALUE_ARB          0x2039
55   #define WGL_TRANSPARENT_ALPHA_VALUE_ARB         0x203A
56   #define WGL_TRANSPARENT_INDEX_VALUE_ARB         0x203B
57   #define WGL_SHARE_DEPTH_ARB                     0x200C
58   #define WGL_SHARE_STENCIL_ARB                   0x200D
59   #define WGL_SHARE_ACCUM_ARB                     0x200E
60   #define WGL_SUPPORT_GDI_ARB                     0x200F
61   #define WGL_SUPPORT_OPENGL_ARB                  0x2010
62   #define WGL_DOUBLE_BUFFER_ARB                   0x2011
63   #define WGL_STEREO_ARB                          0x2012
64   #define WGL_PIXEL_TYPE_ARB                      0x2013
65   #define WGL_COLOR_BITS_ARB                      0x2014
66   #define WGL_RED_BITS_ARB                        0x2015
67   #define WGL_RED_SHIFT_ARB                       0x2016
68   #define WGL_GREEN_BITS_ARB                      0x2017
69   #define WGL_GREEN_SHIFT_ARB                     0x2018
70   #define WGL_BLUE_BITS_ARB                       0x2019
71   #define WGL_BLUE_SHIFT_ARB                      0x201A
72   #define WGL_ALPHA_BITS_ARB                      0x201B
73   #define WGL_ALPHA_SHIFT_ARB                     0x201C
74   #define WGL_ACCUM_BITS_ARB                      0x201D
75   #define WGL_ACCUM_RED_BITS_ARB                  0x201E
76   #define WGL_ACCUM_GREEN_BITS_ARB                0x201F
77   #define WGL_ACCUM_BLUE_BITS_ARB                 0x2020
78   #define WGL_ACCUM_ALPHA_BITS_ARB                0x2021
79   #define WGL_DEPTH_BITS_ARB                      0x2022
80   #define WGL_STENCIL_BITS_ARB                    0x2023
81   #define WGL_AUX_BUFFERS_ARB                     0x2024
82
83   #define WGL_NO_ACCELERATION_ARB                 0x2025
84   #define WGL_GENERIC_ACCELERATION_ARB            0x2026
85   #define WGL_FULL_ACCELERATION_ARB               0x2027
86
87   #define WGL_SWAP_EXCHANGE_ARB                   0x2028
88   #define WGL_SWAP_COPY_ARB                       0x2029
89   #define WGL_SWAP_UNDEFINED_ARB                  0x202A
90
91   #define WGL_TYPE_RGBA_ARB                       0x202B
92   #define WGL_TYPE_COLORINDEX_ARB                 0x202C
93 #endif // WGL_NUMBER_PIXEL_FORMATS_ARB
94
95   // WGL_ARB_create_context_profile
96 #ifndef WGL_CONTEXT_MAJOR_VERSION_ARB
97   #define WGL_CONTEXT_MAJOR_VERSION_ARB           0x2091
98   #define WGL_CONTEXT_MINOR_VERSION_ARB           0x2092
99   #define WGL_CONTEXT_LAYER_PLANE_ARB             0x2093
100   #define WGL_CONTEXT_FLAGS_ARB                   0x2094
101   #define WGL_CONTEXT_PROFILE_MASK_ARB            0x9126
102
103   // WGL_CONTEXT_FLAGS bits
104   #define WGL_CONTEXT_DEBUG_BIT_ARB               0x0001
105   #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002
106
107   // WGL_CONTEXT_PROFILE_MASK_ARB bits
108   #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB          0x00000001
109   #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
110 #endif // WGL_CONTEXT_MAJOR_VERSION_ARB
111
112   static LRESULT CALLBACK wndProcDummy (HWND theWin, UINT theMsg, WPARAM theParamW, LPARAM theParamL)
113   {
114     return DefWindowProcW (theWin, theMsg, theParamW, theParamL);
115   }
116 #else
117   static Bool WaitForNotify (Display* theDisp, XEvent* theEv, char* theArg)
118   {
119     return (theEv->type == MapNotify) && (theEv->xmap.window == (Window )theArg);
120   }
121 #endif
122
123 };
124
125 // =======================================================================
126 // function : OpenGl_Window
127 // purpose  :
128 // =======================================================================
129 OpenGl_Window::OpenGl_Window (const Handle(OpenGl_Display)& theDisplay,
130                               const CALL_DEF_WINDOW&        theCWindow,
131                               Aspect_RenderingContext       theGContext,
132                               const Handle(OpenGl_Caps)&    theCaps,
133                               const Handle(OpenGl_Context)& theShareCtx)
134 : myDisplay (theDisplay),
135   myGlContext (new OpenGl_Context (theCaps)),
136   myOwnGContext (theGContext == 0),
137 #if defined(_WIN32)
138   mySysPalInUse (FALSE),
139 #endif
140   myWidth ((Standard_Integer )theCWindow.dx),
141   myHeight ((Standard_Integer )theCWindow.dy),
142   myBgColor (THE_DEFAULT_BG_COLOR),
143   myDither (theDisplay->Dither()),
144   myBackDither (theDisplay->BackDither())
145 {
146   myBgColor.rgb[0] = theCWindow.Background.r;
147   myBgColor.rgb[1] = theCWindow.Background.g;
148   myBgColor.rgb[2] = theCWindow.Background.b;
149
150 #if defined(_WIN32)
151   HWND  aWindow   = (HWND )theCWindow.XWindow;
152   HDC   aWindowDC = GetDC (aWindow);
153   HGLRC aGContext = (HGLRC )theGContext;
154
155   PIXELFORMATDESCRIPTOR aPixelFrmt;
156   memset (&aPixelFrmt, 0, sizeof(aPixelFrmt));
157   aPixelFrmt.nSize        = sizeof(PIXELFORMATDESCRIPTOR);
158   aPixelFrmt.nVersion     = 1;
159   aPixelFrmt.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
160   aPixelFrmt.iPixelType   = PFD_TYPE_RGBA;
161   aPixelFrmt.cColorBits   = 24;
162   aPixelFrmt.cDepthBits   = 24;
163   aPixelFrmt.cStencilBits = 8;
164   aPixelFrmt.iLayerType   = PFD_MAIN_PLANE;
165   if (theCaps->contextStereo)
166   {
167     aPixelFrmt.dwFlags |= PFD_STEREO;
168   }
169
170   int aPixelFrmtId = ChoosePixelFormat (aWindowDC, &aPixelFrmt);
171   if (aPixelFrmtId == 0)
172   {
173     ReleaseDC (aWindow, aWindowDC);
174
175     TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: ChoosePixelFormat failed. Error code: ");
176     aMsg += (int )GetLastError();
177     Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
178     return;
179   }
180
181   DescribePixelFormat (aWindowDC, aPixelFrmtId, sizeof(aPixelFrmt), &aPixelFrmt);
182   if (aPixelFrmt.dwFlags & PFD_NEED_PALETTE)
183   {
184     WINDOW_DATA* aWndData = (WINDOW_DATA* )GetWindowLongPtr (aWindow, GWLP_USERDATA);
185
186     mySysPalInUse = (aPixelFrmt.dwFlags & PFD_NEED_SYSTEM_PALETTE) ? TRUE : FALSE;
187     InterfaceGraphic_RealizePalette (aWindowDC, aWndData->hPal, FALSE, mySysPalInUse);
188   }
189
190   if (myDither)
191   {
192     myDither = (aPixelFrmt.cColorBits <= 8);
193   }
194
195   if (myBackDither)
196   {
197     myBackDither = (aPixelFrmt.cColorBits <= 8);
198   }
199
200   HGLRC aSlaveCtx = !theShareCtx.IsNull() ? (HGLRC )theShareCtx->myGContext : NULL;
201   if (aGContext == NULL)
202   {
203     // create temporary context to retrieve advanced context creation procedures
204     HMODULE aModule = GetModuleHandleW(NULL);
205     WNDCLASSW aClass; memset (&aClass, 0, sizeof(aClass));
206     aClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
207     aClass.lpfnWndProc   = wndProcDummy;
208     aClass.hInstance     = aModule;
209     aClass.lpszClassName = L"OpenGl_WindowTmp";
210     HWND  aWinTmp     = NULL;
211     HDC   aDevCtxTmp  = NULL;
212     HGLRC aRendCtxTmp = NULL;
213     if ((!theCaps->contextDebug && !theCaps->contextNoAccel)
214      || RegisterClassW (&aClass) == 0)
215     {
216       aClass.lpszClassName = NULL;
217     }
218     if (aClass.lpszClassName != NULL)
219     {
220       DWORD anExStyle = WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE;
221     #if (_WIN32_WINNT >= 0x0500)
222       anExStyle |= WS_EX_NOACTIVATE;
223     #endif
224       aWinTmp = CreateWindowExW(anExStyle,
225                                 aClass.lpszClassName, L"OpenGl_WindowTmp",
226                                 WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED,
227                                 2, 2, 4, 4,
228                                 NULL, NULL, aModule, NULL);
229     }
230     if (aWinTmp != NULL)
231     {
232       aDevCtxTmp = GetDC (aWinTmp);
233       SetPixelFormat (aDevCtxTmp, aPixelFrmtId, &aPixelFrmt);
234       aRendCtxTmp = wglCreateContext (aDevCtxTmp);
235     }
236
237     typedef BOOL (WINAPI *wglChoosePixelFormatARB_t)(HDC           theDevCtx,
238                                                      const int*    theIntAttribs,
239                                                      const float*  theFloatAttribs,
240                                                      unsigned int  theMaxFormats,
241                                                      int*          theFormatsOut,
242                                                      unsigned int* theNumFormatsOut);
243     typedef HGLRC (WINAPI *wglCreateContextAttribsARB_t)(HDC        theDevCtx,
244                                                          HGLRC      theShareContext,
245                                                          const int* theAttribs);
246     wglChoosePixelFormatARB_t    aChoosePixProc = NULL;
247     wglCreateContextAttribsARB_t aCreateCtxProc = NULL;
248     if (aRendCtxTmp != NULL)
249     {
250       wglMakeCurrent (aDevCtxTmp, aRendCtxTmp);
251
252       typedef const char* (WINAPI *wglGetExtensionsStringARB_t)(HDC theDeviceContext);
253       wglGetExtensionsStringARB_t aGetExtensions = (wglGetExtensionsStringARB_t  )wglGetProcAddress ("wglGetExtensionsStringARB");
254       const char* aWglExts = (aGetExtensions != NULL) ? aGetExtensions (wglGetCurrentDC()) : NULL;
255       if (OpenGl_Context::CheckExtension (aWglExts, "WGL_ARB_pixel_format"))
256       {
257         aChoosePixProc = (wglChoosePixelFormatARB_t    )wglGetProcAddress ("wglChoosePixelFormatARB");
258       }
259       if (OpenGl_Context::CheckExtension (aWglExts, "WGL_ARB_create_context_profile"))
260       {
261         aCreateCtxProc = (wglCreateContextAttribsARB_t )wglGetProcAddress ("wglCreateContextAttribsARB");
262       }
263     }
264
265     // choose extended pixel format
266     if (aChoosePixProc != NULL)
267     {
268       const int aPixAttribs[] =
269       {
270         WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
271         WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
272         WGL_DOUBLE_BUFFER_ARB,  GL_TRUE,
273         WGL_STEREO_ARB,         theCaps->contextStereo ? GL_TRUE : GL_FALSE,
274         WGL_PIXEL_TYPE_ARB,     WGL_TYPE_RGBA_ARB,
275         //WGL_SAMPLE_BUFFERS_ARB, 1,
276         //WGL_SAMPLES_ARB,        8,
277         WGL_COLOR_BITS_ARB,     24,
278         WGL_DEPTH_BITS_ARB,     24,
279         WGL_STENCIL_BITS_ARB,   8,
280         WGL_ACCELERATION_ARB,   theCaps->contextNoAccel ? WGL_NO_ACCELERATION_ARB : WGL_FULL_ACCELERATION_ARB,
281         0, 0,
282       };
283       unsigned int aFrmtsNb = 0;
284       aChoosePixProc (aWindowDC, aPixAttribs, NULL, 1, &aPixelFrmtId, &aFrmtsNb);
285     }
286
287     // setup pixel format - may be set only once per window
288     if (!SetPixelFormat (aWindowDC, aPixelFrmtId, &aPixelFrmt))
289     {
290       ReleaseDC (aWindow, aWindowDC);
291
292       TCollection_AsciiString aMsg("OpenGl_Window::CreateWindow: SetPixelFormat failed. Error code: ");
293       aMsg += (int )GetLastError();
294       Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
295       return;
296     }
297
298     // create GL context with extra options
299     if (aCreateCtxProc != NULL)
300     {
301       // Beware! NVIDIA drivers reject context creation when WGL_CONTEXT_PROFILE_MASK_ARB are specified
302       // but not WGL_CONTEXT_MAJOR_VERSION_ARB/WGL_CONTEXT_MINOR_VERSION_ARB.
303       int aCtxAttribs[] =
304       {
305         //WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
306         //WGL_CONTEXT_MINOR_VERSION_ARB, 2,
307         //WGL_CONTEXT_PROFILE_MASK_ARB,  WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, //WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
308         WGL_CONTEXT_FLAGS_ARB,         theCaps->contextDebug ? WGL_CONTEXT_DEBUG_BIT_ARB : 0,
309         0, 0
310       };
311
312       aGContext = aCreateCtxProc (aWindowDC, aSlaveCtx, aCtxAttribs);
313       if (aGContext != NULL)
314       {
315         aSlaveCtx = NULL;
316       }
317     }
318
319     if (aRendCtxTmp != NULL)
320     {
321       wglDeleteContext (aRendCtxTmp);
322     }
323     if (aDevCtxTmp != NULL)
324     {
325       ReleaseDC (aWinTmp, aDevCtxTmp);
326     }
327     if (aWinTmp != NULL)
328     {
329       DestroyWindow (aWinTmp);
330     }
331     if (aClass.lpszClassName != NULL)
332     {
333       UnregisterClassW (aClass.lpszClassName, aModule);
334     }
335
336     if (aGContext == NULL)
337     {
338       // create context using obsolete functionality
339       aGContext = wglCreateContext (aWindowDC);
340     }
341     if (aGContext == NULL)
342     {
343       ReleaseDC (aWindow, aWindowDC);
344
345       TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglCreateContext failed. Error code: ");
346       aMsg += (int )GetLastError();
347       Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
348       return;
349     }
350   }
351
352   // all GL context within one OpenGl_GraphicDriver should be shared!
353   if (aSlaveCtx != NULL && wglShareLists (aSlaveCtx, aGContext) != TRUE)
354   {
355     TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglShareLists failed. Error code: ");
356     aMsg += (int )GetLastError();
357     Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
358     return;
359   }
360
361   myGlContext->Init ((Aspect_Handle )aWindow, (Aspect_Handle )aWindowDC, (Aspect_RenderingContext )aGContext);
362 #else
363   WINDOW aParent = (WINDOW )theCWindow.XWindow;
364   WINDOW aWindow = 0;
365   DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay();
366   GLXContext aGContext = (GLXContext )theGContext;
367
368   XWindowAttributes wattr;
369   XGetWindowAttributes (aDisp, aParent, &wattr);
370   const int scr = DefaultScreen (aDisp);
371
372   XVisualInfo* aVis = NULL;
373   {
374     unsigned long aVisInfoMask = VisualIDMask | VisualScreenMask;
375     XVisualInfo aVisInfo;
376     aVisInfo.visualid = wattr.visual->visualid;
377     aVisInfo.screen   = scr;
378     int aNbItems;
379     aVis = XGetVisualInfo (aDisp, aVisInfoMask, &aVisInfo, &aNbItems);
380   }
381
382   if (!myOwnGContext)
383   {
384     if (aVis != NULL)
385     {
386       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: XGetVisualInfo failed.");
387       return;
388     }
389
390     aWindow = aParent;
391   }
392   else
393   {
394   #if defined(__linux) || defined(Linux) || defined(__APPLE__)
395     if (aVis != NULL)
396     {
397       // check Visual for OpenGl context's parameters compability
398       int isGl = 0, isDoubleBuffer = 0, isRGBA = 0, aDepthSize = 0, aStencilSize = 0;
399
400       if (glXGetConfig (aDisp, aVis, GLX_USE_GL, &isGl) != 0)
401         isGl = 0;
402
403       if (glXGetConfig (aDisp, aVis, GLX_RGBA, &isRGBA) != 0)
404         isRGBA = 0;
405
406       if (glXGetConfig (aDisp, aVis, GLX_DOUBLEBUFFER, &isDoubleBuffer) != 0)
407         isDoubleBuffer = 0;
408
409       if (glXGetConfig (aDisp, aVis, GLX_DEPTH_SIZE, &aDepthSize) != 0)
410         aDepthSize = 0;
411
412       if (glXGetConfig (aDisp, aVis, GLX_STENCIL_SIZE, &aStencilSize) != 0)
413         aStencilSize = 0;
414
415       if (!isGl || !aDepthSize || !aStencilSize || !isRGBA  || (isDoubleBuffer ? 1 : 0) != (myDisplay->DBuffer()? 1 : 0))
416       {
417         XFree (aVis);
418         aVis = NULL;
419       }
420     }
421   #endif
422
423     if (aVis == NULL)
424     {
425       int anIter = 0;
426       int anAttribs[13];
427       anAttribs[anIter++] = GLX_RGBA;
428
429       anAttribs[anIter++] = GLX_DEPTH_SIZE;
430       anAttribs[anIter++] = 1;
431
432       anAttribs[anIter++] = GLX_STENCIL_SIZE;
433       anAttribs[anIter++] = 1;
434
435       anAttribs[anIter++] = GLX_RED_SIZE;
436       anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1;
437
438       anAttribs[anIter++] = GLX_GREEN_SIZE;
439       anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1;
440
441       anAttribs[anIter++] = GLX_BLUE_SIZE;
442       anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1;
443
444       if (myDisplay->DBuffer())
445         anAttribs[anIter++] = GLX_DOUBLEBUFFER;
446
447       anAttribs[anIter++] = None;
448
449       aVis = glXChooseVisual (aDisp, scr, anAttribs);
450       if (aVis == NULL)
451       {
452         Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: glXChooseVisual failed.");
453         return;
454       }
455     }
456
457     if (!theShareCtx.IsNull())
458     {
459       // ctx est une copie du previous
460       aGContext = glXCreateContext (aDisp, aVis, (GLXContext )theShareCtx->myGContext, GL_TRUE);
461     }
462     else
463     {
464       aGContext = glXCreateContext (aDisp, aVis, NULL, GL_TRUE);
465     }
466
467     if (!aGContext)
468     {
469       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: glXCreateContext failed.");
470       return;
471     }
472
473     Colormap cmap = XCreateColormap (aDisp, aParent, aVis->visual, AllocNone);
474
475     XColor color;
476     color.red   = (unsigned short) (myBgColor.rgb[0] * 0xFFFF);
477     color.green = (unsigned short) (myBgColor.rgb[1] * 0xFFFF);
478     color.blue  = (unsigned short) (myBgColor.rgb[2] * 0xFFFF);
479     color.flags = DoRed | DoGreen | DoBlue;
480     XAllocColor (aDisp, cmap, &color);
481
482     XSetWindowAttributes cwa;
483     cwa.colormap         = cmap;
484     cwa.event_mask       = StructureNotifyMask;
485     cwa.border_pixel     = color.pixel;
486     cwa.background_pixel = color.pixel;
487
488     if (aVis->visualid == wattr.visual->visualid)
489     {
490       aWindow = aParent;
491     }
492     else
493     {
494       unsigned long mask = CWBackPixel | CWColormap | CWBorderPixel | CWEventMask;
495       aWindow = XCreateWindow (aDisp, aParent, 0, 0, myWidth, myHeight, 0/*bw*/, aVis->depth, InputOutput, aVis->visual, mask, &cwa);
496     }
497
498     XSetWindowBackground (aDisp, aWindow, cwa.background_pixel);
499     XClearWindow (aDisp, aWindow);
500
501     if (aWindow != aParent)
502     {
503       XEvent anEvent;
504       XMapWindow (aDisp, aWindow);
505       XIfEvent (aDisp, &anEvent, WaitForNotify, (char* )aWindow);
506     }
507   }
508
509   /*
510   * Le BackDitherProp est utilise pour le clear du background
511   * Pour eviter une difference de couleurs avec la couleur choisie
512   * par l'application (XWindow) il faut desactiver le dithering
513   * au dessus de 8 plans.
514   *
515   * Pour le DitherProp:
516   * On cherchera a activer le Dithering que si le Visual a au moins
517   * 8 plans pour le GLX_RED_SIZE. Le test est plus sur car on peut
518   * avoir une profondeur superieure a 12 mais avoir besoin du dithering.
519   * (Carte Impact avec GLX_RED_SIZE a 5 par exemple)
520   */
521
522   int aValue;
523   glXGetConfig (aDisp, aVis, GLX_RED_SIZE, &aValue);
524
525   if (myDither)
526     myDither = (aValue < 8);
527
528   if (myBackDither)
529     myBackDither = (aVis->depth <= 8);
530
531   XFree ((char* )aVis);
532
533   myGlContext->Init ((Aspect_Drawable )aWindow, (Aspect_Display )myDisplay->GetDisplay(), (Aspect_RenderingContext )aGContext);
534 #endif
535   myGlContext->Share (theShareCtx);
536
537   Init();
538 }
539
540 // =======================================================================
541 // function : ~OpenGl_Window
542 // purpose  :
543 // =======================================================================
544 OpenGl_Window::~OpenGl_Window()
545 {
546   if (!myOwnGContext)
547   {
548     myGlContext.Nullify();
549     return;
550   }
551
552   // release "GL" context if it is owned by window
553 #if defined(_WIN32)
554   HWND  aWindow          = (HWND  )myGlContext->myWindow;
555   HDC   aWindowDC        = (HDC   )myGlContext->myWindowDC;
556   HGLRC aWindowGContext  = (HGLRC )myGlContext->myGContext;
557   HGLRC aThreadGlContext = wglGetCurrentContext();
558   myGlContext.Nullify();
559
560   if (aThreadGlContext != NULL)
561   {
562     // Mesa implementation can fail to reset this thread's context if wglDeleteContext()
563     // called without this step. This might lead to crash when using newly created
564     // context if wglMakeCurrent() is not forced right after the wglCreateContext().
565     if (aThreadGlContext == aWindowGContext)
566     {
567       wglMakeCurrent (NULL, NULL);
568     }
569
570     wglDeleteContext (aWindowGContext);
571   }
572   ReleaseDC (aWindow, aWindowDC);
573 #else
574   Display*    aDisplay  = (Display*    )myGlContext->myDisplay;
575   GLXContext  aGContext = (GLXContext  )myGlContext->myGContext;
576   myGlContext.Nullify();
577
578   if (aDisplay != NULL)
579   {
580     // FSXXX sync necessary if non-direct rendering
581     glXWaitGL();
582     glXDestroyContext (aDisplay, aGContext);
583   }
584 #endif
585 }
586
587 #endif // !__APPLE__
588
589 // =======================================================================
590 // function : Activate
591 // purpose  :
592 // =======================================================================
593 Standard_Boolean OpenGl_Window::Activate()
594 {
595   return myGlContext->MakeCurrent();
596 }
597
598 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
599
600 // =======================================================================
601 // function : Resize
602 // purpose  : call_subr_resize
603 // =======================================================================
604 void OpenGl_Window::Resize (const CALL_DEF_WINDOW& theCWindow)
605 {
606   DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay();
607   if (aDisp == NULL)
608     return;
609
610   // If the size is not changed - do nothing
611   if ((myWidth == theCWindow.dx) && (myHeight == theCWindow.dy))
612     return;
613
614   myWidth  = (Standard_Integer )theCWindow.dx;
615   myHeight = (Standard_Integer )theCWindow.dy;
616
617 #if !defined(_WIN32)
618   XResizeWindow (aDisp, myGlContext->myWindow, (unsigned int )myWidth, (unsigned int )myHeight);
619   XSync (aDisp, False);
620 #endif
621
622   Init();
623 }
624
625 #endif // !__APPLE__
626
627 // =======================================================================
628 // function : ReadDepths
629 // purpose  : TelReadDepths
630 // =======================================================================
631 void OpenGl_Window::ReadDepths (const Standard_Integer theX,     const Standard_Integer theY,
632                                 const Standard_Integer theWidth, const Standard_Integer theHeight,
633                                 float* theDepths)
634 {
635   if (theDepths == NULL || !Activate())
636     return;
637
638   glMatrixMode (GL_PROJECTION);
639   glLoadIdentity();
640   gluOrtho2D (0.0, (GLdouble )myWidth, 0.0, (GLdouble )myHeight);
641   glMatrixMode (GL_MODELVIEW);
642   glLoadIdentity();
643
644   glRasterPos2i (theX, theY);
645   DisableFeatures();
646   glReadPixels (theX, theY, theWidth, theHeight, GL_DEPTH_COMPONENT, GL_FLOAT, theDepths);
647   EnableFeatures();
648 }
649
650 // =======================================================================
651 // function : SetBackgroundColor
652 // purpose  : call_subr_set_background
653 // =======================================================================
654 void OpenGl_Window::SetBackgroundColor (const Standard_ShortReal theR,
655                                         const Standard_ShortReal theG,
656                                         const Standard_ShortReal theB)
657 {
658   myBgColor.rgb[0] = theR;
659   myBgColor.rgb[1] = theG;
660   myBgColor.rgb[2] = theB;
661 }
662
663 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
664
665 // =======================================================================
666 // function : Init
667 // purpose  :
668 // =======================================================================
669 void OpenGl_Window::Init()
670 {
671   if (!Activate())
672     return;
673
674 #if defined(_WIN32)
675   RECT cr;
676   GetClientRect ((HWND )myGlContext->myWindow, &cr);
677   myWidth  = cr.right - cr.left;
678   myHeight = cr.bottom - cr.top;
679 #else
680   Window aRootWin;
681   int aDummy;
682   unsigned int aDummyU;
683   unsigned int aNewWidth  = 0;
684   unsigned int aNewHeight = 0;
685   DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay();
686   XGetGeometry (aDisp, myGlContext->myWindow, &aRootWin, &aDummy, &aDummy, &aNewWidth, &aNewHeight, &aDummyU, &aDummyU);
687   myWidth  = aNewWidth;
688   myHeight = aNewHeight;
689 #endif
690
691   glMatrixMode (GL_MODELVIEW);
692   glViewport (0, 0, myWidth, myHeight);
693
694   glDisable (GL_SCISSOR_TEST);
695   glDrawBuffer (GL_BACK);
696 }
697
698 #endif // !__APPLE__
699
700 // =======================================================================
701 // function : EnablePolygonOffset
702 // purpose  : call_subr_enable_polygon_offset
703 // =======================================================================
704 void OpenGl_Window::EnablePolygonOffset() const
705 {
706   Standard_ShortReal aFactor, aUnits;
707   myDisplay->PolygonOffset (aFactor, aUnits);
708   glPolygonOffset (aFactor, aUnits);
709   glEnable (GL_POLYGON_OFFSET_FILL);
710 }
711
712 // =======================================================================
713 // function : DisablePolygonOffset
714 // purpose  : call_subr_disable_polygon_offset
715 // =======================================================================
716 void OpenGl_Window::DisablePolygonOffset() const
717 {
718   glDisable (GL_POLYGON_OFFSET_FILL);
719 }
720
721 // =======================================================================
722 // function : EnableFeatures
723 // purpose  :
724 // =======================================================================
725 void OpenGl_Window::EnableFeatures() const
726 {
727   /*glPixelTransferi (GL_MAP_COLOR, GL_TRUE);*/
728
729   if (myDither)
730     glEnable (GL_DITHER);
731   else
732     glDisable (GL_DITHER);
733 }
734
735 // =======================================================================
736 // function : DisableFeatures
737 // purpose  :
738 // =======================================================================
739 void OpenGl_Window::DisableFeatures() const
740 {
741   glDisable (GL_DITHER);
742   glPixelTransferi (GL_MAP_COLOR, GL_FALSE);
743
744   /*
745   * Disable stuff that's likely to slow down glDrawPixels.
746   * (Omit as much of this as possible, when you know in advance
747   * that the OpenGL state will already be set correctly.)
748   */
749   glDisable(GL_ALPHA_TEST);
750   glDisable(GL_BLEND);
751   glDisable(GL_DEPTH_TEST);
752   glDisable(GL_FOG);
753   glDisable(GL_LIGHTING);
754
755   glDisable(GL_LOGIC_OP);
756   glDisable(GL_STENCIL_TEST);
757   glDisable(GL_TEXTURE_1D);
758   glDisable(GL_TEXTURE_2D);
759   glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
760   glPixelTransferi(GL_RED_SCALE, 1);
761   glPixelTransferi(GL_RED_BIAS, 0);
762   glPixelTransferi(GL_GREEN_SCALE, 1);
763   glPixelTransferi(GL_GREEN_BIAS, 0);
764   glPixelTransferi(GL_BLUE_SCALE, 1);
765   glPixelTransferi(GL_BLUE_BIAS, 0);
766   glPixelTransferi(GL_ALPHA_SCALE, 1);
767   glPixelTransferi(GL_ALPHA_BIAS, 0);
768
769   /*
770   * Disable extensions that could slow down glDrawPixels.
771   * (Actually, you should check for the presence of the proper
772   * extension before making these calls.  I've omitted that
773   * code for simplicity.)
774   */
775
776 #ifdef GL_EXT_convolution
777   glDisable(GL_CONVOLUTION_1D_EXT);
778   glDisable(GL_CONVOLUTION_2D_EXT);
779   glDisable(GL_SEPARABLE_2D_EXT);
780 #endif
781
782 #ifdef GL_EXT_histogram
783   glDisable(GL_HISTOGRAM_EXT);
784   glDisable(GL_MINMAX_EXT);
785 #endif
786
787 #ifdef GL_EXT_texture3D
788   glDisable(GL_TEXTURE_3D_EXT);
789 #endif
790 }
791
792 // =======================================================================
793 // function : MakeFrontBufCurrent
794 // purpose  : TelMakeFrontBufCurrent
795 // =======================================================================
796 void OpenGl_Window::MakeFrontBufCurrent() const
797 {
798   glDrawBuffer (GL_FRONT);
799 }
800
801 // =======================================================================
802 // function : MakeBackBufCurrent
803 // purpose  : TelMakeBackBufCurrent
804 // =======================================================================
805 void OpenGl_Window::MakeBackBufCurrent() const
806 {
807   glDrawBuffer (GL_BACK);
808 }
809
810 // =======================================================================
811 // function : MakeFrontAndBackBufCurrent
812 // purpose  : TelMakeFrontAndBackBufCurrent
813 // =======================================================================
814 void OpenGl_Window::MakeFrontAndBackBufCurrent() const
815 {
816   glDrawBuffer (GL_FRONT_AND_BACK);
817 }
818
819 // =======================================================================
820 // function : GetGContext
821 // purpose  :
822 // =======================================================================
823 GLCONTEXT OpenGl_Window::GetGContext() const
824 {
825   return (GLCONTEXT )myGlContext->myGContext;
826 }