0032323: Configuration - drop unused dependency from Xmu
[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 #include <Aspect_Convert.hxx>
19 #include <Aspect_ScrollDelta.hxx>
20 #include <Aspect_WindowDefinitionError.hxx>
21 #include <Aspect_WindowInputListener.hxx>
22 #include <Message.hxx>
23 #include <Message_Messenger.hxx>
24 #include <Standard_NotImplemented.hxx>
25
26 #if defined(HAVE_XLIB)
27   #include <X11/Xlib.h>
28   #include <X11/Xutil.h>
29   //#include <X11/XF86keysym.h>
30 #endif
31
32 #include <Aspect_DisplayConnection.hxx>
33
34 IMPLEMENT_STANDARD_RTTIEXT(Xw_Window, Aspect_Window)
35
36 // =======================================================================
37 // function : Xw_Window
38 // purpose  :
39 // =======================================================================
40 Xw_Window::Xw_Window (const Handle(Aspect_DisplayConnection)& theXDisplay,
41                       const Standard_CString theTitle,
42                       const Standard_Integer thePxLeft,
43                       const Standard_Integer thePxTop,
44                       const Standard_Integer thePxWidth,
45                       const Standard_Integer thePxHeight)
46 : Aspect_Window(),
47   myDisplay  (theXDisplay),
48   myXWindow  (0),
49   myFBConfig (NULL),
50   myXLeft    (thePxLeft),
51   myYTop     (thePxTop),
52   myXRight   (thePxLeft + thePxWidth),
53   myYBottom  (thePxTop + thePxHeight),
54   myIsOwnWin (Standard_True)
55 {
56   if (thePxWidth <= 0 || thePxHeight <= 0)
57   {
58     throw Aspect_WindowDefinitionError("Xw_Window, Coordinate(s) out of range");
59   }
60   else if (theXDisplay.IsNull())
61   {
62     throw Aspect_WindowDefinitionError("Xw_Window, X Display connection is undefined");
63   }
64
65 #if defined(HAVE_XLIB)
66   myFBConfig = theXDisplay->GetDefaultFBConfig();
67   XVisualInfo* aVisInfo = theXDisplay->GetDefaultVisualInfoX();
68
69   Display* aDisp   = myDisplay->GetDisplay();
70   int      aScreen = DefaultScreen(aDisp);
71   Window   aParent = RootWindow   (aDisp, aScreen);
72
73   unsigned long aMask = 0;
74   XSetWindowAttributes aWinAttr;
75   memset (&aWinAttr, 0, sizeof(aWinAttr));
76   aWinAttr.event_mask = ExposureMask | StructureNotifyMask;
77   aMask |= CWEventMask;
78   if (aVisInfo != NULL)
79   {
80     aWinAttr.colormap = XCreateColormap(aDisp, aParent, aVisInfo->visual, AllocNone);
81   }
82   aWinAttr.border_pixel = 0;
83   aWinAttr.override_redirect = False;
84
85   myXWindow = (Window )XCreateWindow (aDisp, aParent,
86                             myXLeft, myYTop, thePxWidth, thePxHeight,
87                             0, aVisInfo != NULL ? aVisInfo->depth : CopyFromParent,
88                             InputOutput,
89                             aVisInfo != NULL ? aVisInfo->visual : CopyFromParent,
90                             CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, &aWinAttr);
91   if (myXWindow == 0)
92   {
93     throw Aspect_WindowDefinitionError("Xw_Window, Unable to create window");
94   }
95
96   // if parent - desktop
97   XSizeHints aSizeHints;
98   aSizeHints.x      = myXLeft;
99   aSizeHints.y      = myYTop;
100   aSizeHints.flags  = PPosition;
101   aSizeHints.width  = thePxWidth;
102   aSizeHints.height = thePxHeight;
103   aSizeHints.flags |= PSize;
104   XSetStandardProperties (aDisp, (Window )myXWindow, theTitle, theTitle, None,
105                           NULL, 0, &aSizeHints);
106
107   /*XTextProperty aTitleProperty;
108   aTitleProperty.encoding = None;
109   char* aTitle = (char* )theTitle;
110   Xutf8TextListToTextProperty(aDisp, &aTitle, 1, XUTF8StringStyle, &aTitleProperty);
111   XSetWMName      (aDisp, (Window )myXWindow, &aTitleProperty);
112   XSetWMProperties(aDisp, (Window )myXWindow, &aTitleProperty, &aTitleProperty, NULL, 0, NULL, NULL, NULL);*/
113
114   XFlush (aDisp);
115 #else
116   (void )theTitle;
117   if (myXWindow == 0)
118   {
119     throw Aspect_WindowDefinitionError ("Xw_Window, Unable to create window - not implemented");
120   }
121 #endif
122 }
123
124 // =======================================================================
125 // function : Xw_Window
126 // purpose  :
127 // =======================================================================
128 Xw_Window::Xw_Window (const Handle(Aspect_DisplayConnection)& theXDisplay,
129                       const Aspect_Drawable theXWin,
130                       const Aspect_FBConfig theFBConfig)
131 : Aspect_Window(),
132   myDisplay  (theXDisplay),
133   myXWindow  (theXWin),
134   myFBConfig (theFBConfig),
135   myXLeft    (0),
136   myYTop     (0),
137   myXRight   (512),
138   myYBottom  (512),
139   myIsOwnWin (Standard_False)
140 {
141   if (theXWin == 0)
142   {
143     throw Aspect_WindowDefinitionError("Xw_Window, given invalid X window");
144   }
145   else if (theXDisplay.IsNull())
146   {
147     throw Aspect_WindowDefinitionError("Xw_Window, X Display connection is undefined");
148   }
149
150 #if defined(HAVE_XLIB)
151   Display* aDisp = myDisplay->GetDisplay();
152
153   XWindowAttributes aWinAttr;
154   XGetWindowAttributes (aDisp, (Window )myXWindow, &aWinAttr);
155   XVisualInfo aVisInfoTmp;
156   aVisInfoTmp.visualid = aWinAttr.visual->visualid;
157   aVisInfoTmp.screen   = DefaultScreen (aDisp);
158   int aNbItems = 0;
159   XVisualInfo* aVisInfo = XGetVisualInfo (aDisp, VisualIDMask | VisualScreenMask, &aVisInfoTmp, &aNbItems);
160   if (aVisInfo == NULL)
161   {
162     throw Aspect_WindowDefinitionError("Xw_Window, Visual is unavailable");
163   }
164   XFree (aVisInfo);
165
166   DoResize();
167 #else
168   //throw Standard_NotImplemented("Xw_Window, not implemented");
169 #endif
170 }
171
172 // =======================================================================
173 // function : ~Xw_Window
174 // purpose  :
175 // =======================================================================
176 Xw_Window::~Xw_Window()
177 {
178   if (myIsOwnWin && myXWindow != 0 && !myDisplay.IsNull())
179   {
180   #if defined(HAVE_XLIB)
181     XDestroyWindow (myDisplay->GetDisplay(), (Window )myXWindow);
182   #endif
183   }
184 }
185
186 // =======================================================================
187 // function : IsMapped
188 // purpose  :
189 // =======================================================================
190 Standard_Boolean Xw_Window::IsMapped() const
191 {
192   if (myXWindow == 0)
193   {
194     return false;
195   }
196   else if (IsVirtual())
197   {
198     return Standard_True;
199   }
200
201 #if defined(HAVE_XLIB)
202   XFlush (myDisplay->GetDisplay());
203   XWindowAttributes aWinAttr;
204   XGetWindowAttributes (myDisplay->GetDisplay(), (Window )myXWindow, &aWinAttr);
205   return aWinAttr.map_state == IsUnviewable
206       || aWinAttr.map_state == IsViewable;
207 #else
208   return Standard_False;
209 #endif
210 }
211
212 // =======================================================================
213 // function : Map
214 // purpose  :
215 // =======================================================================
216 void Xw_Window::Map() const
217 {
218   if (IsVirtual() || myXWindow == 0)
219   {
220     return;
221   }
222
223 #if defined(HAVE_XLIB)
224   XMapWindow (myDisplay->GetDisplay(), (Window )myXWindow);
225   XFlush (myDisplay->GetDisplay());
226 #endif
227 }
228
229 // =======================================================================
230 // function : Unmap
231 // purpose  :
232 // =======================================================================
233 void Xw_Window::Unmap() const
234 {
235   if (IsVirtual() || myXWindow == 0)
236   {
237     return;
238   }
239
240 #if defined(HAVE_XLIB)
241   XIconifyWindow (myDisplay->GetDisplay(), (Window )myXWindow, DefaultScreen(myDisplay->GetDisplay()));
242 #endif
243 }
244
245 // =======================================================================
246 // function : DoResize
247 // purpose  :
248 // =======================================================================
249 Aspect_TypeOfResize Xw_Window::DoResize()
250 {
251   if (IsVirtual() || myXWindow == 0)
252   {
253     return Aspect_TOR_UNKNOWN;
254   }
255
256 #if defined(HAVE_XLIB)
257   XFlush (myDisplay->GetDisplay());
258   XWindowAttributes aWinAttr;
259   memset (&aWinAttr, 0, sizeof(aWinAttr));
260   XGetWindowAttributes (myDisplay->GetDisplay(), (Window )myXWindow, &aWinAttr);
261   if (aWinAttr.map_state == IsUnmapped)
262   {
263     return Aspect_TOR_UNKNOWN;
264   }
265
266   Standard_Integer aMask = 0;
267   Aspect_TypeOfResize aMode = Aspect_TOR_UNKNOWN;
268
269   if (Abs (aWinAttr.x                     - myXLeft  ) > 2) aMask |= 1;
270   if (Abs ((aWinAttr.x + aWinAttr.width)  - myXRight ) > 2) aMask |= 2;
271   if (Abs (aWinAttr.y                     - myYTop   ) > 2) aMask |= 4;
272   if (Abs ((aWinAttr.y + aWinAttr.height) - myYBottom) > 2) aMask |= 8;
273   switch (aMask)
274   {
275     case 0:  aMode = Aspect_TOR_NO_BORDER;               break;
276     case 1:  aMode = Aspect_TOR_LEFT_BORDER;             break;
277     case 2:  aMode = Aspect_TOR_RIGHT_BORDER;            break;
278     case 4:  aMode = Aspect_TOR_TOP_BORDER;              break;
279     case 5:  aMode = Aspect_TOR_LEFT_AND_TOP_BORDER;     break;
280     case 6:  aMode = Aspect_TOR_TOP_AND_RIGHT_BORDER;    break;
281     case 8:  aMode = Aspect_TOR_BOTTOM_BORDER;           break;
282     case 9:  aMode = Aspect_TOR_BOTTOM_AND_LEFT_BORDER;  break;
283     case 10: aMode = Aspect_TOR_RIGHT_AND_BOTTOM_BORDER; break;
284     default: break;
285   }
286
287   myXLeft   = aWinAttr.x;
288   myXRight  = aWinAttr.x + aWinAttr.width;
289   myYTop    = aWinAttr.y;
290   myYBottom = aWinAttr.y + aWinAttr.height;
291   return aMode;
292 #else
293   return Aspect_TOR_UNKNOWN;
294 #endif
295 }
296
297 // =======================================================================
298 // function : Ratio
299 // purpose  :
300 // =======================================================================
301 Standard_Real Xw_Window::Ratio() const
302 {
303   if (IsVirtual() || myXWindow == 0)
304   {
305     return Standard_Real(myXRight - myXLeft) / Standard_Real(myYBottom - myYTop);
306   }
307
308 #if defined(HAVE_XLIB)
309   XFlush (myDisplay->GetDisplay());
310   XWindowAttributes aWinAttr;
311   memset (&aWinAttr, 0, sizeof(aWinAttr));
312   XGetWindowAttributes (myDisplay->GetDisplay(), (Window )myXWindow, &aWinAttr);
313   return Standard_Real(aWinAttr.width) / Standard_Real(aWinAttr.height);
314 #else
315   return 1.0;
316 #endif
317 }
318
319 // =======================================================================
320 // function : Position
321 // purpose  :
322 // =======================================================================
323 void Xw_Window::Position (Standard_Integer& theX1, Standard_Integer& theY1,
324                           Standard_Integer& theX2, Standard_Integer& theY2) const
325 {
326   if (IsVirtual() || myXWindow == 0)
327   {
328     theX1  = myXLeft;
329     theX2  = myXRight;
330     theY1  = myYTop;
331     theY2  = myYBottom;
332     return;
333   }
334
335 #if defined(HAVE_XLIB)
336   XFlush (myDisplay->GetDisplay());
337   XWindowAttributes anAttributes;
338   memset (&anAttributes, 0, sizeof(anAttributes));
339   XGetWindowAttributes (myDisplay->GetDisplay(), (Window )myXWindow, &anAttributes);
340   Window aChild;
341   XTranslateCoordinates (myDisplay->GetDisplay(), anAttributes.root, (Window )myXWindow,
342                          0, 0, &anAttributes.x, &anAttributes.y, &aChild);
343
344   theX1 = -anAttributes.x;
345   theX2 = theX1 + anAttributes.width;
346   theY1 = -anAttributes.y;
347   theY2 = theY1 + anAttributes.height;
348 #endif
349 }
350
351 // =======================================================================
352 // function : Size
353 // purpose  :
354 // =======================================================================
355 void Xw_Window::Size (Standard_Integer& theWidth,
356                       Standard_Integer& theHeight) const
357 {
358   if (IsVirtual() || myXWindow == 0)
359   {
360     theWidth  = myXRight - myXLeft;
361     theHeight = myYBottom - myYTop;
362     return;
363   }
364
365 #if defined(HAVE_XLIB)
366   XFlush (myDisplay->GetDisplay());
367   XWindowAttributes aWinAttr;
368   memset (&aWinAttr, 0, sizeof(aWinAttr));
369   XGetWindowAttributes (myDisplay->GetDisplay(), (Window )myXWindow, &aWinAttr);
370   theWidth  = aWinAttr.width;
371   theHeight = aWinAttr.height;
372 #endif
373 }
374
375 // =======================================================================
376 // function : SetTitle
377 // purpose  :
378 // =======================================================================
379 void Xw_Window::SetTitle (const TCollection_AsciiString& theTitle)
380 {
381   if (myXWindow != 0)
382   {
383   #if defined(HAVE_XLIB)
384     XStoreName (myDisplay->GetDisplay(), (Window )myXWindow, theTitle.ToCString());
385   #else
386     (void )theTitle;
387   #endif
388   }
389 }
390
391 // =======================================================================
392 // function : InvalidateContent
393 // purpose  :
394 // =======================================================================
395 void Xw_Window::InvalidateContent (const Handle(Aspect_DisplayConnection)& theDisp)
396 {
397   if (myXWindow == 0)
398   {
399     return;
400   }
401
402 #if defined(HAVE_XLIB)
403   const Handle(Aspect_DisplayConnection)& aDisp = !theDisp.IsNull() ? theDisp : myDisplay;
404   Display* aDispX = aDisp->GetDisplay();
405
406   XEvent anEvent;
407   memset (&anEvent, 0, sizeof(anEvent));
408   anEvent.type = Expose;
409   anEvent.xexpose.window = (Window )myXWindow;
410   XSendEvent (aDispX, (Window )myXWindow, False, ExposureMask, &anEvent);
411   XFlush (aDispX);
412 #else
413   (void )theDisp;
414 #endif
415 }
416
417 // =======================================================================
418 // function : VirtualKeyFromNative
419 // purpose  :
420 // =======================================================================
421 Aspect_VKey Xw_Window::VirtualKeyFromNative (unsigned long theKey)
422 {
423 #if defined(HAVE_XLIB)
424   if (theKey >= XK_0
425    && theKey <= XK_9)
426   {
427     return Aspect_VKey(theKey - XK_0 + Aspect_VKey_0);
428   }
429
430   if (theKey >= XK_A
431    && theKey <= XK_Z)
432   {
433     return Aspect_VKey(theKey - XK_A + Aspect_VKey_A);
434   }
435
436   if (theKey >= XK_a
437    && theKey <= XK_z)
438   {
439     return Aspect_VKey(theKey - XK_a + Aspect_VKey_A);
440   }
441
442   if (theKey >= XK_F1
443    && theKey <= XK_F24)
444   {
445     if (theKey <= XK_F12)
446     {
447       return Aspect_VKey(theKey - XK_F1 + Aspect_VKey_F1);
448     }
449     return Aspect_VKey_UNKNOWN;
450   }
451
452   switch (theKey)
453   {
454     case XK_space:
455       return Aspect_VKey_Space;
456     case XK_apostrophe:
457       return Aspect_VKey_Apostrophe;
458     case XK_comma:
459       return Aspect_VKey_Comma;
460     case XK_minus:
461       return Aspect_VKey_Minus;
462     case XK_period:
463       return Aspect_VKey_Period;
464     case XK_semicolon:
465       return Aspect_VKey_Semicolon;
466     case XK_equal:
467       return Aspect_VKey_Equal;
468     case XK_bracketleft:
469       return Aspect_VKey_BracketLeft;
470     case XK_backslash:
471       return Aspect_VKey_Backslash;
472     case XK_bracketright:
473       return Aspect_VKey_BracketRight;
474     case XK_BackSpace:
475       return Aspect_VKey_Backspace;
476     case XK_Tab:
477       return Aspect_VKey_Tab;
478     //case XK_Linefeed:
479     case XK_Return:
480     case XK_KP_Enter:
481       return Aspect_VKey_Enter;
482     //case XK_Pause:
483     //  return Aspect_VKey_Pause;
484     case XK_Escape:
485       return Aspect_VKey_Escape;
486     case XK_Home:
487       return Aspect_VKey_Home;
488     case XK_Left:
489       return Aspect_VKey_Left;
490     case XK_Up:
491       return Aspect_VKey_Up;
492     case XK_Right:
493       return Aspect_VKey_Right;
494     case XK_Down:
495       return Aspect_VKey_Down;
496     case XK_Prior:
497       return Aspect_VKey_PageUp;
498     case XK_Next:
499       return Aspect_VKey_PageDown;
500     case XK_End:
501       return Aspect_VKey_End;
502     //case XK_Insert:
503     //  return Aspect_VKey_Insert;
504     case XK_Menu:
505       return Aspect_VKey_Menu;
506     case XK_Num_Lock:
507       return Aspect_VKey_Numlock;
508     //case XK_KP_Delete:
509     //  return Aspect_VKey_NumDelete;
510     case XK_KP_Multiply:
511       return Aspect_VKey_NumpadMultiply;
512     case XK_KP_Add:
513       return Aspect_VKey_NumpadAdd;
514     //case XK_KP_Separator:
515     //  return Aspect_VKey_Separator;
516     case XK_KP_Subtract:
517       return Aspect_VKey_NumpadSubtract;
518     //case XK_KP_Decimal:
519     //  return Aspect_VKey_Decimal;
520     case XK_KP_Divide:
521       return Aspect_VKey_NumpadDivide;
522     case XK_Shift_L:
523     case XK_Shift_R:
524       return Aspect_VKey_Shift;
525     case XK_Control_L:
526     case XK_Control_R:
527       return Aspect_VKey_Control;
528     //case XK_Caps_Lock:
529     //  return Aspect_VKey_CapsLock;
530     case XK_Alt_L:
531     case XK_Alt_R:
532       return Aspect_VKey_Alt;
533     //case XK_Super_L:
534     //case XK_Super_R:
535     //  return Aspect_VKey_Super;
536     case XK_Delete:
537       return Aspect_VKey_Delete;
538
539     case 0x1008FF11: // XF86AudioLowerVolume
540       return Aspect_VKey_VolumeDown;
541     case 0x1008FF12: // XF86AudioMute
542       return Aspect_VKey_VolumeMute;
543     case 0x1008FF13: // XF86AudioRaiseVolume
544       return Aspect_VKey_VolumeUp;
545
546     case 0x1008FF14: // XF86AudioPlay
547       return Aspect_VKey_MediaPlayPause;
548     case 0x1008FF15: // XF86AudioStop
549       return Aspect_VKey_MediaStop;
550     case 0x1008FF16: // XF86AudioPrev
551       return Aspect_VKey_MediaPreviousTrack;
552     case 0x1008FF17: // XF86AudioNext
553       return Aspect_VKey_MediaNextTrack;
554
555     case 0x1008FF18: // XF86HomePage
556       return Aspect_VKey_BrowserHome;
557     case 0x1008FF26: // XF86Back
558       return Aspect_VKey_BrowserBack;
559     case 0x1008FF27: // XF86Forward
560       return Aspect_VKey_BrowserForward;
561     case 0x1008FF28: // XF86Stop
562       return Aspect_VKey_BrowserStop;
563     case 0x1008FF29: // XF86Refresh
564       return Aspect_VKey_BrowserRefresh;
565   }
566 #else
567   (void )theKey;
568 #endif
569   return Aspect_VKey_UNKNOWN;
570 }
571
572 // =======================================================================
573 // function : ProcessMessage
574 // purpose  :
575 // =======================================================================
576 bool Xw_Window::ProcessMessage (Aspect_WindowInputListener& theListener,
577                                 XEvent&
578                                 #if defined(HAVE_XLIB) // msvc before VS2015 had problems with (void )theMsg
579                                         theMsg
580                                 #endif
581                                 )
582 {
583 #if defined(HAVE_XLIB)
584   Display* aDisplay = myDisplay->GetDisplay();
585
586   // Handle event for the chosen display connection
587   switch (theMsg.type)
588   {
589     case ClientMessage:
590     {
591       if ((Atom)theMsg.xclient.data.l[0] == myDisplay->GetAtom (Aspect_XA_DELETE_WINDOW)
592        && theMsg.xclient.window == (Window )myXWindow)
593       {
594         theListener.ProcessClose();
595         return true;
596       }
597       return false;
598     }
599     case FocusIn:
600     case FocusOut:
601     {
602       if (theMsg.xfocus.window == (Window )myXWindow)
603       {
604         theListener.ProcessFocus (theMsg.type == FocusIn);
605       }
606       return true;
607     }
608     case Expose:
609     {
610       if (theMsg.xexpose.window == (Window )myXWindow)
611       {
612         theListener.ProcessExpose();
613       }
614
615       // remove all the ExposureMask and process them at once
616       for (int aNbMaxEvents = XPending (aDisplay); aNbMaxEvents > 0; --aNbMaxEvents)
617       {
618         if (!XCheckWindowEvent (aDisplay, (Window )myXWindow, ExposureMask, &theMsg))
619         {
620           break;
621         }
622       }
623
624       return true;
625     }
626     case ConfigureNotify:
627     {
628       // remove all the StructureNotifyMask and process them at once
629       for (int aNbMaxEvents = XPending (aDisplay); aNbMaxEvents > 0; --aNbMaxEvents)
630       {
631         if (!XCheckWindowEvent (aDisplay, (Window )myXWindow, StructureNotifyMask, &theMsg))
632         {
633           break;
634         }
635       }
636
637       if (theMsg.xconfigure.window == (Window )myXWindow)
638       {
639         theListener.ProcessConfigure (true);
640       }
641       return true;
642     }
643     case KeyPress:
644     case KeyRelease:
645     {
646       XKeyEvent*   aKeyEvent = (XKeyEvent* )&theMsg;
647       const KeySym aKeySym = XLookupKeysym (aKeyEvent, 0);
648       const Aspect_VKey aVKey = Xw_Window::VirtualKeyFromNative (aKeySym);
649       if (aVKey != Aspect_VKey_UNKNOWN)
650       {
651         const double aTimeStamp = theListener.EventTime();
652         if (theMsg.type == KeyPress)
653         {
654           theListener.KeyDown (aVKey, aTimeStamp);
655         }
656         else
657         {
658           theListener.KeyUp (aVKey, aTimeStamp);
659         }
660         theListener.ProcessInput();
661       }
662       return true;
663     }
664     case ButtonPress:
665     case ButtonRelease:
666     {
667       const Graphic3d_Vec2i aPos (theMsg.xbutton.x, theMsg.xbutton.y);
668       Aspect_VKeyFlags aFlags  = Aspect_VKeyFlags_NONE;
669       Aspect_VKeyMouse aButton = Aspect_VKeyMouse_NONE;
670       if (theMsg.xbutton.button == Button1) { aButton = Aspect_VKeyMouse_LeftButton; }
671       if (theMsg.xbutton.button == Button2) { aButton = Aspect_VKeyMouse_MiddleButton; }
672       if (theMsg.xbutton.button == Button3) { aButton = Aspect_VKeyMouse_RightButton; }
673
674       if ((theMsg.xbutton.state & ControlMask) != 0) { aFlags |= Aspect_VKeyFlags_CTRL; }
675       if ((theMsg.xbutton.state & ShiftMask)   != 0) { aFlags |= Aspect_VKeyFlags_SHIFT; }
676       if (theListener.Keys().IsKeyDown (Aspect_VKey_Alt))
677       {
678         aFlags |= Aspect_VKeyFlags_ALT;
679       }
680
681       if (theMsg.xbutton.button == Button4
682        || theMsg.xbutton.button == Button5)
683       {
684         if (theMsg.type != ButtonPress)
685         {
686           return true;
687         }
688
689         const double aDeltaF = (theMsg.xbutton.button == Button4 ? 1.0 : -1.0);
690         theListener.UpdateMouseScroll (Aspect_ScrollDelta (aPos, aDeltaF, aFlags));
691       }
692       else if (theMsg.type == ButtonPress)
693       {
694         theListener.PressMouseButton (aPos, aButton, aFlags, false);
695       }
696       else
697       {
698         theListener.ReleaseMouseButton (aPos, aButton, aFlags, false);
699       }
700       theListener.ProcessInput();
701       return true;
702     }
703     case MotionNotify:
704     {
705       if (theMsg.xmotion.window != (Window )myXWindow)
706       {
707         return false;
708       }
709
710       // remove all the ButtonMotionMask and process them at once
711       for (int aNbMaxEvents = XPending (aDisplay); aNbMaxEvents > 0; --aNbMaxEvents)
712       {
713         if (!XCheckWindowEvent (aDisplay, (Window )myXWindow, ButtonMotionMask | PointerMotionMask, &theMsg))
714         {
715           break;
716         }
717       }
718
719       Graphic3d_Vec2i aPos (theMsg.xmotion.x, theMsg.xmotion.y);
720       Aspect_VKeyMouse aButtons = Aspect_VKeyMouse_NONE;
721       Aspect_VKeyFlags aFlags   = Aspect_VKeyFlags_NONE;
722       if ((theMsg.xmotion.state & Button1Mask) != 0) { aButtons |= Aspect_VKeyMouse_LeftButton; }
723       if ((theMsg.xmotion.state & Button2Mask) != 0) { aButtons |= Aspect_VKeyMouse_MiddleButton; }
724       if ((theMsg.xmotion.state & Button3Mask) != 0) { aButtons |= Aspect_VKeyMouse_RightButton; }
725
726       if ((theMsg.xmotion.state & ControlMask) != 0) { aFlags |= Aspect_VKeyFlags_CTRL; }
727       if ((theMsg.xmotion.state & ShiftMask)   != 0) { aFlags |= Aspect_VKeyFlags_SHIFT; }
728       if (theListener.Keys().IsKeyDown (Aspect_VKey_Alt))
729       {
730         aFlags |= Aspect_VKeyFlags_ALT;
731       }
732
733       theListener.UpdateMousePosition (aPos, aButtons, aFlags, false);
734       theListener.ProcessInput();
735       return true;
736     }
737   }
738 #else
739   (void )theListener;
740 #endif
741   return false;
742 }