Qt: new volume slider, optionnal. Totem like, for people who use Totem
[vlc.git] / modules / gui / skins2 / x11 / x11_loop.cpp
1 /*****************************************************************************
2  * x11_loop.cpp
3  *****************************************************************************
4  * Copyright (C) 2003 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Cyril Deguet     <asmax@via.ecp.fr>
8  *          Olivier Teulière <ipkiss@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 #ifdef X11_SKINS
26
27 #include <X11/keysym.h>
28 #include "x11_loop.hpp"
29 #include "x11_display.hpp"
30 #include "x11_dragdrop.hpp"
31 #include "x11_factory.hpp"
32 #include "x11_timer.hpp"
33 #include "../src/generic_window.hpp"
34 #include "../src/theme.hpp"
35 #include "../src/window_manager.hpp"
36 #include "../events/evt_focus.hpp"
37 #include "../events/evt_key.hpp"
38 #include "../events/evt_mouse.hpp"
39 #include "../events/evt_motion.hpp"
40 #include "../events/evt_leave.hpp"
41 #include "../events/evt_refresh.hpp"
42 #include "../events/evt_scroll.hpp"
43 #include "../commands/async_queue.hpp"
44 #include "../utils/var_bool.hpp"
45 #include "vlc_keys.h"
46
47
48 // Maximum interval between clicks for a double-click (in microsec)
49 int X11Loop::m_dblClickDelay = 400000;
50
51
52 X11Loop::X11Loop( intf_thread_t *pIntf, X11Display &rDisplay ):
53     OSLoop( pIntf ), m_rDisplay( rDisplay ), m_exit( false ),
54     m_lastClickTime( 0 ), m_lastClickPosX( 0 ), m_lastClickPosY( 0 )
55 {
56     // Initialize the key map
57     keysymToVlcKey[XK_F1] = KEY_F1;
58     keysymToVlcKey[XK_F2] = KEY_F2;
59     keysymToVlcKey[XK_F3] = KEY_F3;
60     keysymToVlcKey[XK_F4] = KEY_F4;
61     keysymToVlcKey[XK_F5] = KEY_F5;
62     keysymToVlcKey[XK_F6] = KEY_F6;
63     keysymToVlcKey[XK_F7] = KEY_F7;
64     keysymToVlcKey[XK_F8] = KEY_F8;
65     keysymToVlcKey[XK_F9] = KEY_F9;
66     keysymToVlcKey[XK_F10] = KEY_F10;
67     keysymToVlcKey[XK_F11] = KEY_F11;
68     keysymToVlcKey[XK_F12] = KEY_F12;
69     keysymToVlcKey[XK_Return] = KEY_ENTER;
70     keysymToVlcKey[XK_space] = KEY_SPACE;
71     keysymToVlcKey[XK_Escape] = KEY_ESC;
72     keysymToVlcKey[XK_Left] = KEY_LEFT;
73     keysymToVlcKey[XK_Right] = KEY_RIGHT;
74     keysymToVlcKey[XK_Up] = KEY_UP;
75     keysymToVlcKey[XK_Down] = KEY_DOWN;
76     keysymToVlcKey[XK_Home] = KEY_HOME;
77     keysymToVlcKey[XK_End] = KEY_END;
78     keysymToVlcKey[XK_Prior] = KEY_PAGEUP;
79     keysymToVlcKey[XK_Next] = KEY_PAGEDOWN;
80     keysymToVlcKey[XK_Delete] = KEY_DELETE;
81     keysymToVlcKey[XK_Insert] = KEY_INSERT;
82 }
83
84
85 X11Loop::~X11Loop()
86 {
87 }
88
89
90 OSLoop *X11Loop::instance( intf_thread_t *pIntf, X11Display &rDisplay )
91 {
92     if( pIntf->p_sys->p_osLoop == NULL )
93     {
94         OSLoop *pOsLoop = new X11Loop( pIntf, rDisplay );
95         pIntf->p_sys->p_osLoop = pOsLoop;
96     }
97     return pIntf->p_sys->p_osLoop;
98 }
99
100
101 void X11Loop::destroy( intf_thread_t *pIntf )
102 {
103     if( pIntf->p_sys->p_osLoop )
104     {
105         delete pIntf->p_sys->p_osLoop;
106         pIntf->p_sys->p_osLoop = NULL;
107     }
108 }
109
110
111 void X11Loop::run()
112 {
113     OSFactory *pOsFactory = OSFactory::instance( getIntf() );
114     X11TimerLoop *pTimerLoop = ((X11Factory*)pOsFactory)->getTimerLoop();
115
116     // Main event loop
117     while( ! m_exit )
118     {
119         int nPending;
120
121         // Number of pending events in the queue
122         nPending = XPending( XDISPLAY );
123
124         while( ! m_exit && nPending > 0 )
125         {
126             // Handle the next X11 event
127             handleX11Event();
128
129             // Number of pending events in the queue
130             nPending = XPending( XDISPLAY );
131         }
132
133         // Wait for the next timer and execute it
134         // The sleep is interrupted if an X11 event is received
135         if( !m_exit )
136         {
137             pTimerLoop->waitNextTimer();
138         }
139     }
140 }
141
142
143 void X11Loop::exit()
144 {
145     m_exit = true;
146 }
147
148
149 void X11Loop::handleX11Event()
150 {
151     XEvent event;
152     OSFactory *pOsFactory = OSFactory::instance( getIntf() );
153
154     // Look for the next event in the queue
155     XNextEvent( XDISPLAY, &event );
156
157     if( event.xany.window == m_rDisplay.getMainWindow() )
158     {
159         if( event.type == MapNotify )
160         {
161             // When the "parent" window is mapped, show all the visible
162             // windows, as it is not automatic, unfortunately
163             Theme *pTheme = getIntf()->p_sys->p_theme;
164             if( pTheme )
165             {
166                 pTheme->getWindowManager().synchVisibility();
167             }
168         }
169         return;
170     }
171
172     // Find the window to which the event is sent
173     GenericWindow *pWin =
174         ((X11Factory*)pOsFactory)->m_windowMap[event.xany.window];
175
176     if( !pWin )
177     {
178         msg_Warn( getIntf(), "no associated generic window" );
179         return;
180     }
181
182     // Send the right event object to the window
183     switch( event.type )
184     {
185         case Expose:
186         {
187             EvtRefresh evt( getIntf(), event.xexpose.x,
188                             event.xexpose.y, event.xexpose.width,
189                             event.xexpose.height );
190             pWin->processEvent( evt );
191             break;
192         }
193         case FocusIn:
194         {
195             EvtFocus evt( getIntf(), true );
196             pWin->processEvent( evt );
197             break;
198         }
199         case FocusOut:
200         {
201             EvtFocus evt( getIntf(), false );
202             pWin->processEvent( evt );
203             break;
204         }
205
206         case MotionNotify:
207         {
208             // Don't trust the position in the event, it is
209             // out of date. Get the actual current position instead
210             int x, y;
211             pOsFactory->getMousePos( x, y );
212             EvtMotion evt( getIntf(), x, y );
213             pWin->processEvent( evt );
214             break;
215         }
216         case LeaveNotify:
217         {
218             EvtLeave evt( getIntf() );
219             pWin->processEvent( evt );
220             break;
221         }
222         case ButtonPress:
223         case ButtonRelease:
224         {
225             EvtMouse::ActionType_t action = EvtMouse::kDown;
226             switch( event.type )
227             {
228                 case ButtonPress:
229                     action = EvtMouse::kDown;
230                     break;
231                 case ButtonRelease:
232                     action = EvtMouse::kUp;
233                     break;
234             }
235
236             // Get the modifiers
237             int mod = EvtInput::kModNone;
238             if( event.xbutton.state & Mod1Mask )
239             {
240                 mod |= EvtInput::kModAlt;
241             }
242             if( event.xbutton.state & ControlMask )
243             {
244                 mod |= EvtInput::kModCtrl;
245             }
246             if( event.xbutton.state & ShiftMask )
247             {
248                 mod |= EvtInput::kModShift;
249             }
250
251             // Check for double clicks
252             if( event.type == ButtonPress &&
253                 event.xbutton.button == 1 )
254             {
255                 mtime_t time = mdate();
256                 int x, y;
257                 pOsFactory->getMousePos( x, y );
258                 if( time - m_lastClickTime < m_dblClickDelay &&
259                     x == m_lastClickPosX && y == m_lastClickPosY )
260                 {
261                     m_lastClickTime = 0;
262                     action = EvtMouse::kDblClick;
263                 }
264                 else
265                 {
266                     m_lastClickTime = time;
267                     m_lastClickPosX = x;
268                     m_lastClickPosY = y;
269                 }
270             }
271
272             switch( event.xbutton.button )
273             {
274                 case 1:
275                 {
276                     EvtMouse evt( getIntf(), event.xbutton.x,
277                                   event.xbutton.y, EvtMouse::kLeft,
278                                   action, mod );
279                     pWin->processEvent( evt );
280                     break;
281                 }
282                 case 2:
283                 {
284                     EvtMouse evt( getIntf(), event.xbutton.x,
285                                   event.xbutton.y, EvtMouse::kMiddle,
286                                   action, mod );
287                     pWin->processEvent( evt );
288                     break;
289                 }
290                 case 3:
291                 {
292                     EvtMouse evt( getIntf(), event.xbutton.x,
293                                   event.xbutton.y, EvtMouse::kRight,
294                                   action, mod );
295                     pWin->processEvent( evt );
296                     break;
297                 }
298                 case 4:
299                 {
300                     // Scroll up
301                     EvtScroll evt( getIntf(), event.xbutton.x,
302                                    event.xbutton.y, EvtScroll::kUp,
303                                    mod );
304                     pWin->processEvent( evt );
305                     break;
306                 }
307                 case 5:
308                 {
309                     // Scroll down
310                     EvtScroll evt( getIntf(), event.xbutton.x,
311                                    event.xbutton.y, EvtScroll::kDown,
312                                    mod );
313                     pWin->processEvent( evt );
314                     break;
315                 }
316             }
317             break;
318         }
319         case KeyPress:
320         case KeyRelease:
321         {
322             EvtKey::ActionType_t action = EvtKey::kDown;
323             int mod = EvtInput::kModNone;
324             // Get the modifiers
325             if( event.xkey.state & Mod1Mask )
326             {
327                 mod |= EvtInput::kModAlt;
328             }
329             if( event.xkey.state & ControlMask )
330             {
331                 mod |= EvtInput::kModCtrl;
332             }
333             if( event.xkey.state & ShiftMask )
334             {
335                 mod |= EvtInput::kModShift;
336             }
337
338             // Take the first keysym = lower case character
339             KeySym keysym = XLookupKeysym( &event.xkey, 0 );
340
341             // Get VLC key code from the keysym
342             int key = keysymToVlcKey[keysym];
343             if( !key )
344             {
345                 // Normal key
346                 key = keysym;
347             }
348
349             switch( event.type )
350             {
351                 case KeyPress:
352                     action = EvtKey::kDown;
353                     break;
354                 case KeyRelease:
355                     action = EvtKey::kUp;
356                     break;
357             }
358             EvtKey evt( getIntf(), key, action, mod );
359             pWin->processEvent( evt );
360             break;
361         }
362
363         case ClientMessage:
364         {
365             // Get the message type
366             string type = XGetAtomName( XDISPLAY, event.xclient.message_type );
367
368             // Find the DnD object for this window
369             X11DragDrop *pDnd =
370                 ((X11Factory*)pOsFactory)->m_dndMap[event.xany.window];
371             if( !pDnd )
372             {
373                 msg_Err( getIntf(), "no associated D&D object" );
374                 return;
375             }
376
377             if( type == "XdndEnter" )
378             {
379                 pDnd->dndEnter( event.xclient.data.l );
380             }
381             else if( type == "XdndPosition" )
382             {
383                 pDnd->dndPosition( event.xclient.data.l );
384             }
385             else if( type == "XdndLeave" )
386             {
387                 pDnd->dndLeave( event.xclient.data.l );
388             }
389             else if( type == "XdndDrop" )
390             {
391                 pDnd->dndDrop( event.xclient.data.l );
392             }
393             break;
394         }
395     }
396 }
397
398 #endif