git.sesse.net Git - vlc/blob - 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