0027684: Coding rules - drop unused declarations from Graphic3d
[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 under
8 // the terms of the GNU Lesser General Public License 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_GlCore12.hxx>
17
18 #include <OpenGl_Context.hxx>
19 #include <OpenGl_GraphicDriver.hxx>
20 #include <OpenGl_Window.hxx>
21
22 #include <Aspect_GraphicDeviceDefinitionError.hxx>
23 #include <Graphic3d_TransformUtils.hxx>
24 #include <TCollection_AsciiString.hxx>
25 #include <TCollection_ExtendedString.hxx>
26 #include <Graphic3d_GraphicDriver.hxx>
27
28 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Window,MMgt_TShared)
29
30 #if defined(HAVE_EGL) || defined(__ANDROID__) || defined(__QNX__)
31   #include <EGL/egl.h>
32 #endif
33
34
35 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
36
37 namespace
38 {
39
40 #if defined(HAVE_EGL) || defined(__ANDROID__) || defined(__QNX__)
41   //
42 #elif defined(_WIN32)
43
44   // WGL_ARB_pixel_format
45 #ifndef WGL_NUMBER_PIXEL_FORMATS_ARB
46   #define WGL_NUMBER_PIXEL_FORMATS_ARB            0x2000
47   #define WGL_DRAW_TO_WINDOW_ARB                  0x2001
48   #define WGL_DRAW_TO_BITMAP_ARB                  0x2002
49   #define WGL_ACCELERATION_ARB                    0x2003
50   #define WGL_NEED_PALETTE_ARB                    0x2004
51   #define WGL_NEED_SYSTEM_PALETTE_ARB             0x2005
52   #define WGL_SWAP_LAYER_BUFFERS_ARB              0x2006
53   #define WGL_SWAP_METHOD_ARB                     0x2007
54   #define WGL_NUMBER_OVERLAYS_ARB                 0x2008
55   #define WGL_NUMBER_UNDERLAYS_ARB                0x2009
56   #define WGL_TRANSPARENT_ARB                     0x200A
57   #define WGL_TRANSPARENT_RED_VALUE_ARB           0x2037
58   #define WGL_TRANSPARENT_GREEN_VALUE_ARB         0x2038
59   #define WGL_TRANSPARENT_BLUE_VALUE_ARB          0x2039
60   #define WGL_TRANSPARENT_ALPHA_VALUE_ARB         0x203A
61   #define WGL_TRANSPARENT_INDEX_VALUE_ARB         0x203B
62   #define WGL_SHARE_DEPTH_ARB                     0x200C
63   #define WGL_SHARE_STENCIL_ARB                   0x200D
64   #define WGL_SHARE_ACCUM_ARB                     0x200E
65   #define WGL_SUPPORT_GDI_ARB                     0x200F
66   #define WGL_SUPPORT_OPENGL_ARB                  0x2010
67   #define WGL_DOUBLE_BUFFER_ARB                   0x2011
68   #define WGL_STEREO_ARB                          0x2012
69   #define WGL_PIXEL_TYPE_ARB                      0x2013
70   #define WGL_COLOR_BITS_ARB                      0x2014
71   #define WGL_RED_BITS_ARB                        0x2015
72   #define WGL_RED_SHIFT_ARB                       0x2016
73   #define WGL_GREEN_BITS_ARB                      0x2017
74   #define WGL_GREEN_SHIFT_ARB                     0x2018
75   #define WGL_BLUE_BITS_ARB                       0x2019
76   #define WGL_BLUE_SHIFT_ARB                      0x201A
77   #define WGL_ALPHA_BITS_ARB                      0x201B
78   #define WGL_ALPHA_SHIFT_ARB                     0x201C
79   #define WGL_ACCUM_BITS_ARB                      0x201D
80   #define WGL_ACCUM_RED_BITS_ARB                  0x201E
81   #define WGL_ACCUM_GREEN_BITS_ARB                0x201F
82   #define WGL_ACCUM_BLUE_BITS_ARB                 0x2020
83   #define WGL_ACCUM_ALPHA_BITS_ARB                0x2021
84   #define WGL_DEPTH_BITS_ARB                      0x2022
85   #define WGL_STENCIL_BITS_ARB                    0x2023
86   #define WGL_AUX_BUFFERS_ARB                     0x2024
87
88   #define WGL_NO_ACCELERATION_ARB                 0x2025
89   #define WGL_GENERIC_ACCELERATION_ARB            0x2026
90   #define WGL_FULL_ACCELERATION_ARB               0x2027
91
92   #define WGL_SWAP_EXCHANGE_ARB                   0x2028
93   #define WGL_SWAP_COPY_ARB                       0x2029
94   #define WGL_SWAP_UNDEFINED_ARB                  0x202A
95
96   #define WGL_TYPE_RGBA_ARB                       0x202B
97   #define WGL_TYPE_COLORINDEX_ARB                 0x202C
98 #endif // WGL_NUMBER_PIXEL_FORMATS_ARB
99
100   // WGL_ARB_create_context_profile
101 #ifndef WGL_CONTEXT_MAJOR_VERSION_ARB
102   #define WGL_CONTEXT_MAJOR_VERSION_ARB           0x2091
103   #define WGL_CONTEXT_MINOR_VERSION_ARB           0x2092
104   #define WGL_CONTEXT_LAYER_PLANE_ARB             0x2093
105   #define WGL_CONTEXT_FLAGS_ARB                   0x2094
106   #define WGL_CONTEXT_PROFILE_MASK_ARB            0x9126
107
108   // WGL_CONTEXT_FLAGS bits
109   #define WGL_CONTEXT_DEBUG_BIT_ARB               0x0001
110   #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002
111
112   // WGL_CONTEXT_PROFILE_MASK_ARB bits
113   #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB          0x00000001
114   #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
115 #endif // WGL_CONTEXT_MAJOR_VERSION_ARB
116
117   static LRESULT CALLBACK wndProcDummy (HWND theWin, UINT theMsg, WPARAM theParamW, LPARAM theParamL)
118   {
119     return DefWindowProcW (theWin, theMsg, theParamW, theParamL);
120   }
121 #else
122
123   // GLX_ARB_create_context
124 #ifndef GLX_CONTEXT_MAJOR_VERSION_ARB
125   #define GLX_CONTEXT_DEBUG_BIT_ARB         0x00000001
126   #define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
127   #define GLX_CONTEXT_MAJOR_VERSION_ARB     0x2091
128   #define GLX_CONTEXT_MINOR_VERSION_ARB     0x2092
129   #define GLX_CONTEXT_FLAGS_ARB             0x2094
130
131   // GLX_ARB_create_context_profile
132   #define GLX_CONTEXT_CORE_PROFILE_BIT_ARB  0x00000001
133   #define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
134   #define GLX_CONTEXT_PROFILE_MASK_ARB      0x9126
135 #endif
136
137   //! Dummy XError handler which just skips errors
138   static int xErrorDummyHandler (Display*     /*theDisplay*/,
139                                  XErrorEvent* /*theErrorEvent*/)
140   {
141     return 0;
142   }
143
144   //! Auxiliary method to format list.
145   static void addMsgToList (TCollection_ExtendedString&       theList,
146                             const TCollection_ExtendedString& theMsg)
147   {
148     if (!theList.IsEmpty())
149     {
150       theList += ", ";
151     }
152     theList += theMsg;
153   }
154 #endif
155
156 }
157
158 // =======================================================================
159 // function : OpenGl_Window
160 // purpose  :
161 // =======================================================================
162 OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
163                               const Handle(Aspect_Window)&  thePlatformWindow,
164                               Aspect_RenderingContext       theGContext,
165                               const Handle(OpenGl_Caps)&    theCaps,
166                               const Handle(OpenGl_Context)& theShareCtx)
167 : myGlContext (new OpenGl_Context (theCaps)),
168   myOwnGContext (theGContext == 0),
169   myPlatformWindow (thePlatformWindow),
170   mySwapInterval (theCaps->swapInterval)
171 {
172   myPlatformWindow->Size (myWidth, myHeight);
173
174   Standard_Boolean isCoreProfile = Standard_False;
175
176 #if defined(HAVE_EGL) || defined(__ANDROID__) || defined(__QNX__)
177   EGLDisplay anEglDisplay = (EGLDisplay )theDriver->getRawGlDisplay();
178   EGLContext anEglContext = (EGLContext )theDriver->getRawGlContext();
179   EGLConfig  anEglConfig  = (EGLConfig  )theDriver->getRawGlConfig();
180   if (anEglDisplay == EGL_NO_DISPLAY
181    || anEglContext == EGL_NO_CONTEXT
182    || anEglConfig == NULL)
183   {
184     Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL does not provide compatible configurations!");
185     return;
186   }
187
188   EGLSurface anEglSurf = EGL_NO_SURFACE;
189   if (theGContext == (EGLContext )EGL_NO_CONTEXT)
190   {
191     // create new surface
192     anEglSurf = eglCreateWindowSurface (anEglDisplay,
193                                         anEglConfig,
194                                         (EGLNativeWindowType )myPlatformWindow->NativeHandle(),
195                                         NULL);
196     if (anEglSurf == EGL_NO_SURFACE)
197     {
198       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL is unable to create surface for window!");
199       return;
200     }
201   }
202   else if (theGContext != anEglContext)
203   {
204     Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL is used in unsupported combination!");
205     return;
206   }
207   else
208   {
209     anEglSurf = eglGetCurrentSurface(EGL_DRAW);
210     if (anEglSurf == EGL_NO_SURFACE)
211     {
212       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL is unable to retrieve current surface!");
213       return;
214     }
215   }
216
217   myGlContext->Init ((Aspect_Drawable )anEglSurf, (Aspect_Display )anEglDisplay, (Aspect_RenderingContext )anEglContext, isCoreProfile);
218 #elif defined(_WIN32)
219   (void )theDriver;
220   HWND  aWindow   = (HWND )myPlatformWindow->NativeHandle();
221   HDC   aWindowDC = GetDC (aWindow);
222   HGLRC aGContext = (HGLRC )theGContext;
223
224   PIXELFORMATDESCRIPTOR aPixelFrmt;
225   memset (&aPixelFrmt, 0, sizeof(aPixelFrmt));
226   aPixelFrmt.nSize        = sizeof(PIXELFORMATDESCRIPTOR);
227   aPixelFrmt.nVersion     = 1;
228   aPixelFrmt.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
229   aPixelFrmt.iPixelType   = PFD_TYPE_RGBA;
230   aPixelFrmt.cColorBits   = 24;
231   aPixelFrmt.cDepthBits   = 24;
232   aPixelFrmt.cStencilBits = 8;
233   aPixelFrmt.iLayerType   = PFD_MAIN_PLANE;
234   if (theCaps->contextStereo)
235   {
236     aPixelFrmt.dwFlags |= PFD_STEREO;
237   }
238
239   int aPixelFrmtId = ChoosePixelFormat (aWindowDC, &aPixelFrmt);
240
241   // in case of failure try without stereo if any
242   const Standard_Boolean hasStereo = aPixelFrmtId != 0 && theCaps->contextStereo;
243   if (aPixelFrmtId == 0 && theCaps->contextStereo)
244   {
245     TCollection_ExtendedString aMsg ("OpenGl_Window::CreateWindow: "
246                                      "ChoosePixelFormat is unable to find stereo supported pixel format. "
247                                      "Choosing similar non stereo format.");
248     myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
249                               GL_DEBUG_TYPE_OTHER,
250                               0, GL_DEBUG_SEVERITY_HIGH, aMsg);
251
252     aPixelFrmt.dwFlags &= ~PFD_STEREO;
253     aPixelFrmtId = ChoosePixelFormat (aWindowDC, &aPixelFrmt);
254   }
255
256   if (aPixelFrmtId == 0)
257   {
258     ReleaseDC (aWindow, aWindowDC);
259
260     TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: ChoosePixelFormat failed. Error code: ");
261     aMsg += (int )GetLastError();
262     Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
263     return;
264   }
265
266   DescribePixelFormat (aWindowDC, aPixelFrmtId, sizeof(aPixelFrmt), &aPixelFrmt);
267
268   HGLRC aSlaveCtx = !theShareCtx.IsNull() ? (HGLRC )theShareCtx->myGContext : NULL;
269   if (aGContext == NULL)
270   {
271     // create temporary context to retrieve advanced context creation procedures
272     HMODULE aModule = GetModuleHandleW(NULL);
273     WNDCLASSW aClass; memset (&aClass, 0, sizeof(aClass));
274     aClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
275     aClass.lpfnWndProc   = wndProcDummy;
276     aClass.hInstance     = aModule;
277     aClass.lpszClassName = L"OpenGl_WindowTmp";
278     HWND  aWinTmp     = NULL;
279     HDC   aDevCtxTmp  = NULL;
280     HGLRC aRendCtxTmp = NULL;
281     if ((!theCaps->contextDebug && !theCaps->contextNoAccel && theCaps->contextCompatible)
282      || RegisterClassW (&aClass) == 0)
283     {
284       aClass.lpszClassName = NULL;
285     }
286     if (aClass.lpszClassName != NULL)
287     {
288       DWORD anExStyle = WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE;
289     #if (_WIN32_WINNT >= 0x0500)
290       anExStyle |= WS_EX_NOACTIVATE;
291     #endif
292       aWinTmp = CreateWindowExW(anExStyle,
293                                 aClass.lpszClassName, L"OpenGl_WindowTmp",
294                                 WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED,
295                                 2, 2, 4, 4,
296                                 NULL, NULL, aModule, NULL);
297     }
298     if (aWinTmp != NULL)
299     {
300       aDevCtxTmp = GetDC (aWinTmp);
301       SetPixelFormat (aDevCtxTmp, aPixelFrmtId, &aPixelFrmt);
302       aRendCtxTmp = wglCreateContext (aDevCtxTmp);
303     }
304
305     typedef BOOL (WINAPI *wglChoosePixelFormatARB_t)(HDC           theDevCtx,
306                                                      const int*    theIntAttribs,
307                                                      const float*  theFloatAttribs,
308                                                      unsigned int  theMaxFormats,
309                                                      int*          theFormatsOut,
310                                                      unsigned int* theNumFormatsOut);
311     typedef HGLRC (WINAPI *wglCreateContextAttribsARB_t)(HDC        theDevCtx,
312                                                          HGLRC      theShareContext,
313                                                          const int* theAttribs);
314     wglChoosePixelFormatARB_t    aChoosePixProc = NULL;
315     wglCreateContextAttribsARB_t aCreateCtxProc = NULL;
316     if (aRendCtxTmp != NULL)
317     {
318       wglMakeCurrent (aDevCtxTmp, aRendCtxTmp);
319
320       typedef const char* (WINAPI *wglGetExtensionsStringARB_t)(HDC theDeviceContext);
321       wglGetExtensionsStringARB_t aGetExtensions = (wglGetExtensionsStringARB_t  )wglGetProcAddress ("wglGetExtensionsStringARB");
322       const char* aWglExts = (aGetExtensions != NULL) ? aGetExtensions (wglGetCurrentDC()) : NULL;
323       if (OpenGl_Context::CheckExtension (aWglExts, "WGL_ARB_pixel_format"))
324       {
325         aChoosePixProc = (wglChoosePixelFormatARB_t    )wglGetProcAddress ("wglChoosePixelFormatARB");
326       }
327       if (OpenGl_Context::CheckExtension (aWglExts, "WGL_ARB_create_context_profile"))
328       {
329         aCreateCtxProc = (wglCreateContextAttribsARB_t )wglGetProcAddress ("wglCreateContextAttribsARB");
330       }
331     }
332
333     // choose extended pixel format
334     if (aChoosePixProc != NULL)
335     {
336       const int aPixAttribs[] =
337       {
338         WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
339         WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
340         WGL_DOUBLE_BUFFER_ARB,  GL_TRUE,
341         WGL_STEREO_ARB,         hasStereo ? GL_TRUE : GL_FALSE,
342         WGL_PIXEL_TYPE_ARB,     WGL_TYPE_RGBA_ARB,
343         //WGL_SAMPLE_BUFFERS_ARB, 1,
344         //WGL_SAMPLES_ARB,        8,
345         WGL_COLOR_BITS_ARB,     24,
346         WGL_DEPTH_BITS_ARB,     24,
347         WGL_STENCIL_BITS_ARB,   8,
348         WGL_ACCELERATION_ARB,   theCaps->contextNoAccel ? WGL_NO_ACCELERATION_ARB : WGL_FULL_ACCELERATION_ARB,
349         0, 0,
350       };
351       unsigned int aFrmtsNb = 0;
352       aChoosePixProc (aWindowDC, aPixAttribs, NULL, 1, &aPixelFrmtId, &aFrmtsNb);
353     }
354
355     // setup pixel format - may be set only once per window
356     if (!SetPixelFormat (aWindowDC, aPixelFrmtId, &aPixelFrmt))
357     {
358       ReleaseDC (aWindow, aWindowDC);
359
360       TCollection_AsciiString aMsg("OpenGl_Window::CreateWindow: SetPixelFormat failed. Error code: ");
361       aMsg += (int )GetLastError();
362       Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
363       return;
364     }
365
366     // create GL context with extra options
367     if (aCreateCtxProc != NULL)
368     {
369       if (!theCaps->contextCompatible)
370       {
371         int aCoreCtxAttribs[] =
372         {
373           WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
374           WGL_CONTEXT_MINOR_VERSION_ARB, 2,
375           WGL_CONTEXT_PROFILE_MASK_ARB,  WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
376           WGL_CONTEXT_FLAGS_ARB,         theCaps->contextDebug ? WGL_CONTEXT_DEBUG_BIT_ARB : 0,
377           0, 0
378         };
379
380         // Try to create the core profile of highest OpenGL version supported by OCCT
381         // (this will be done automatically by some drivers when requesting 3.2,
382         //  but some will not (e.g. AMD Catalyst) since WGL_ARB_create_context_profile specification allows both implementations).
383         for (int aLowVer4 = 5; aLowVer4 >= 0 && aGContext == NULL; --aLowVer4)
384         {
385           aCoreCtxAttribs[1] = 4;
386           aCoreCtxAttribs[3] = aLowVer4;
387           aGContext = aCreateCtxProc (aWindowDC, aSlaveCtx, aCoreCtxAttribs);
388         }
389         for (int aLowVer3 = 3; aLowVer3 >= 2 && aGContext == NULL; --aLowVer3)
390         {
391           aCoreCtxAttribs[1] = 3;
392           aCoreCtxAttribs[3] = aLowVer3;
393           aGContext = aCreateCtxProc (aWindowDC, aSlaveCtx, aCoreCtxAttribs);
394         }
395         isCoreProfile = aGContext != NULL;
396       }
397
398       if (aGContext == NULL)
399       {
400         int aCtxAttribs[] =
401         {
402           // Beware! NVIDIA drivers reject context creation when WGL_CONTEXT_PROFILE_MASK_ARB are specified
403           // but not WGL_CONTEXT_MAJOR_VERSION_ARB/WGL_CONTEXT_MINOR_VERSION_ARB.
404           //WGL_CONTEXT_PROFILE_MASK_ARB,  WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
405           WGL_CONTEXT_FLAGS_ARB,         theCaps->contextDebug ? WGL_CONTEXT_DEBUG_BIT_ARB : 0,
406           0, 0
407         };
408         isCoreProfile = Standard_False;
409         aGContext = aCreateCtxProc (aWindowDC, aSlaveCtx, aCtxAttribs);
410
411         if (aGContext != NULL
412         && !theCaps->contextCompatible)
413         {
414           TCollection_ExtendedString aMsg("OpenGl_Window::CreateWindow: core profile creation failed.");
415           myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
416         }
417       }
418
419       if (aGContext != NULL)
420       {
421         aSlaveCtx = NULL;
422       }
423     }
424
425     if (aRendCtxTmp != NULL)
426     {
427       wglDeleteContext (aRendCtxTmp);
428     }
429     if (aDevCtxTmp != NULL)
430     {
431       ReleaseDC (aWinTmp, aDevCtxTmp);
432     }
433     if (aWinTmp != NULL)
434     {
435       DestroyWindow (aWinTmp);
436     }
437     if (aClass.lpszClassName != NULL)
438     {
439       UnregisterClassW (aClass.lpszClassName, aModule);
440     }
441
442     if (aGContext == NULL)
443     {
444       // create context using obsolete functionality
445       aGContext = wglCreateContext (aWindowDC);
446     }
447     if (aGContext == NULL)
448     {
449       ReleaseDC (aWindow, aWindowDC);
450
451       TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglCreateContext failed. Error code: ");
452       aMsg += (int )GetLastError();
453       Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
454       return;
455     }
456   }
457
458   // all GL context within one OpenGl_GraphicDriver should be shared!
459   if (aSlaveCtx != NULL && wglShareLists (aSlaveCtx, aGContext) != TRUE)
460   {
461     TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglShareLists failed. Error code: ");
462     aMsg += (int )GetLastError();
463     Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
464     return;
465   }
466
467   myGlContext->Init ((Aspect_Handle )aWindow, (Aspect_Handle )aWindowDC, (Aspect_RenderingContext )aGContext, isCoreProfile);
468 #else
469   Window     aWindow   = (Window )myPlatformWindow->NativeHandle();
470   Display*   aDisp     = theDriver->GetDisplayConnection()->GetDisplay();
471   GLXContext aGContext = (GLXContext )theGContext;
472   GLXContext aSlaveCtx = !theShareCtx.IsNull() ? (GLXContext )theShareCtx->myGContext : NULL;
473
474   XWindowAttributes aWinAttribs;
475   XGetWindowAttributes (aDisp, aWindow, &aWinAttribs);
476   XVisualInfo aVisInfo;
477   aVisInfo.visualid = aWinAttribs.visual->visualid;
478   aVisInfo.screen   = DefaultScreen (aDisp);
479   int aNbItems;
480   XVisualInfo* aVis = XGetVisualInfo (aDisp, VisualIDMask | VisualScreenMask, &aVisInfo, &aNbItems);
481   int isGl = 0;
482   if (aVis == NULL)
483   {
484     Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: XGetVisualInfo is unable to choose needed configuration in existing OpenGL context. ");
485     return;
486   }
487   else if (glXGetConfig (aDisp, aVis, GLX_USE_GL, &isGl) != 0 || !isGl)
488   {
489     Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: window Visual does not support GL rendering!");
490     return;
491   }
492
493   // create new context
494   GLXFBConfig anFBConfig = myPlatformWindow->NativeFBConfig();
495   const char* aGlxExts   = glXQueryExtensionsString (aDisp, aVisInfo.screen);
496   if (myOwnGContext
497    && anFBConfig != NULL
498    && OpenGl_Context::CheckExtension (aGlxExts, "GLX_ARB_create_context_profile"))
499   {
500     // Replace default XError handler to ignore errors.
501     // Warning - this is global for all threads!
502     typedef int (*xerrorhandler_t)(Display* , XErrorEvent* );
503     xerrorhandler_t anOldHandler = XSetErrorHandler(xErrorDummyHandler);
504
505     typedef GLXContext (*glXCreateContextAttribsARB_t)(Display* dpy, GLXFBConfig config,
506                                                        GLXContext share_context, Bool direct,
507                                                        const int* attrib_list);
508     glXCreateContextAttribsARB_t aCreateCtxProc = (glXCreateContextAttribsARB_t )glXGetProcAddress((const GLubyte* )"glXCreateContextAttribsARB");
509     if (!theCaps->contextCompatible)
510     {
511       int aCoreCtxAttribs[] =
512       {
513         GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
514         GLX_CONTEXT_MINOR_VERSION_ARB, 2,
515         GLX_CONTEXT_PROFILE_MASK_ARB,  GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
516         GLX_CONTEXT_FLAGS_ARB,         theCaps->contextDebug ? GLX_CONTEXT_DEBUG_BIT_ARB : 0,
517         0, 0
518       };
519
520       // try to create the core profile of highest OpenGL version supported by OCCT
521       for (int aLowVer4 = 5; aLowVer4 >= 0 && aGContext == NULL; --aLowVer4)
522       {
523         aCoreCtxAttribs[1] = 4;
524         aCoreCtxAttribs[3] = aLowVer4;
525         aGContext = aCreateCtxProc (aDisp, anFBConfig, aSlaveCtx, True, aCoreCtxAttribs);
526       }
527       for (int aLowVer3 = 3; aLowVer3 >= 2 && aGContext == NULL; --aLowVer3)
528       {
529         aCoreCtxAttribs[1] = 3;
530         aCoreCtxAttribs[3] = aLowVer3;
531         aGContext = aCreateCtxProc (aDisp, anFBConfig, aSlaveCtx, True, aCoreCtxAttribs);
532       }
533       isCoreProfile = aGContext != NULL;
534     }
535
536     if (aGContext == NULL)
537     {
538       int aCtxAttribs[] =
539       {
540         GLX_CONTEXT_FLAGS_ARB, theCaps->contextDebug ? GLX_CONTEXT_DEBUG_BIT_ARB : 0,
541         0, 0
542       };
543       isCoreProfile = Standard_False;
544       aGContext = aCreateCtxProc (aDisp, anFBConfig, aSlaveCtx, True, aCtxAttribs);
545
546       if (aGContext != NULL
547       && !theCaps->contextCompatible)
548       {
549         TCollection_ExtendedString aMsg("OpenGl_Window::CreateWindow: core profile creation failed.");
550         myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
551       }
552     }
553     XSetErrorHandler(anOldHandler);
554   }
555
556   if (myOwnGContext
557    && aGContext == NULL)
558   {
559     aGContext = glXCreateContext (aDisp, aVis, aSlaveCtx, GL_TRUE);
560     if (aGContext == NULL)
561     {
562       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: glXCreateContext failed.");
563       return;
564     }
565   }
566
567   // check Visual for OpenGl context's parameters compatibility
568   TCollection_ExtendedString aList;
569   int isDoubleBuffer = 0, isRGBA = 0, isStereo = 0;
570   int aDepthSize = 0, aStencilSize = 0;
571   glXGetConfig (aDisp, aVis, GLX_RGBA,         &isRGBA);
572   glXGetConfig (aDisp, aVis, GLX_DOUBLEBUFFER, &isDoubleBuffer);
573   glXGetConfig (aDisp, aVis, GLX_STEREO,       &isStereo);
574   glXGetConfig (aDisp, aVis, GLX_DEPTH_SIZE,   &aDepthSize);
575   glXGetConfig (aDisp, aVis, GLX_STENCIL_SIZE, &aStencilSize);
576   if (aDepthSize < 1)      addMsgToList (aList, "no depth buffer");
577   if (aStencilSize < 1)    addMsgToList (aList, "no stencil buffer");
578   if (isRGBA == 0)         addMsgToList (aList, "no RGBA color buffer");
579   if (isDoubleBuffer == 0) addMsgToList (aList, "no Double Buffer");
580   if (theCaps->contextStereo && isStereo == 0)
581   {
582     addMsgToList (aList, "no Quad Buffer");
583   }
584   else if (!theCaps->contextStereo && isStereo == 1)
585   {
586     addMsgToList (aList, "extra Quad Buffer");
587   }
588   if (!aList.IsEmpty())
589   {
590     TCollection_ExtendedString aMsg = TCollection_ExtendedString ("OpenGl_Window::CreateWindow: window Visual is incomplete: ") + aList;
591     myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
592                               GL_DEBUG_TYPE_OTHER,
593                               0, GL_DEBUG_SEVERITY_MEDIUM, aMsg);
594   }
595
596   myGlContext->Init ((Aspect_Drawable )aWindow, (Aspect_Display )aDisp, (Aspect_RenderingContext )aGContext, isCoreProfile);
597 #endif
598   myGlContext->Share (theShareCtx);
599   myGlContext->SetSwapInterval (mySwapInterval);
600   Init();
601 }
602
603 // =======================================================================
604 // function : ~OpenGl_Window
605 // purpose  :
606 // =======================================================================
607 OpenGl_Window::~OpenGl_Window()
608 {
609   if (!myOwnGContext
610    ||  myGlContext.IsNull())
611   {
612     myGlContext.Nullify();
613     return;
614   }
615
616   // release "GL" context if it is owned by window
617   // Mesa implementation can fail to destroy GL context if it set for current thread.
618   // It should be safer to unset thread GL context before its destruction.
619 #if defined(HAVE_EGL) || defined(__ANDROID__) || defined(__QNX__)
620   if ((EGLSurface )myGlContext->myWindow != EGL_NO_SURFACE)
621   {
622     eglDestroySurface ((EGLDisplay )myGlContext->myDisplay,
623                        (EGLSurface )myGlContext->myWindow);
624   }
625 #elif defined(_WIN32)
626   HWND  aWindow          = (HWND  )myGlContext->myWindow;
627   HDC   aWindowDC        = (HDC   )myGlContext->myWindowDC;
628   HGLRC aWindowGContext  = (HGLRC )myGlContext->myGContext;
629   HGLRC aThreadGContext  = wglGetCurrentContext();
630   myGlContext.Nullify();
631
632   if (aThreadGContext != NULL)
633   {
634     if (aThreadGContext == aWindowGContext)
635     {
636       wglMakeCurrent (NULL, NULL);
637     }
638
639     wglDeleteContext (aWindowGContext);
640   }
641   ReleaseDC (aWindow, aWindowDC);
642 #else
643   Display*    aDisplay        = (Display*    )myGlContext->myDisplay;
644   GLXContext  aWindowGContext = (GLXContext  )myGlContext->myGContext;
645   GLXContext  aThreadGContext = glXGetCurrentContext();
646   myGlContext.Nullify();
647
648   if (aDisplay != NULL)
649   {
650     if (aThreadGContext == aWindowGContext)
651     {
652       glXMakeCurrent (aDisplay, None, NULL);
653     }
654
655     // FSXXX sync necessary if non-direct rendering
656     glXWaitGL();
657     glXDestroyContext (aDisplay, aWindowGContext);
658   }
659 #endif
660 }
661
662 #endif // !__APPLE__
663
664 // =======================================================================
665 // function : Activate
666 // purpose  :
667 // =======================================================================
668 Standard_Boolean OpenGl_Window::Activate()
669 {
670   return myGlContext->MakeCurrent();
671 }
672
673 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
674
675 // =======================================================================
676 // function : Resize
677 // purpose  : call_subr_resize
678 // =======================================================================
679 void OpenGl_Window::Resize()
680 {
681 #if !defined(_WIN32) && !defined(HAVE_EGL) && !defined(__ANDROID__) && !defined(__QNX__)
682   Display* aDisp = (Display* )myGlContext->myDisplay;
683   if (aDisp == NULL)
684     return;
685 #endif
686
687   Standard_Integer aWidth  = 0;
688   Standard_Integer aHeight = 0;
689   myPlatformWindow->Size (aWidth, aHeight);
690
691   // If the size is not changed - do nothing
692   if ((myWidth == aWidth) && (myHeight == aHeight))
693     return;
694
695   myWidth  = aWidth;
696   myHeight = aHeight;
697
698 #if !defined(_WIN32) && !defined(HAVE_EGL) && !defined(__ANDROID__) && !defined(__QNX__)
699   XResizeWindow (aDisp, myGlContext->myWindow, (unsigned int )myWidth, (unsigned int )myHeight);
700   XSync (aDisp, False);
701 #endif
702
703   Init();
704 }
705
706 // =======================================================================
707 // function : Init
708 // purpose  :
709 // =======================================================================
710 void OpenGl_Window::Init()
711 {
712   if (!Activate())
713     return;
714
715 #if defined(HAVE_EGL) || defined(__ANDROID__) || defined(__QNX__)
716   eglQuerySurface ((EGLDisplay )myGlContext->myDisplay, (EGLSurface )myGlContext->myWindow, EGL_WIDTH,  &myWidth);
717   eglQuerySurface ((EGLDisplay )myGlContext->myDisplay, (EGLSurface )myGlContext->myWindow, EGL_HEIGHT, &myHeight);
718 #elif defined(_WIN32)
719   //
720 #else
721   Window aRootWin;
722   int aDummy;
723   unsigned int aDummyU;
724   unsigned int aNewWidth  = 0;
725   unsigned int aNewHeight = 0;
726   Display* aDisp = (Display* )myGlContext->myDisplay;
727   XGetGeometry (aDisp, myGlContext->myWindow, &aRootWin, &aDummy, &aDummy, &aNewWidth, &aNewHeight, &aDummyU, &aDummyU);
728   myWidth  = aNewWidth;
729   myHeight = aNewHeight;
730 #endif
731
732   glDisable (GL_DITHER);
733   glDisable (GL_SCISSOR_TEST);
734   glViewport (0, 0, myWidth, myHeight);
735 #if !defined(GL_ES_VERSION_2_0)
736   glDrawBuffer (GL_BACK);
737   if (myGlContext->core11 != NULL)
738   {
739     glMatrixMode (GL_MODELVIEW);
740   }
741 #endif
742 }
743
744 // =======================================================================
745 // function : SetSwapInterval
746 // purpose  :
747 // =======================================================================
748 void OpenGl_Window::SetSwapInterval()
749 {
750   if (mySwapInterval != myGlContext->caps->swapInterval)
751   {
752     mySwapInterval = myGlContext->caps->swapInterval;
753     myGlContext->SetSwapInterval (mySwapInterval);
754   }
755 }
756
757 #endif // !__APPLE__