0030745: Visualization, TKOpenGl - fix initialization of GLES3 context
[occt.git] / src / Xw / Xw_Window.cxx
1 // Created on: 2013-04-06
2 // Created by: Kirill Gavrilov
3 // Copyright (c) 2013-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 <Xw_Window.hxx>
17
18 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX)) && !defined(__ANDROID__) && !defined(__QNX__)
19
20 #include <Aspect_Convert.hxx>
21 #include <Aspect_WindowDefinitionError.hxx>
22 #include <Message.hxx>
23 #include <Message_Messenger.hxx>
24
25 #if defined(HAVE_EGL) || defined(HAVE_GLES2)
26   #include <EGL/egl.h>
27   #ifndef EGL_OPENGL_ES3_BIT
28     #define EGL_OPENGL_ES3_BIT 0x00000040
29   #endif
30 #else
31   #include <GL/glx.h>
32
33 namespace
34 {
35
36   //! Search for RGBA double-buffered visual with stencil buffer.
37   static int TheDoubleBuffVisual[] =
38   {
39     GLX_RGBA,
40     GLX_DEPTH_SIZE, 16,
41     GLX_STENCIL_SIZE, 1,
42     GLX_DOUBLEBUFFER,
43     None
44   };
45
46   //! Search for RGBA double-buffered visual with stencil buffer.
47   static int TheDoubleBuffFBConfig[] =
48   {
49     GLX_X_RENDERABLE,  True,
50     GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
51     GLX_RENDER_TYPE,   GLX_RGBA_BIT,
52     GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
53     GLX_DEPTH_SIZE,    16,
54     GLX_STENCIL_SIZE,  1,
55     GLX_DOUBLEBUFFER,  True,
56     None
57   };
58
59 }
60
61 #endif
62
63 IMPLEMENT_STANDARD_RTTIEXT(Xw_Window, Aspect_Window)
64
65 // =======================================================================
66 // function : Xw_Window
67 // purpose  :
68 // =======================================================================
69 Xw_Window::Xw_Window (const Handle(Aspect_DisplayConnection)& theXDisplay,
70                       const Standard_CString theTitle,
71                       const Standard_Integer thePxLeft,
72                       const Standard_Integer thePxTop,
73                       const Standard_Integer thePxWidth,
74                       const Standard_Integer thePxHeight,
75                       const Aspect_FBConfig  theFBConfig)
76 : Aspect_Window(),
77   myDisplay  (theXDisplay),
78   myXWindow  (0),
79   myFBConfig (theFBConfig),
80   myXLeft    (thePxLeft),
81   myYTop     (thePxTop),
82   myXRight   (thePxLeft + thePxWidth),
83   myYBottom  (thePxTop + thePxHeight),
84   myIsOwnWin (Standard_True)
85 {
86   if (thePxWidth <= 0 || thePxHeight <= 0)
87   {
88     throw Aspect_WindowDefinitionError("Xw_Window, Coordinate(s) out of range");
89   }
90   else if (theXDisplay.IsNull())
91   {
92     throw Aspect_WindowDefinitionError("Xw_Window, X Display connection is undefined");
93     return;
94   }
95
96   Display* aDisp   = myDisplay->GetDisplay();
97   int      aScreen = DefaultScreen(aDisp);
98   Window   aParent = RootWindow   (aDisp, aScreen);
99   XVisualInfo* aVisInfo = NULL;
100
101 #if defined(HAVE_EGL) || defined(HAVE_GLES2)
102   EGLDisplay anEglDisplay = eglGetDisplay (aDisp);
103   EGLint aVerMajor = 0; EGLint aVerMinor = 0;
104   XVisualInfo aVisInfoTmp; memset (&aVisInfoTmp, 0, sizeof(aVisInfoTmp));
105   if (anEglDisplay != EGL_NO_DISPLAY
106    && eglInitialize (anEglDisplay, &aVerMajor, &aVerMinor) == EGL_TRUE)
107   {
108     EGLint aConfigAttribs[] =
109     {
110       EGL_RED_SIZE,     8,
111       EGL_GREEN_SIZE,   8,
112       EGL_BLUE_SIZE,    8,
113       EGL_ALPHA_SIZE,   0,
114       EGL_DEPTH_SIZE,   24,
115       EGL_STENCIL_SIZE, 8,
116     #if defined(HAVE_GLES2)
117       EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
118     #else
119       EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
120     #endif
121       EGL_NONE
122     };
123
124     EGLint aNbConfigs = 0;
125     void* anEglConfig = NULL;
126     for (Standard_Integer aGlesVer = 3; aGlesVer >= 2; --aGlesVer)
127     {
128     #if defined(GL_ES_VERSION_2_0)
129       aConfigAttribs[6 * 2 + 1] = aGlesVer == 3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT;
130     #else
131       if (aGlesVer == 2)
132       {
133         break;
134       }
135     #endif
136
137       if (eglChooseConfig (anEglDisplay, aConfigAttribs, &anEglConfig, 1, &aNbConfigs) == EGL_TRUE
138        && anEglConfig != NULL)
139       {
140         break;
141       }
142       eglGetError();
143
144       aConfigAttribs[4 * 2 + 1] = 16; // try config with smaller depth buffer
145       if (eglChooseConfig (anEglDisplay, aConfigAttribs, &anEglConfig, 1, &aNbConfigs) == EGL_TRUE
146        && anEglConfig != NULL)
147       {
148         break;
149       }
150       eglGetError();
151     }
152
153     if (anEglConfig != NULL
154      && eglGetConfigAttrib (anEglDisplay, anEglConfig, EGL_NATIVE_VISUAL_ID, (EGLint* )&aVisInfoTmp.visualid) == EGL_TRUE)
155     {
156       int aNbVisuals = 0;
157       aVisInfoTmp.screen = DefaultScreen (aDisp);
158       aVisInfo = XGetVisualInfo (aDisp, VisualIDMask | VisualScreenMask, &aVisInfoTmp, &aNbVisuals);
159     }
160   }
161   if (aVisInfo == NULL)
162   {
163     Message::DefaultMessenger()->Send ("Warning: cannot choose Visual using EGL while creating Xw_Window", Message_Warning);
164   }
165 #else
166   int aDummy = 0;
167   if (!glXQueryExtension (myDisplay->GetDisplay(), &aDummy, &aDummy))
168   {
169     throw Aspect_WindowDefinitionError("Xw_Window, GLX extension is unavailable");
170     return;
171   }
172   if (myFBConfig == NULL)
173   {
174     // FBConfigs were added in GLX version 1.3
175     int aGlxMajor = 0;
176     int aGlxMinor = 0;
177     const bool hasFBCfg = glXQueryVersion (aDisp, &aGlxMajor, &aGlxMinor)
178                        && ((aGlxMajor == 1 && aGlxMinor >= 3) || (aGlxMajor > 1));
179     if (hasFBCfg)
180     {
181       int aFBCount = 0;
182       GLXFBConfig* aFBCfgList = NULL;
183       if (hasFBCfg)
184       {
185         aFBCfgList = glXChooseFBConfig (aDisp, aScreen, TheDoubleBuffFBConfig, &aFBCount);
186       }
187       if(aFBCfgList != NULL
188       && aFBCount >= 1)
189       {
190         myFBConfig = aFBCfgList[0];
191         aVisInfo   = glXGetVisualFromFBConfig (aDisp, myFBConfig);
192       }
193       XFree (aFBCfgList);
194     }
195   }
196
197   if (aVisInfo == NULL)
198   {
199     aVisInfo = glXChooseVisual (aDisp, aScreen, TheDoubleBuffVisual);
200   }
201   if (aVisInfo == NULL)
202   {
203     throw Aspect_WindowDefinitionError("Xw_Window, couldn't find compatible Visual (RGBA, double-buffered)");
204     return;
205   }
206 #endif
207
208   unsigned long aMask = 0;
209   XSetWindowAttributes aWinAttr;
210   memset(&aWinAttr, 0, sizeof(XSetWindowAttributes));
211   aWinAttr.event_mask = ExposureMask | StructureNotifyMask;
212   aMask |= CWEventMask;
213   if (aVisInfo != NULL)
214   {
215     aWinAttr.colormap = XCreateColormap(aDisp, aParent, aVisInfo->visual, AllocNone);
216   }
217   aWinAttr.border_pixel = 0;
218   aWinAttr.override_redirect = False;
219
220   myXWindow = XCreateWindow(aDisp, aParent,
221                             myXLeft, myYTop, thePxWidth, thePxHeight,
222                             0, aVisInfo != NULL ? aVisInfo->depth : CopyFromParent,
223                             InputOutput,
224                             aVisInfo != NULL ? aVisInfo->visual : CopyFromParent,
225                             CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, &aWinAttr);
226   if (aVisInfo != NULL)
227   {
228     XFree (aVisInfo);
229     aVisInfo = NULL;
230   }
231   if (myXWindow == 0)
232   {
233     throw Aspect_WindowDefinitionError("Xw_Window, Unable to create window");
234     return;
235   }
236
237   // if parent - desktop
238   XSizeHints aSizeHints;
239   aSizeHints.x      = myXLeft;
240   aSizeHints.y      = myYTop;
241   aSizeHints.flags  = PPosition;
242   aSizeHints.width  = thePxWidth;
243   aSizeHints.height = thePxHeight;
244   aSizeHints.flags |= PSize;
245   XSetStandardProperties (aDisp, myXWindow, theTitle, theTitle, None,
246                           NULL, 0, &aSizeHints);
247
248   /*XTextProperty aTitleProperty;
249   aTitleProperty.encoding = None;
250   char* aTitle = (char* )theTitle;
251   Xutf8TextListToTextProperty(aDisp, &aTitle, 1, XUTF8StringStyle, &aTitleProperty);
252   XSetWMName      (aDisp, myXWindow, &aTitleProperty);
253   XSetWMProperties(aDisp, myXWindow, &aTitleProperty, &aTitleProperty, NULL, 0, NULL, NULL, NULL);*/
254
255   XFlush (aDisp);
256 }
257
258 // =======================================================================
259 // function : Xw_Window
260 // purpose  :
261 // =======================================================================
262 Xw_Window::Xw_Window (const Handle(Aspect_DisplayConnection)& theXDisplay,
263                       const Window theXWin,
264                       const Aspect_FBConfig theFBConfig)
265 : Aspect_Window(),
266   myDisplay  (theXDisplay),
267   myXWindow  (theXWin),
268   myFBConfig (theFBConfig),
269   myXLeft    (0),
270   myYTop     (0),
271   myXRight   (512),
272   myYBottom  (512),
273   myIsOwnWin (Standard_False)
274 {
275   if (theXWin == 0)
276   {
277     throw Aspect_WindowDefinitionError("Xw_Window, given invalid X window");
278     return;
279   }
280   else if (theXDisplay.IsNull())
281   {
282     throw Aspect_WindowDefinitionError("Xw_Window, X Display connection is undefined");
283     return;
284   }
285 #if !defined(HAVE_EGL) && !defined(HAVE_GLES2)
286   int aDummy = 0;
287   if (!glXQueryExtension (myDisplay->GetDisplay(), &aDummy, &aDummy))
288   {
289     myXWindow = 0;
290     throw Aspect_WindowDefinitionError("Xw_Window, GLX extension is unavailable");
291     return;
292   }
293 #endif
294
295   Display* aDisp = myDisplay->GetDisplay();
296
297   XWindowAttributes aWinAttr;
298   XGetWindowAttributes (aDisp, myXWindow, &aWinAttr);
299   XVisualInfo aVisInfoTmp;
300   aVisInfoTmp.visualid = aWinAttr.visual->visualid;
301   aVisInfoTmp.screen   = DefaultScreen (aDisp);
302   int aNbItems = 0;
303   XVisualInfo* aVisInfo = XGetVisualInfo (aDisp, VisualIDMask | VisualScreenMask, &aVisInfoTmp, &aNbItems);
304   if (aVisInfo == NULL)
305   {
306     throw Aspect_WindowDefinitionError("Xw_Window, Visual is unavailable");
307     return;
308   }
309   XFree (aVisInfo);
310
311   DoResize();
312 }
313
314 // =======================================================================
315 // function : ~Xw_Window
316 // purpose  :
317 // =======================================================================
318 Xw_Window::~Xw_Window()
319 {
320   if (myIsOwnWin && myXWindow != 0 && !myDisplay.IsNull())
321   {
322     XDestroyWindow (myDisplay->GetDisplay(), myXWindow);
323   }
324 }
325
326 // =======================================================================
327 // function : XWindow
328 // purpose  :
329 // =======================================================================
330 Window Xw_Window::XWindow() const
331 {
332   return myXWindow;
333 }
334
335 // =======================================================================
336 // function : IsMapped
337 // purpose  :
338 // =======================================================================
339 Standard_Boolean Xw_Window::IsMapped() const
340 {
341   if (myXWindow == 0)
342   {
343     return false;
344   }
345   else if (IsVirtual())
346   {
347     return Standard_True;
348   }
349
350   XFlush (myDisplay->GetDisplay());
351   XWindowAttributes aWinAttr;
352   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
353   return aWinAttr.map_state == IsUnviewable
354       || aWinAttr.map_state == IsViewable;
355 }
356
357 // =======================================================================
358 // function : Map
359 // purpose  :
360 // =======================================================================
361 void Xw_Window::Map() const
362 {
363   if (IsVirtual() || myXWindow == 0)
364   {
365     return;
366   }
367
368   XMapWindow (myDisplay->GetDisplay(), myXWindow);
369   XFlush (myDisplay->GetDisplay());
370 }
371
372 // =======================================================================
373 // function : Unmap
374 // purpose  :
375 // =======================================================================
376 void Xw_Window::Unmap() const
377 {
378   if (IsVirtual() || myXWindow == 0)
379   {
380     return;
381   }
382
383   XIconifyWindow (myDisplay->GetDisplay(), myXWindow, DefaultScreen(myDisplay->GetDisplay()));
384 }
385
386 // =======================================================================
387 // function : DoResize
388 // purpose  :
389 // =======================================================================
390 Aspect_TypeOfResize Xw_Window::DoResize() const
391 {
392   if (myXWindow == 0)
393   {
394     return Aspect_TOR_UNKNOWN;
395   }
396
397   XFlush (myDisplay->GetDisplay());
398   XWindowAttributes aWinAttr;
399   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
400   if (aWinAttr.map_state == IsUnmapped)
401   {
402     return Aspect_TOR_UNKNOWN;
403   }
404
405   Standard_Integer aMask = 0;
406   Aspect_TypeOfResize aMode = Aspect_TOR_UNKNOWN;
407
408   if (Abs (aWinAttr.x                     - myXLeft  ) > 2) aMask |= 1;
409   if (Abs ((aWinAttr.x + aWinAttr.width)  - myXRight ) > 2) aMask |= 2;
410   if (Abs (aWinAttr.y                     - myYTop   ) > 2) aMask |= 4;
411   if (Abs ((aWinAttr.y + aWinAttr.height) - myYBottom) > 2) aMask |= 8;
412   switch (aMask)
413   {
414     case 0:  aMode = Aspect_TOR_NO_BORDER;               break;
415     case 1:  aMode = Aspect_TOR_LEFT_BORDER;             break;
416     case 2:  aMode = Aspect_TOR_RIGHT_BORDER;            break;
417     case 4:  aMode = Aspect_TOR_TOP_BORDER;              break;
418     case 5:  aMode = Aspect_TOR_LEFT_AND_TOP_BORDER;     break;
419     case 6:  aMode = Aspect_TOR_TOP_AND_RIGHT_BORDER;    break;
420     case 8:  aMode = Aspect_TOR_BOTTOM_BORDER;           break;
421     case 9:  aMode = Aspect_TOR_BOTTOM_AND_LEFT_BORDER;  break;
422     case 10: aMode = Aspect_TOR_RIGHT_AND_BOTTOM_BORDER; break;
423     default: break;
424   }
425
426   *((Standard_Integer* )&myXLeft   ) = aWinAttr.x;
427   *((Standard_Integer* )&myXRight  ) = aWinAttr.x + aWinAttr.width;
428   *((Standard_Integer* )&myYTop    ) = aWinAttr.y;
429   *((Standard_Integer* )&myYBottom ) = aWinAttr.y + aWinAttr.height;
430   return aMode;
431 }
432
433 // =======================================================================
434 // function : DoMapping
435 // purpose  :
436 // =======================================================================
437 Standard_Boolean Xw_Window::DoMapping() const
438 {
439   return Standard_True; // IsMapped()
440 }
441
442 // =======================================================================
443 // function : Ratio
444 // purpose  :
445 // =======================================================================
446 Standard_Real Xw_Window::Ratio() const
447 {
448   if (myXWindow == 0)
449   {
450     return 1.0;
451   }
452
453   XFlush (myDisplay->GetDisplay());
454   XWindowAttributes aWinAttr;
455   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
456   return Standard_Real(aWinAttr.width) / Standard_Real(aWinAttr.height);
457 }
458
459 // =======================================================================
460 // function : Position
461 // purpose  :
462 // =======================================================================
463 void Xw_Window::Position (Standard_Integer& X1, Standard_Integer& Y1,
464                           Standard_Integer& X2, Standard_Integer& Y2) const
465 {
466   if (myXWindow == 0)
467   {
468     return;
469   }
470
471   XFlush (myDisplay->GetDisplay());
472   XWindowAttributes anAttributes;
473   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &anAttributes);
474   Window aChild;
475   XTranslateCoordinates (myDisplay->GetDisplay(), anAttributes.root, myXWindow,
476                          0, 0, &anAttributes.x, &anAttributes.y, &aChild);
477
478   X1 = -anAttributes.x;
479   X2 = X1 + anAttributes.width;
480   Y1 = -anAttributes.y;
481   Y2 = Y1 + anAttributes.height;
482 }
483
484 // =======================================================================
485 // function : Size
486 // purpose  :
487 // =======================================================================
488 void Xw_Window::Size (Standard_Integer& theWidth,
489                       Standard_Integer& theHeight) const
490 {
491   if (myXWindow == 0)
492   {
493     return;
494   }
495
496   XFlush (myDisplay->GetDisplay());
497   XWindowAttributes aWinAttr;
498   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
499   theWidth  = aWinAttr.width;
500   theHeight = aWinAttr.height;
501 }
502
503 // =======================================================================
504 // function : InvalidateContent
505 // purpose  :
506 // =======================================================================
507 void Xw_Window::InvalidateContent (const Handle(Aspect_DisplayConnection)& theDisp)
508 {
509   if (myXWindow == 0)
510   {
511     return;
512   }
513
514   const Handle(Aspect_DisplayConnection)& aDisp = !theDisp.IsNull() ? theDisp : myDisplay;
515   Display* aDispX = aDisp->GetDisplay();
516
517   XEvent anEvent;
518   memset (&anEvent, 0, sizeof(anEvent));
519   anEvent.type = Expose;
520   anEvent.xexpose.window = myXWindow;
521   XSendEvent (aDispX, myXWindow, False, ExposureMask, &anEvent);
522   XFlush (aDispX);
523 }
524
525 #endif //  Win32 or Mac OS X