0030507: Visualization - introduce AIS_ViewController
[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 //#include <X11/XF86keysym.h>
26
27 #if defined(HAVE_EGL) || defined(HAVE_GLES2)
28   #include <EGL/egl.h>
29   #ifndef EGL_OPENGL_ES3_BIT
30     #define EGL_OPENGL_ES3_BIT 0x00000040
31   #endif
32 #else
33   #include <GL/glx.h>
34
35 namespace
36 {
37
38   //! Search for RGBA double-buffered visual with stencil buffer.
39   static int TheDoubleBuffVisual[] =
40   {
41     GLX_RGBA,
42     GLX_DEPTH_SIZE, 16,
43     GLX_STENCIL_SIZE, 1,
44     GLX_DOUBLEBUFFER,
45     None
46   };
47
48   //! Search for RGBA double-buffered visual with stencil buffer.
49   static int TheDoubleBuffFBConfig[] =
50   {
51     GLX_X_RENDERABLE,  True,
52     GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
53     GLX_RENDER_TYPE,   GLX_RGBA_BIT,
54     GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
55     GLX_DEPTH_SIZE,    16,
56     GLX_STENCIL_SIZE,  1,
57     GLX_DOUBLEBUFFER,  True,
58     None
59   };
60
61 }
62
63 #endif
64
65 IMPLEMENT_STANDARD_RTTIEXT(Xw_Window, Aspect_Window)
66
67 // =======================================================================
68 // function : Xw_Window
69 // purpose  :
70 // =======================================================================
71 Xw_Window::Xw_Window (const Handle(Aspect_DisplayConnection)& theXDisplay,
72                       const Standard_CString theTitle,
73                       const Standard_Integer thePxLeft,
74                       const Standard_Integer thePxTop,
75                       const Standard_Integer thePxWidth,
76                       const Standard_Integer thePxHeight,
77                       const Aspect_FBConfig  theFBConfig)
78 : Aspect_Window(),
79   myDisplay  (theXDisplay),
80   myXWindow  (0),
81   myFBConfig (theFBConfig),
82   myXLeft    (thePxLeft),
83   myYTop     (thePxTop),
84   myXRight   (thePxLeft + thePxWidth),
85   myYBottom  (thePxTop + thePxHeight),
86   myIsOwnWin (Standard_True)
87 {
88   if (thePxWidth <= 0 || thePxHeight <= 0)
89   {
90     throw Aspect_WindowDefinitionError("Xw_Window, Coordinate(s) out of range");
91   }
92   else if (theXDisplay.IsNull())
93   {
94     throw Aspect_WindowDefinitionError("Xw_Window, X Display connection is undefined");
95     return;
96   }
97
98   Display* aDisp   = myDisplay->GetDisplay();
99   int      aScreen = DefaultScreen(aDisp);
100   Window   aParent = RootWindow   (aDisp, aScreen);
101   XVisualInfo* aVisInfo = NULL;
102
103 #if defined(HAVE_EGL) || defined(HAVE_GLES2)
104   EGLDisplay anEglDisplay = eglGetDisplay (aDisp);
105   EGLint aVerMajor = 0; EGLint aVerMinor = 0;
106   XVisualInfo aVisInfoTmp; memset (&aVisInfoTmp, 0, sizeof(aVisInfoTmp));
107   if (anEglDisplay != EGL_NO_DISPLAY
108    && eglInitialize (anEglDisplay, &aVerMajor, &aVerMinor) == EGL_TRUE)
109   {
110     EGLint aConfigAttribs[] =
111     {
112       EGL_RED_SIZE,     8,
113       EGL_GREEN_SIZE,   8,
114       EGL_BLUE_SIZE,    8,
115       EGL_ALPHA_SIZE,   0,
116       EGL_DEPTH_SIZE,   24,
117       EGL_STENCIL_SIZE, 8,
118     #if defined(HAVE_GLES2)
119       EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
120     #else
121       EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
122     #endif
123       EGL_NONE
124     };
125
126     EGLint aNbConfigs = 0;
127     void* anEglConfig = NULL;
128     for (Standard_Integer aGlesVer = 3; aGlesVer >= 2; --aGlesVer)
129     {
130     #if defined(GL_ES_VERSION_2_0)
131       aConfigAttribs[6 * 2 + 1] = aGlesVer == 3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT;
132     #else
133       if (aGlesVer == 2)
134       {
135         break;
136       }
137     #endif
138
139       if (eglChooseConfig (anEglDisplay, aConfigAttribs, &anEglConfig, 1, &aNbConfigs) == EGL_TRUE
140        && anEglConfig != NULL)
141       {
142         break;
143       }
144       eglGetError();
145
146       aConfigAttribs[4 * 2 + 1] = 16; // try config with smaller depth buffer
147       if (eglChooseConfig (anEglDisplay, aConfigAttribs, &anEglConfig, 1, &aNbConfigs) == EGL_TRUE
148        && anEglConfig != NULL)
149       {
150         break;
151       }
152       eglGetError();
153     }
154
155     if (anEglConfig != NULL
156      && eglGetConfigAttrib (anEglDisplay, anEglConfig, EGL_NATIVE_VISUAL_ID, (EGLint* )&aVisInfoTmp.visualid) == EGL_TRUE)
157     {
158       int aNbVisuals = 0;
159       aVisInfoTmp.screen = DefaultScreen (aDisp);
160       aVisInfo = XGetVisualInfo (aDisp, VisualIDMask | VisualScreenMask, &aVisInfoTmp, &aNbVisuals);
161     }
162   }
163   if (aVisInfo == NULL)
164   {
165     Message::DefaultMessenger()->Send ("Warning: cannot choose Visual using EGL while creating Xw_Window", Message_Warning);
166   }
167 #else
168   int aDummy = 0;
169   if (!glXQueryExtension (myDisplay->GetDisplay(), &aDummy, &aDummy))
170   {
171     throw Aspect_WindowDefinitionError("Xw_Window, GLX extension is unavailable");
172     return;
173   }
174   if (myFBConfig == NULL)
175   {
176     // FBConfigs were added in GLX version 1.3
177     int aGlxMajor = 0;
178     int aGlxMinor = 0;
179     const bool hasFBCfg = glXQueryVersion (aDisp, &aGlxMajor, &aGlxMinor)
180                        && ((aGlxMajor == 1 && aGlxMinor >= 3) || (aGlxMajor > 1));
181     if (hasFBCfg)
182     {
183       int aFBCount = 0;
184       GLXFBConfig* aFBCfgList = NULL;
185       if (hasFBCfg)
186       {
187         aFBCfgList = glXChooseFBConfig (aDisp, aScreen, TheDoubleBuffFBConfig, &aFBCount);
188       }
189       if(aFBCfgList != NULL
190       && aFBCount >= 1)
191       {
192         myFBConfig = aFBCfgList[0];
193         aVisInfo   = glXGetVisualFromFBConfig (aDisp, myFBConfig);
194       }
195       XFree (aFBCfgList);
196     }
197   }
198
199   if (aVisInfo == NULL)
200   {
201     aVisInfo = glXChooseVisual (aDisp, aScreen, TheDoubleBuffVisual);
202   }
203   if (aVisInfo == NULL)
204   {
205     throw Aspect_WindowDefinitionError("Xw_Window, couldn't find compatible Visual (RGBA, double-buffered)");
206     return;
207   }
208 #endif
209
210   unsigned long aMask = 0;
211   XSetWindowAttributes aWinAttr;
212   memset(&aWinAttr, 0, sizeof(XSetWindowAttributes));
213   aWinAttr.event_mask = ExposureMask | StructureNotifyMask;
214   aMask |= CWEventMask;
215   if (aVisInfo != NULL)
216   {
217     aWinAttr.colormap = XCreateColormap(aDisp, aParent, aVisInfo->visual, AllocNone);
218   }
219   aWinAttr.border_pixel = 0;
220   aWinAttr.override_redirect = False;
221
222   myXWindow = XCreateWindow(aDisp, aParent,
223                             myXLeft, myYTop, thePxWidth, thePxHeight,
224                             0, aVisInfo != NULL ? aVisInfo->depth : CopyFromParent,
225                             InputOutput,
226                             aVisInfo != NULL ? aVisInfo->visual : CopyFromParent,
227                             CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, &aWinAttr);
228   if (aVisInfo != NULL)
229   {
230     XFree (aVisInfo);
231     aVisInfo = NULL;
232   }
233   if (myXWindow == 0)
234   {
235     throw Aspect_WindowDefinitionError("Xw_Window, Unable to create window");
236     return;
237   }
238
239   // if parent - desktop
240   XSizeHints aSizeHints;
241   aSizeHints.x      = myXLeft;
242   aSizeHints.y      = myYTop;
243   aSizeHints.flags  = PPosition;
244   aSizeHints.width  = thePxWidth;
245   aSizeHints.height = thePxHeight;
246   aSizeHints.flags |= PSize;
247   XSetStandardProperties (aDisp, myXWindow, theTitle, theTitle, None,
248                           NULL, 0, &aSizeHints);
249
250   /*XTextProperty aTitleProperty;
251   aTitleProperty.encoding = None;
252   char* aTitle = (char* )theTitle;
253   Xutf8TextListToTextProperty(aDisp, &aTitle, 1, XUTF8StringStyle, &aTitleProperty);
254   XSetWMName      (aDisp, myXWindow, &aTitleProperty);
255   XSetWMProperties(aDisp, myXWindow, &aTitleProperty, &aTitleProperty, NULL, 0, NULL, NULL, NULL);*/
256
257   XFlush (aDisp);
258 }
259
260 // =======================================================================
261 // function : Xw_Window
262 // purpose  :
263 // =======================================================================
264 Xw_Window::Xw_Window (const Handle(Aspect_DisplayConnection)& theXDisplay,
265                       const Window theXWin,
266                       const Aspect_FBConfig theFBConfig)
267 : Aspect_Window(),
268   myDisplay  (theXDisplay),
269   myXWindow  (theXWin),
270   myFBConfig (theFBConfig),
271   myXLeft    (0),
272   myYTop     (0),
273   myXRight   (512),
274   myYBottom  (512),
275   myIsOwnWin (Standard_False)
276 {
277   if (theXWin == 0)
278   {
279     throw Aspect_WindowDefinitionError("Xw_Window, given invalid X window");
280     return;
281   }
282   else if (theXDisplay.IsNull())
283   {
284     throw Aspect_WindowDefinitionError("Xw_Window, X Display connection is undefined");
285     return;
286   }
287 #if !defined(HAVE_EGL) && !defined(HAVE_GLES2)
288   int aDummy = 0;
289   if (!glXQueryExtension (myDisplay->GetDisplay(), &aDummy, &aDummy))
290   {
291     myXWindow = 0;
292     throw Aspect_WindowDefinitionError("Xw_Window, GLX extension is unavailable");
293     return;
294   }
295 #endif
296
297   Display* aDisp = myDisplay->GetDisplay();
298
299   XWindowAttributes aWinAttr;
300   XGetWindowAttributes (aDisp, myXWindow, &aWinAttr);
301   XVisualInfo aVisInfoTmp;
302   aVisInfoTmp.visualid = aWinAttr.visual->visualid;
303   aVisInfoTmp.screen   = DefaultScreen (aDisp);
304   int aNbItems = 0;
305   XVisualInfo* aVisInfo = XGetVisualInfo (aDisp, VisualIDMask | VisualScreenMask, &aVisInfoTmp, &aNbItems);
306   if (aVisInfo == NULL)
307   {
308     throw Aspect_WindowDefinitionError("Xw_Window, Visual is unavailable");
309     return;
310   }
311   XFree (aVisInfo);
312
313   DoResize();
314 }
315
316 // =======================================================================
317 // function : ~Xw_Window
318 // purpose  :
319 // =======================================================================
320 Xw_Window::~Xw_Window()
321 {
322   if (myIsOwnWin && myXWindow != 0 && !myDisplay.IsNull())
323   {
324     XDestroyWindow (myDisplay->GetDisplay(), myXWindow);
325   }
326 }
327
328 // =======================================================================
329 // function : XWindow
330 // purpose  :
331 // =======================================================================
332 Window Xw_Window::XWindow() const
333 {
334   return myXWindow;
335 }
336
337 // =======================================================================
338 // function : IsMapped
339 // purpose  :
340 // =======================================================================
341 Standard_Boolean Xw_Window::IsMapped() const
342 {
343   if (myXWindow == 0)
344   {
345     return false;
346   }
347   else if (IsVirtual())
348   {
349     return Standard_True;
350   }
351
352   XFlush (myDisplay->GetDisplay());
353   XWindowAttributes aWinAttr;
354   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
355   return aWinAttr.map_state == IsUnviewable
356       || aWinAttr.map_state == IsViewable;
357 }
358
359 // =======================================================================
360 // function : Map
361 // purpose  :
362 // =======================================================================
363 void Xw_Window::Map() const
364 {
365   if (IsVirtual() || myXWindow == 0)
366   {
367     return;
368   }
369
370   XMapWindow (myDisplay->GetDisplay(), myXWindow);
371   XFlush (myDisplay->GetDisplay());
372 }
373
374 // =======================================================================
375 // function : Unmap
376 // purpose  :
377 // =======================================================================
378 void Xw_Window::Unmap() const
379 {
380   if (IsVirtual() || myXWindow == 0)
381   {
382     return;
383   }
384
385   XIconifyWindow (myDisplay->GetDisplay(), myXWindow, DefaultScreen(myDisplay->GetDisplay()));
386 }
387
388 // =======================================================================
389 // function : DoResize
390 // purpose  :
391 // =======================================================================
392 Aspect_TypeOfResize Xw_Window::DoResize() const
393 {
394   if (myXWindow == 0)
395   {
396     return Aspect_TOR_UNKNOWN;
397   }
398
399   XFlush (myDisplay->GetDisplay());
400   XWindowAttributes aWinAttr;
401   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
402   if (aWinAttr.map_state == IsUnmapped)
403   {
404     return Aspect_TOR_UNKNOWN;
405   }
406
407   Standard_Integer aMask = 0;
408   Aspect_TypeOfResize aMode = Aspect_TOR_UNKNOWN;
409
410   if (Abs (aWinAttr.x                     - myXLeft  ) > 2) aMask |= 1;
411   if (Abs ((aWinAttr.x + aWinAttr.width)  - myXRight ) > 2) aMask |= 2;
412   if (Abs (aWinAttr.y                     - myYTop   ) > 2) aMask |= 4;
413   if (Abs ((aWinAttr.y + aWinAttr.height) - myYBottom) > 2) aMask |= 8;
414   switch (aMask)
415   {
416     case 0:  aMode = Aspect_TOR_NO_BORDER;               break;
417     case 1:  aMode = Aspect_TOR_LEFT_BORDER;             break;
418     case 2:  aMode = Aspect_TOR_RIGHT_BORDER;            break;
419     case 4:  aMode = Aspect_TOR_TOP_BORDER;              break;
420     case 5:  aMode = Aspect_TOR_LEFT_AND_TOP_BORDER;     break;
421     case 6:  aMode = Aspect_TOR_TOP_AND_RIGHT_BORDER;    break;
422     case 8:  aMode = Aspect_TOR_BOTTOM_BORDER;           break;
423     case 9:  aMode = Aspect_TOR_BOTTOM_AND_LEFT_BORDER;  break;
424     case 10: aMode = Aspect_TOR_RIGHT_AND_BOTTOM_BORDER; break;
425     default: break;
426   }
427
428   *((Standard_Integer* )&myXLeft   ) = aWinAttr.x;
429   *((Standard_Integer* )&myXRight  ) = aWinAttr.x + aWinAttr.width;
430   *((Standard_Integer* )&myYTop    ) = aWinAttr.y;
431   *((Standard_Integer* )&myYBottom ) = aWinAttr.y + aWinAttr.height;
432   return aMode;
433 }
434
435 // =======================================================================
436 // function : DoMapping
437 // purpose  :
438 // =======================================================================
439 Standard_Boolean Xw_Window::DoMapping() const
440 {
441   return Standard_True; // IsMapped()
442 }
443
444 // =======================================================================
445 // function : Ratio
446 // purpose  :
447 // =======================================================================
448 Standard_Real Xw_Window::Ratio() const
449 {
450   if (myXWindow == 0)
451   {
452     return 1.0;
453   }
454
455   XFlush (myDisplay->GetDisplay());
456   XWindowAttributes aWinAttr;
457   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
458   return Standard_Real(aWinAttr.width) / Standard_Real(aWinAttr.height);
459 }
460
461 // =======================================================================
462 // function : Position
463 // purpose  :
464 // =======================================================================
465 void Xw_Window::Position (Standard_Integer& X1, Standard_Integer& Y1,
466                           Standard_Integer& X2, Standard_Integer& Y2) const
467 {
468   if (myXWindow == 0)
469   {
470     return;
471   }
472
473   XFlush (myDisplay->GetDisplay());
474   XWindowAttributes anAttributes;
475   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &anAttributes);
476   Window aChild;
477   XTranslateCoordinates (myDisplay->GetDisplay(), anAttributes.root, myXWindow,
478                          0, 0, &anAttributes.x, &anAttributes.y, &aChild);
479
480   X1 = -anAttributes.x;
481   X2 = X1 + anAttributes.width;
482   Y1 = -anAttributes.y;
483   Y2 = Y1 + anAttributes.height;
484 }
485
486 // =======================================================================
487 // function : Size
488 // purpose  :
489 // =======================================================================
490 void Xw_Window::Size (Standard_Integer& theWidth,
491                       Standard_Integer& theHeight) const
492 {
493   if (myXWindow == 0)
494   {
495     return;
496   }
497
498   XFlush (myDisplay->GetDisplay());
499   XWindowAttributes aWinAttr;
500   XGetWindowAttributes (myDisplay->GetDisplay(), myXWindow, &aWinAttr);
501   theWidth  = aWinAttr.width;
502   theHeight = aWinAttr.height;
503 }
504
505 // =======================================================================
506 // function : SetTitle
507 // purpose  :
508 // =======================================================================
509 void Xw_Window::SetTitle (const TCollection_AsciiString& theTitle)
510 {
511   if (myXWindow != 0)
512   {
513     XStoreName (myDisplay->GetDisplay(), myXWindow, theTitle.ToCString());
514   }
515 }
516
517 // =======================================================================
518 // function : InvalidateContent
519 // purpose  :
520 // =======================================================================
521 void Xw_Window::InvalidateContent (const Handle(Aspect_DisplayConnection)& theDisp)
522 {
523   if (myXWindow == 0)
524   {
525     return;
526   }
527
528   const Handle(Aspect_DisplayConnection)& aDisp = !theDisp.IsNull() ? theDisp : myDisplay;
529   Display* aDispX = aDisp->GetDisplay();
530
531   XEvent anEvent;
532   memset (&anEvent, 0, sizeof(anEvent));
533   anEvent.type = Expose;
534   anEvent.xexpose.window = myXWindow;
535   XSendEvent (aDispX, myXWindow, False, ExposureMask, &anEvent);
536   XFlush (aDispX);
537 }
538
539 // =======================================================================
540 // function : VirtualKeyFromNative
541 // purpose  :
542 // =======================================================================
543 Aspect_VKey Xw_Window::VirtualKeyFromNative (unsigned long theKey)
544 {
545   if (theKey >= XK_0
546    && theKey <= XK_9)
547   {
548     return Aspect_VKey(theKey - XK_0 + Aspect_VKey_0);
549   }
550
551   if (theKey >= XK_A
552    && theKey <= XK_Z)
553   {
554     return Aspect_VKey(theKey - XK_A + Aspect_VKey_A);
555   }
556
557   if (theKey >= XK_a
558    && theKey <= XK_z)
559   {
560     return Aspect_VKey(theKey - XK_a + Aspect_VKey_A);
561   }
562
563   if (theKey >= XK_F1
564    && theKey <= XK_F24)
565   {
566     if (theKey <= XK_F12)
567     {
568       return Aspect_VKey(theKey - XK_F1 + Aspect_VKey_F1);
569     }
570     return Aspect_VKey_UNKNOWN;
571   }
572
573   switch (theKey)
574   {
575     case XK_space:
576       return Aspect_VKey_Space;
577     case XK_apostrophe:
578       return Aspect_VKey_Apostrophe;
579     case XK_comma:
580       return Aspect_VKey_Comma;
581     case XK_minus:
582       return Aspect_VKey_Minus;
583     case XK_period:
584       return Aspect_VKey_Period;
585     case XK_semicolon:
586       return Aspect_VKey_Semicolon;
587     case XK_equal:
588       return Aspect_VKey_Equal;
589     case XK_bracketleft:
590       return Aspect_VKey_BracketLeft;
591     case XK_backslash:
592       return Aspect_VKey_Backslash;
593     case XK_bracketright:
594       return Aspect_VKey_BracketRight;
595     case XK_BackSpace:
596       return Aspect_VKey_Backspace;
597     case XK_Tab:
598       return Aspect_VKey_Tab;
599     //case XK_Linefeed:
600     case XK_Return:
601     case XK_KP_Enter:
602       return Aspect_VKey_Enter;
603     //case XK_Pause:
604     //  return Aspect_VKey_Pause;
605     case XK_Escape:
606       return Aspect_VKey_Escape;
607     case XK_Home:
608       return Aspect_VKey_Home;
609     case XK_Left:
610       return Aspect_VKey_Left;
611     case XK_Up:
612       return Aspect_VKey_Up;
613     case XK_Right:
614       return Aspect_VKey_Right;
615     case XK_Down:
616       return Aspect_VKey_Down;
617     case XK_Prior:
618       return Aspect_VKey_PageUp;
619     case XK_Next:
620       return Aspect_VKey_PageDown;
621     case XK_End:
622       return Aspect_VKey_End;
623     //case XK_Insert:
624     //  return Aspect_VKey_Insert;
625     case XK_Menu:
626       return Aspect_VKey_Menu;
627     case XK_Num_Lock:
628       return Aspect_VKey_Numlock;
629     //case XK_KP_Delete:
630     //  return Aspect_VKey_NumDelete;
631     case XK_KP_Multiply:
632       return Aspect_VKey_NumpadMultiply;
633     case XK_KP_Add:
634       return Aspect_VKey_NumpadAdd;
635     //case XK_KP_Separator:
636     //  return Aspect_VKey_Separator;
637     case XK_KP_Subtract:
638       return Aspect_VKey_NumpadSubtract;
639     //case XK_KP_Decimal:
640     //  return Aspect_VKey_Decimal;
641     case XK_KP_Divide:
642       return Aspect_VKey_NumpadDivide;
643     case XK_Shift_L:
644     case XK_Shift_R:
645       return Aspect_VKey_Shift;
646     case XK_Control_L:
647     case XK_Control_R:
648       return Aspect_VKey_Control;
649     //case XK_Caps_Lock:
650     //  return Aspect_VKey_CapsLock;
651     case XK_Alt_L:
652     case XK_Alt_R:
653       return Aspect_VKey_Alt;
654     //case XK_Super_L:
655     //case XK_Super_R:
656     //  return Aspect_VKey_Super;
657     case XK_Delete:
658       return Aspect_VKey_Delete;
659
660     case 0x1008FF11: // XF86AudioLowerVolume
661       return Aspect_VKey_VolumeDown;
662     case 0x1008FF12: // XF86AudioMute
663       return Aspect_VKey_VolumeMute;
664     case 0x1008FF13: // XF86AudioRaiseVolume
665       return Aspect_VKey_VolumeUp;
666
667     case 0x1008FF14: // XF86AudioPlay
668       return Aspect_VKey_MediaPlayPause;
669     case 0x1008FF15: // XF86AudioStop
670       return Aspect_VKey_MediaStop;
671     case 0x1008FF16: // XF86AudioPrev
672       return Aspect_VKey_MediaPreviousTrack;
673     case 0x1008FF17: // XF86AudioNext
674       return Aspect_VKey_MediaNextTrack;
675
676     case 0x1008FF18: // XF86HomePage
677       return Aspect_VKey_BrowserHome;
678     case 0x1008FF26: // XF86Back
679       return Aspect_VKey_BrowserBack;
680     case 0x1008FF27: // XF86Forward
681       return Aspect_VKey_BrowserForward;
682     case 0x1008FF28: // XF86Stop
683       return Aspect_VKey_BrowserStop;
684     case 0x1008FF29: // XF86Refresh
685       return Aspect_VKey_BrowserRefresh;
686   }
687   return Aspect_VKey_UNKNOWN;
688 }
689
690 #endif //  Win32 or Mac OS X