• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

KDECore

kglobalaccel_win.cpp

Go to the documentation of this file.

/* This file is part of the KDE libraries
    Copyright (C) 2001,2002 Ellis Whitehead <ellis@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include "config.h"

#include <qwindowdefs.h>
#ifdef Q_WS_WIN

#include "kglobalaccel_win.h"
#include "kglobalaccel.h"
#include "kkeyserver_x11.h"

#include <qpopupmenu.h>
#include <qregexp.h>
#include <qwidget.h>
#include <qmetaobject.h>
#include <private/qucomextra_p.h>
#include <kapplication.h>
#include <kdebug.h>
#include <kkeynative.h>

//----------------------------------------------------

static QValueList< KGlobalAccelPrivate* >* all_accels = 0;

KGlobalAccelPrivate::KGlobalAccelPrivate()
: KAccelBase( KAccelBase::NATIVE_KEYS )
, m_blocked( false )
, m_blockingDisabled( false )
{
        if( all_accels == NULL )
            all_accels = new QValueList< KGlobalAccelPrivate* >;
        all_accels->append( this );
    m_sConfigGroup = "Global Shortcuts";
//  kapp->installX11EventFilter( this );
}

KGlobalAccelPrivate::~KGlobalAccelPrivate()
{
    // TODO: Need to release all grabbed keys if the main window is not shutting down.
    //for( CodeModMap::ConstIterator it = m_rgCodeModToAction.begin(); it != m_rgCodeModToAction.end(); ++it ) {
    //  const CodeMod& codemod = it.key();
    //}
        all_accels->remove( this );
        if( all_accels->count() == 0 ) {
            delete all_accels;
            all_accels = NULL;
        }
}

void KGlobalAccelPrivate::setEnabled( bool bEnable )
{
    m_bEnabled = bEnable;
    //updateConnections();
}

void KGlobalAccelPrivate::blockShortcuts( bool block )
{
        if( all_accels == NULL )
            return;
        for( QValueList< KGlobalAccelPrivate* >::ConstIterator it = all_accels->begin();
             it != all_accels->end();
             ++it ) {
            if( (*it)->m_blockingDisabled )
                continue;
            (*it)->m_blocked = block;
            (*it)->updateConnections();
        }
}

void KGlobalAccelPrivate::disableBlocking( bool block )
{
        m_blockingDisabled = block;
}

bool KGlobalAccelPrivate::isEnabledInternal() const
{
        return KAccelBase::isEnabled() && !m_blocked;
}

bool KGlobalAccelPrivate::emitSignal( Signal )
{
    return false;
}

bool KGlobalAccelPrivate::connectKey( KAccelAction& action, const KKeyServer::Key& key )
    { return grabKey( key, true, &action ); }
bool KGlobalAccelPrivate::connectKey( const KKeyServer::Key& key )
    { return grabKey( key, true, 0 ); }
bool KGlobalAccelPrivate::disconnectKey( KAccelAction& action, const KKeyServer::Key& key )
    { return grabKey( key, false, &action ); }
bool KGlobalAccelPrivate::disconnectKey( const KKeyServer::Key& key )
    { return grabKey( key, false, 0 ); }

bool KGlobalAccelPrivate::grabKey( const KKeyServer::Key& key, bool bGrab, KAccelAction* pAction )
{
    /*
    if( !key.code() ) {
        kdWarning(125) << "KGlobalAccelPrivate::grabKey( " << key.key().toStringInternal() << ", " << bGrab << ", \"" << (pAction ? pAction->name().latin1() : "(null)") << "\" ): Tried to grab key with null code." << endl;
        return false;
    }

    // Make sure that grab masks have been initialized.
    if( g_keyModMaskXOnOrOff == 0 )
        calculateGrabMasks();

    uchar keyCodeX = key.code();
    uint keyModX = key.mod() & g_keyModMaskXAccel; // Get rid of any non-relevant bits in mod
    // HACK: make Alt+Print work
    if( key.sym() == XK_Sys_Req ) {
        keyModX |= KKeyServer::modXAlt();
        keyCodeX = 111;
    }

    kdDebug(125) << QString( "grabKey( key: '%1', bGrab: %2 ): keyCodeX: %3 keyModX: %4\n" )
        .arg( key.key().toStringInternal() ).arg( bGrab )
        .arg( keyCodeX, 0, 16 ).arg( keyModX, 0, 16 );
    if( !keyCodeX )
        return false;

    // We'll have to grab 8 key modifier combinations in order to cover all
    //  combinations of CapsLock, NumLock, ScrollLock.
    // Does anyone with more X-savvy know how to set a mask on qt_xrootwin so that
    //  the irrelevant bits are always ignored and we can just make one XGrabKey
    //  call per accelerator? -- ellis
#ifndef NDEBUG
    QString sDebug = QString("\tcode: 0x%1 state: 0x%2 | ").arg(keyCodeX,0,16).arg(keyModX,0,16);
#endif
    uint keyModMaskX = ~g_keyModMaskXOnOrOff;
    for( uint irrelevantBitsMask = 0; irrelevantBitsMask <= 0xff; irrelevantBitsMask++ ) {
        if( (irrelevantBitsMask & keyModMaskX) == 0 ) {
#ifndef NDEBUG
            sDebug += QString("0x%3, ").arg(irrelevantBitsMask, 0, 16);
#endif
            if( bGrab )
                XGrabKey( qt_xdisplay(), keyCodeX, keyModX | irrelevantBitsMask,
                    qt_xrootwin(), True, GrabModeAsync, GrabModeSync );
            else
                XUngrabKey( qt_xdisplay(), keyCodeX, keyModX | irrelevantBitsMask, qt_xrootwin() );
        }
    }
#ifndef NDEBUG
    kdDebug(125) << sDebug << endl;
#endif

        bool failed = false;
        if( bGrab ) {
#ifdef Q_WS_X11
            failed = handler.error( true ); // sync now
#endif
            // If grab failed, then ungrab any grabs that could possibly succeed
        if( failed ) {
            kdDebug(125) << "grab failed!\n";
            for( uint m = 0; m <= 0xff; m++ ) {
                if( m & keyModMaskX == 0 )
                    XUngrabKey( qt_xdisplay(), keyCodeX, keyModX | m, qt_xrootwin() );
                }
                }
    }
        if( !failed )
        {
        CodeMod codemod;
        codemod.code = keyCodeX;
        codemod.mod = keyModX;
        if( key.mod() & KKeyServer::MODE_SWITCH )
            codemod.mod |= KKeyServer::MODE_SWITCH;

        if( bGrab )
            m_rgCodeModToAction.insert( codemod, pAction );
        else
            m_rgCodeModToAction.remove( codemod );
    }
    return !failed;*/
    return false;
}

/*bool KGlobalAccelPrivate::x11Event( XEvent* pEvent )
{
    //kdDebug(125) << "x11EventFilter( type = " << pEvent->type << " )" << endl;
    switch( pEvent->type ) {
     case MappingNotify:
            XRefreshKeyboardMapping( &pEvent->xmapping );
        x11MappingNotify();
        return false;
     case XKeyPress:
        if( x11KeyPress( pEvent ) )
            return true;
     default:
        return QWidget::x11Event( pEvent );
    }
}

void KGlobalAccelPrivate::x11MappingNotify()
{
    kdDebug(125) << "KGlobalAccelPrivate::x11MappingNotify()" << endl;
    if( m_bEnabled ) {
        // Maybe the X modifier map has been changed.
        KKeyServer::initializeMods();
        calculateGrabMasks();
        // Do new XGrabKey()s.
        updateConnections();
    }
}

bool KGlobalAccelPrivate::x11KeyPress( const XEvent *pEvent )
{
    // do not change this line unless you really really know what you are doing (Matthias)
    if ( !QWidget::keyboardGrabber() && !QApplication::activePopupWidget() ) {
        XUngrabKeyboard( qt_xdisplay(), pEvent->xkey.time );
                XFlush( qt_xdisplay()); // avoid X(?) bug
        }

    if( !m_bEnabled )
        return false;

    CodeMod codemod;
    codemod.code = pEvent->xkey.keycode;
    codemod.mod = pEvent->xkey.state & (g_keyModMaskXAccel | KKeyServer::MODE_SWITCH);

    // If numlock is active and a keypad key is pressed, XOR the SHIFT state.
    //  e.g., KP_4 => Shift+KP_Left, and Shift+KP_4 => KP_Left.
    if( pEvent->xkey.state & KKeyServer::modXNumLock() ) {
        // TODO: what's the xor operator in c++?
        uint sym = XKeycodeToKeysym( qt_xdisplay(), codemod.code, 0 );
        // If this is a keypad key,
        if( sym >= XK_KP_Space && sym <= XK_KP_9 ) {
            switch( sym ) {
                // Leave the following keys unaltered
                // FIXME: The proper solution is to see which keysyms don't change when shifted.
                case XK_KP_Multiply:
                case XK_KP_Add:
                case XK_KP_Subtract:
                case XK_KP_Divide:
                    break;
                default:
                    if( codemod.mod & KKeyServer::modXShift() )
                        codemod.mod &= ~KKeyServer::modXShift();
                    else
                        codemod.mod |= KKeyServer::modXShift();
            }
        }
    }

    KKeyNative keyNative( pEvent );
    KKey key = keyNative;

    kdDebug(125) << "x11KeyPress: seek " << key.toStringInternal()
        << QString( " keyCodeX: %1 state: %2 keyModX: %3" )
            .arg( codemod.code, 0, 16 ).arg( pEvent->xkey.state, 0, 16 ).arg( codemod.mod, 0, 16 ) << endl;

    // Search for which accelerator activated this event:
    if( !m_rgCodeModToAction.contains( codemod ) ) {
#ifndef NDEBUG
        for( CodeModMap::ConstIterator it = m_rgCodeModToAction.begin(); it != m_rgCodeModToAction.end(); ++it ) {
            KAccelAction* pAction = *it;
            kdDebug(125) << "\tcode: " << QString::number(it.key().code, 16) << " mod: " << QString::number(it.key().mod, 16)
                << (pAction ? QString(" name: \"%1\" shortcut: %2").arg(pAction->name()).arg(pAction->shortcut().toStringInternal()) : QString::null)
                << endl;
        }
#endif
        return false;
    }
    KAccelAction* pAction = m_rgCodeModToAction[codemod];

    if( !pAction ) {
                static bool recursion_block = false;
                if( !recursion_block ) {
                        recursion_block = true;
                QPopupMenu* pMenu = createPopupMenu( 0, KKeySequence(key) );
                connect( pMenu, SIGNAL(activated(int)), this, SLOT(slotActivated(int)) );
                pMenu->exec( QPoint( 0, 0 ) );
                disconnect( pMenu, SIGNAL(activated(int)), this, SLOT(slotActivated(int)));
                delete pMenu;
                        recursion_block = false;
                }
    } else if( !pAction->objSlotPtr() || !pAction->isEnabled() )
        return false;
    else
        activate( pAction, KKeySequence(key) );

    return true;
}*/

void KGlobalAccelPrivate::activate( KAccelAction* pAction, const KKeySequence& seq )
{
    kdDebug(125) << "KGlobalAccelPrivate::activate( \"" << pAction->name() << "\" ) " << endl;

    QRegExp rexPassIndex( "([ ]*int[ ]*)" );
    QRegExp rexPassInfo( " QString" );
    QRegExp rexIndex( " ([0-9]+)$" );

    // If the slot to be called accepts an integer index
    //  and an index is present at the end of the action's name,
    //  then send the slot the given index #.
    if( rexPassIndex.search( pAction->methodSlotPtr() ) >= 0 && rexIndex.search( pAction->name() ) >= 0 ) {
        int n = rexIndex.cap(1).toInt();
        kdDebug(125) << "Calling " << pAction->methodSlotPtr() << " int = " << n << endl;
                int slot_id = pAction->objSlotPtr()->metaObject()->findSlot( normalizeSignalSlot( pAction->methodSlotPtr() ).data() + 1, true );
                if( slot_id >= 0 ) {
                    QUObject o[2];
                    static_QUType_int.set(o+1,n);
                    const_cast< QObject* >( pAction->objSlotPtr())->qt_invoke( slot_id, o );
                }
    } else if( rexPassInfo.search( pAction->methodSlotPtr() ) ) {
                int slot_id = pAction->objSlotPtr()->metaObject()->findSlot( normalizeSignalSlot( pAction->methodSlotPtr() ).data() + 1, true );
                if( slot_id >= 0 ) {
                    QUObject o[4];
                    static_QUType_QString.set(o+1,pAction->name());
                    static_QUType_QString.set(o+2,pAction->label());
                    static_QUType_ptr.set(o+3,&seq);
                    const_cast< QObject* >( pAction->objSlotPtr())->qt_invoke( slot_id, o );
                }
    } else {
                int slot_id = pAction->objSlotPtr()->metaObject()->findSlot( normalizeSignalSlot( pAction->methodSlotPtr() ).data() + 1, true );
                if( slot_id >= 0 )
                    const_cast< QObject* >( pAction->objSlotPtr())->qt_invoke( slot_id, 0 );
    }
}

void KGlobalAccelPrivate::slotActivated( int iAction )
{
    KAccelAction* pAction = actions().actionPtr( iAction );
    if( pAction )
        activate( pAction, KKeySequence() );
}

#include "kglobalaccel_win.moc"

#endif // !Q_WS_WIN

KDECore

Skip menu "KDECore"

• Main Page
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

API Reference

Skip menu "API Reference"

• dcop
• DNSSD
• interfaces
• Kate
• kconf_update
• KDECore
• KDED
• kdefx
• KDEsu
• kdeui
• KDocTools
• KHTML
• KImgIO
• KInit
• kio
• kioslave
• KJS
• KNewStuff
• KParts
• KUtils

Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal