0024148: Test case bugs/vis/bug24131_markers works wrong on software MS OpenGL
[occt.git] / src / OpenGl / OpenGl_Window.cxx
1 // Created on: 2011-09-20
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20 #include <OpenGl_GlCore11.hxx>
21
22 #include <InterfaceGraphic.hxx>
23
24 #include <OpenGl_Window.hxx>
25
26 #include <OpenGl_Context.hxx>
27 #include <OpenGl_Display.hxx>
28
29 #include <Aspect_GraphicDeviceDefinitionError.hxx>
30 #include <TCollection_AsciiString.hxx>
31
32 IMPLEMENT_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared)
33 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Window,MMgt_TShared)
34
35 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
36
37 namespace
38 {
39   static const TEL_COLOUR THE_DEFAULT_BG_COLOR = { { 0.F, 0.F, 0.F, 1.F } };
40
41 #if defined(_WIN32)
42
43   // WGL_ARB_pixel_format
44 #ifndef WGL_NUMBER_PIXEL_FORMATS_ARB
45   #define WGL_NUMBER_PIXEL_FORMATS_ARB            0x2000
46   #define WGL_DRAW_TO_WINDOW_ARB                  0x2001
47   #define WGL_DRAW_TO_BITMAP_ARB                  0x2002
48   #define WGL_ACCELERATION_ARB                    0x2003
49   #define WGL_NEED_PALETTE_ARB                    0x2004
50   #define WGL_NEED_SYSTEM_PALETTE_ARB             0x2005
51   #define WGL_SWAP_LAYER_BUFFERS_ARB              0x2006
52   #define WGL_SWAP_METHOD_ARB                     0x2007
53   #define WGL_NUMBER_OVERLAYS_ARB                 0x2008
54   #define WGL_NUMBER_UNDERLAYS_ARB                0x2009
55   #define WGL_TRANSPARENT_ARB                     0x200A
56   #define WGL_TRANSPARENT_RED_VALUE_ARB           0x2037
57   #define WGL_TRANSPARENT_GREEN_VALUE_ARB         0x2038
58   #define WGL_TRANSPARENT_BLUE_VALUE_ARB          0x2039
59   #define WGL_TRANSPARENT_ALPHA_VALUE_ARB         0x203A
60   #define WGL_TRANSPARENT_INDEX_VALUE_ARB         0x203B
61   #define WGL_SHARE_DEPTH_ARB                     0x200C
62   #define WGL_SHARE_STENCIL_ARB                   0x200D
63   #define WGL_SHARE_ACCUM_ARB                     0x200E
64   #define WGL_SUPPORT_GDI_ARB                     0x200F
65   #define WGL_SUPPORT_OPENGL_ARB                  0x2010
66   #define WGL_DOUBLE_BUFFER_ARB                   0x2011
67   #define WGL_STEREO_ARB                          0x2012
68   #define WGL_PIXEL_TYPE_ARB                      0x2013
69   #define WGL_COLOR_BITS_ARB                      0x2014
70   #define WGL_RED_BITS_ARB                        0x2015
71   #define WGL_RED_SHIFT_ARB                       0x2016
72   #define WGL_GREEN_BITS_ARB                      0x2017
73   #define WGL_GREEN_SHIFT_ARB                     0x2018
74   #define WGL_BLUE_BITS_ARB                       0x2019
75   #define WGL_BLUE_SHIFT_ARB                      0x201A
76   #define WGL_ALPHA_BITS_ARB                      0x201B
77   #define WGL_ALPHA_SHIFT_ARB                     0x201C
78   #define WGL_ACCUM_BITS_ARB                      0x201D
79   #define WGL_ACCUM_RED_BITS_ARB                  0x201E
80   #define WGL_ACCUM_GREEN_BITS_ARB                0x201F
81   #define WGL_ACCUM_BLUE_BITS_ARB                 0x2020
82   #define WGL_ACCUM_ALPHA_BITS_ARB                0x2021
83   #define WGL_DEPTH_BITS_ARB                      0x2022
84   #define WGL_STENCIL_BITS_ARB                    0x2023
85   #define WGL_AUX_BUFFERS_ARB                     0x2024
86
87   #define WGL_NO_ACCELERATION_ARB                 0x2025
88   #define WGL_GENERIC_ACCELERATION_ARB            0x2026
89   #define WGL_FULL_ACCELERATION_ARB               0x2027
90
91   #define WGL_SWAP_EXCHANGE_ARB                   0x2028
92   #define WGL_SWAP_COPY_ARB                       0x2029
93   #define WGL_SWAP_UNDEFINED_ARB                  0x202A
94
95   #define WGL_TYPE_RGBA_ARB                       0x202B
96   #define WGL_TYPE_COLORINDEX_ARB                 0x202C
97 #endif // WGL_NUMBER_PIXEL_FORMATS_ARB
98
99   // WGL_ARB_create_context_profile
100 #ifndef WGL_CONTEXT_MAJOR_VERSION_ARB
101   #define WGL_CONTEXT_MAJOR_VERSION_ARB           0x2091
102   #define WGL_CONTEXT_MINOR_VERSION_ARB           0x2092
103   #define WGL_CONTEXT_LAYER_PLANE_ARB             0x2093
104   #define WGL_CONTEXT_FLAGS_ARB                   0x2094
105   #define WGL_CONTEXT_PROFILE_MASK_ARB            0x9126
106
107   // WGL_CONTEXT_FLAGS bits
108   #define WGL_CONTEXT_DEBUG_BIT_ARB               0x0001
109   #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002
110
111   // WGL_CONTEXT_PROFILE_MASK_ARB bits
112   #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB          0x00000001
113   #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
114 #endif // WGL_CONTEXT_MAJOR_VERSION_ARB
115
116   static LRESULT CALLBACK wndProcDummy (HWND theWin, UINT theMsg, WPARAM theParamW, LPARAM theParamL)
117   {
118     return DefWindowProcW (theWin, theMsg, theParamW, theParamL);
119   }
120 #else
121   static Bool WaitForNotify (Display* theDisp, XEvent* theEv, char* theArg)
122   {
123     return (theEv->type == MapNotify) && (theEv->xmap.window == (Window )theArg);
124   }
125 #endif
126
127 };
128
129 // =======================================================================
130 // function : OpenGl_Window
131 // purpose  :
132 // =======================================================================
133 OpenGl_Window::OpenGl_Window (const Handle(OpenGl_Display)& theDisplay,
134                               const CALL_DEF_WINDOW&        theCWindow,
135                               Aspect_RenderingContext       theGContext,
136                               const Handle(OpenGl_Caps)&    theCaps,
137                               const Handle(OpenGl_Context)& theShareCtx)
138 : myDisplay (theDisplay),
139   myGlContext (new OpenGl_Context (theCaps)),
140   myOwnGContext (theGContext == 0),
141 #if defined(_WIN32)
142   mySysPalInUse (FALSE),
143 #endif
144   myWidth ((Standard_Integer )theCWindow.dx),
145   myHeight ((Standard_Integer )theCWindow.dy),
146   myBgColor (THE_DEFAULT_BG_COLOR),
147   myDither (theDisplay->Dither()),
148   myBackDither (theDisplay->BackDither())
149 {
150   myBgColor.rgb[0] = theCWindow.Background.r;
151   myBgColor.rgb[1] = theCWindow.Background.g;
152   myBgColor.rgb[2] = theCWindow.Background.b;
153
154 #if defined(_WIN32)
155   HWND  aWindow   = (HWND )theCWindow.XWindow;
156   HDC   aWindowDC = GetDC (aWindow);
157   HGLRC aGContext = (HGLRC )theGContext;
158
159   PIXELFORMATDESCRIPTOR aPixelFrmt;
160   memset (&aPixelFrmt, 0, sizeof(aPixelFrmt));
161   aPixelFrmt.nSize        = sizeof(PIXELFORMATDESCRIPTOR);
162   aPixelFrmt.nVersion     = 1;
163   aPixelFrmt.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
164   aPixelFrmt.iPixelType   = PFD_TYPE_RGBA;
165   aPixelFrmt.cColorBits   = 24;
166   aPixelFrmt.cDepthBits   = 24;
167   aPixelFrmt.cStencilBits = 8;
168   aPixelFrmt.iLayerType   = PFD_MAIN_PLANE;
169   if (theCaps->contextStereo)
170   {
171     aPixelFrmt.dwFlags |= PFD_STEREO;
172   }
173
174   int aPixelFrmtId = ChoosePixelFormat (aWindowDC, &aPixelFrmt);
175   if (aPixelFrmtId == 0)
176   {
177     ReleaseDC (aWindow, aWindowDC);
178
179     TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: ChoosePixelFormat failed. Error code: ");
180     aMsg += (int )GetLastError();
181     Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
182     return;
183   }
184
185   DescribePixelFormat (aWindowDC, aPixelFrmtId, sizeof(aPixelFrmt), &aPixelFrmt);
186   if (aPixelFrmt.dwFlags & PFD_NEED_PALETTE)
187   {
188     WINDOW_DATA* aWndData = (WINDOW_DATA* )GetWindowLongPtr (aWindow, GWLP_USERDATA);
189
190     mySysPalInUse = (aPixelFrmt.dwFlags & PFD_NEED_SYSTEM_PALETTE) ? TRUE : FALSE;
191     InterfaceGraphic_RealizePalette (aWindowDC, aWndData->hPal, FALSE, mySysPalInUse);
192   }
193
194   if (myDither)
195   {
196     myDither = (aPixelFrmt.cColorBits <= 8);
197   }
198
199   if (myBackDither)
200   {
201     myBackDither = (aPixelFrmt.cColorBits <= 8);
202   }
203
204   HGLRC aSlaveCtx = !theShareCtx.IsNull() ? (HGLRC )theShareCtx->myGContext : NULL;
205   if (aGContext == NULL)
206   {
207     // create temporary context to retrieve advanced context creation procedures
208     HMODULE aModule = GetModuleHandleW(NULL);
209     WNDCLASSW aClass; memset (&aClass, 0, sizeof(aClass));
210     aClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
211     aClass.lpfnWndProc   = wndProcDummy;
212     aClass.hInstance     = aModule;
213     aClass.lpszClassName = L"OpenGl_WindowTmp";
214     HWND  aWinTmp     = NULL;
215     HDC   aDevCtxTmp  = NULL;
216     HGLRC aRendCtxTmp = NULL;
217     if ((!theCaps->contextDebug && !theCaps->contextNoAccel)
218      || RegisterClassW (&aClass) == 0)
219     {
220       aClass.lpszClassName = NULL;
221     }
222     if (aClass.lpszClassName != NULL)
223     {
224       aWinTmp = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE | WS_EX_NOACTIVATE,
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 || !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 defined(_WIN32)
547   HWND  aWindow   = (HWND  )myGlContext->myWindow;
548   HDC   aWindowDC = (HDC   )myGlContext->myWindowDC;
549   HGLRC aGContext = (HGLRC )myGlContext->myGContext;
550   myGlContext.Nullify();
551
552   if (myOwnGContext)
553   {
554     if (wglGetCurrentContext() != NULL)
555     {
556       wglDeleteContext (aGContext);
557     }
558     ReleaseDC (aWindow, aWindowDC);
559   }
560 #else
561   Display*    aDisplay  = (Display*    )myGlContext->myDisplay;
562   GLXContext  aGContext = (GLXContext  )myGlContext->myGContext;
563   myGlContext.Nullify();
564
565   if (aDisplay != NULL && myOwnGContext)
566   {
567     // FSXXX sync necessary if non-direct rendering
568     glXWaitGL();
569     glXDestroyContext (aDisplay, aGContext);
570   }
571 #endif
572 }
573
574 #endif // !__APPLE__
575
576 // =======================================================================
577 // function : Activate
578 // purpose  :
579 // =======================================================================
580 Standard_Boolean OpenGl_Window::Activate()
581 {
582   return myGlContext->MakeCurrent();
583 }
584
585 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
586
587 // =======================================================================
588 // function : Resize
589 // purpose  : call_subr_resize
590 // =======================================================================
591 void OpenGl_Window::Resize (const CALL_DEF_WINDOW& theCWindow)
592 {
593   DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay();
594   if (aDisp == NULL)
595     return;
596
597   // If the size is not changed - do nothing
598   if ((myWidth == theCWindow.dx) && (myHeight == theCWindow.dy))
599     return;
600
601   myWidth  = (Standard_Integer )theCWindow.dx;
602   myHeight = (Standard_Integer )theCWindow.dy;
603
604 #if !defined(_WIN32)
605   XResizeWindow (aDisp, myGlContext->myWindow, (unsigned int )myWidth, (unsigned int )myHeight);
606   XSync (aDisp, False);
607 #endif
608
609   Init();
610 }
611
612 #endif // !__APPLE__
613
614 // =======================================================================
615 // function : ReadDepths
616 // purpose  : TelReadDepths
617 // =======================================================================
618 void OpenGl_Window::ReadDepths (const Standard_Integer theX,     const Standard_Integer theY,
619                                 const Standard_Integer theWidth, const Standard_Integer theHeight,
620                                 float* theDepths)
621 {
622   if (theDepths == NULL || !Activate())
623     return;
624
625   glMatrixMode (GL_PROJECTION);
626   glLoadIdentity();
627   gluOrtho2D (0.0, (GLdouble )myWidth, 0.0, (GLdouble )myHeight);
628   glMatrixMode (GL_MODELVIEW);
629   glLoadIdentity();
630
631   glRasterPos2i (theX, theY);
632   DisableFeatures();
633   glReadPixels (theX, theY, theWidth, theHeight, GL_DEPTH_COMPONENT, GL_FLOAT, theDepths);
634   EnableFeatures();
635 }
636
637 // =======================================================================
638 // function : SetBackgroundColor
639 // purpose  : call_subr_set_background
640 // =======================================================================
641 void OpenGl_Window::SetBackgroundColor (const Standard_ShortReal theR,
642                                         const Standard_ShortReal theG,
643                                         const Standard_ShortReal theB)
644 {
645   myBgColor.rgb[0] = theR;
646   myBgColor.rgb[1] = theG;
647   myBgColor.rgb[2] = theB;
648 }
649
650 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
651
652 // =======================================================================
653 // function : Init
654 // purpose  :
655 // =======================================================================
656 void OpenGl_Window::Init()
657 {
658   if (!Activate())
659     return;
660
661 #if defined(_WIN32)
662   RECT cr;
663   GetClientRect ((HWND )myGlContext->myWindow, &cr);
664   myWidth  = cr.right - cr.left;
665   myHeight = cr.bottom - cr.top;
666 #else
667   Window aRootWin;
668   int aDummy;
669   unsigned int aDummyU;
670   unsigned int aNewWidth  = 0;
671   unsigned int aNewHeight = 0;
672   DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay();
673   XGetGeometry (aDisp, myGlContext->myWindow, &aRootWin, &aDummy, &aDummy, &aNewWidth, &aNewHeight, &aDummyU, &aDummyU);
674   myWidth  = aNewWidth;
675   myHeight = aNewHeight;
676 #endif
677
678   glMatrixMode (GL_MODELVIEW);
679   glViewport (0, 0, myWidth, myHeight);
680
681   glDisable (GL_SCISSOR_TEST);
682   glDrawBuffer (GL_BACK);
683 }
684
685 #endif // !__APPLE__
686
687 // =======================================================================
688 // function : EnablePolygonOffset
689 // purpose  : call_subr_enable_polygon_offset
690 // =======================================================================
691 void OpenGl_Window::EnablePolygonOffset() const
692 {
693   Standard_ShortReal aFactor, aUnits;
694   myDisplay->PolygonOffset (aFactor, aUnits);
695   glPolygonOffset (aFactor, aUnits);
696   glEnable (GL_POLYGON_OFFSET_FILL);
697 }
698
699 // =======================================================================
700 // function : DisablePolygonOffset
701 // purpose  : call_subr_disable_polygon_offset
702 // =======================================================================
703 void OpenGl_Window::DisablePolygonOffset() const
704 {
705   glDisable (GL_POLYGON_OFFSET_FILL);
706 }
707
708 // =======================================================================
709 // function : EnableFeatures
710 // purpose  :
711 // =======================================================================
712 void OpenGl_Window::EnableFeatures() const
713 {
714   /*glPixelTransferi (GL_MAP_COLOR, GL_TRUE);*/
715
716   if (myDither)
717     glEnable (GL_DITHER);
718   else
719     glDisable (GL_DITHER);
720 }
721
722 // =======================================================================
723 // function : DisableFeatures
724 // purpose  :
725 // =======================================================================
726 void OpenGl_Window::DisableFeatures() const
727 {
728   glDisable (GL_DITHER);
729   glPixelTransferi (GL_MAP_COLOR, GL_FALSE);
730
731   /*
732   * Disable stuff that's likely to slow down glDrawPixels.
733   * (Omit as much of this as possible, when you know in advance
734   * that the OpenGL state will already be set correctly.)
735   */
736   glDisable(GL_ALPHA_TEST);
737   glDisable(GL_BLEND);
738   glDisable(GL_DEPTH_TEST);
739   glDisable(GL_FOG);
740   glDisable(GL_LIGHTING);
741
742   glDisable(GL_LOGIC_OP);
743   glDisable(GL_STENCIL_TEST);
744   glDisable(GL_TEXTURE_1D);
745   glDisable(GL_TEXTURE_2D);
746   glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
747   glPixelTransferi(GL_RED_SCALE, 1);
748   glPixelTransferi(GL_RED_BIAS, 0);
749   glPixelTransferi(GL_GREEN_SCALE, 1);
750   glPixelTransferi(GL_GREEN_BIAS, 0);
751   glPixelTransferi(GL_BLUE_SCALE, 1);
752   glPixelTransferi(GL_BLUE_BIAS, 0);
753   glPixelTransferi(GL_ALPHA_SCALE, 1);
754   glPixelTransferi(GL_ALPHA_BIAS, 0);
755
756   /*
757   * Disable extensions that could slow down glDrawPixels.
758   * (Actually, you should check for the presence of the proper
759   * extension before making these calls.  I've omitted that
760   * code for simplicity.)
761   */
762
763 #ifdef GL_EXT_convolution
764   glDisable(GL_CONVOLUTION_1D_EXT);
765   glDisable(GL_CONVOLUTION_2D_EXT);
766   glDisable(GL_SEPARABLE_2D_EXT);
767 #endif
768
769 #ifdef GL_EXT_histogram
770   glDisable(GL_HISTOGRAM_EXT);
771   glDisable(GL_MINMAX_EXT);
772 #endif
773
774 #ifdef GL_EXT_texture3D
775   glDisable(GL_TEXTURE_3D_EXT);
776 #endif
777 }
778
779 // =======================================================================
780 // function : MakeFrontBufCurrent
781 // purpose  : TelMakeFrontBufCurrent
782 // =======================================================================
783 void OpenGl_Window::MakeFrontBufCurrent() const
784 {
785   glDrawBuffer (GL_FRONT);
786 }
787
788 // =======================================================================
789 // function : MakeBackBufCurrent
790 // purpose  : TelMakeBackBufCurrent
791 // =======================================================================
792 void OpenGl_Window::MakeBackBufCurrent() const
793 {
794   glDrawBuffer (GL_BACK);
795 }
796
797 // =======================================================================
798 // function : MakeFrontAndBackBufCurrent
799 // purpose  : TelMakeFrontAndBackBufCurrent
800 // =======================================================================
801 void OpenGl_Window::MakeFrontAndBackBufCurrent() const
802 {
803   glDrawBuffer (GL_FRONT_AND_BACK);
804 }
805
806 // =======================================================================
807 // function : GetGContext
808 // purpose  :
809 // =======================================================================
810 GLCONTEXT OpenGl_Window::GetGContext() const
811 {
812   return (GLCONTEXT )myGlContext->myGContext;
813 }