Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 616 insertions, 0 deletions

diff --git a/kdecore/kaccelbase.cpp b/kdecore/kaccelbase.cpp
new file mode 100644
index 000000000..d8d0c36da
--- /dev/null
+++ b/kdecore/kaccelbase.cpp
@@ -0,0 +1,616 @@
+/*
+    Copyright (C) 1997-2000 Nicolas Hadacek <hadacek@kde.org>
+    Copyright (C) 1998 Mark Donohoe <donohoe@kde.org>
+    Copyright (C) 1998 Matthias Ettrich <ettrich@kde.org>
+    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 "kaccelbase.h"
+
+#include <qkeycode.h>
+#include <qlabel.h>
+#include <qpopupmenu.h>
+
+#include <kconfig.h>
+#include "kckey.h"
+#include <kdebug.h>
+#include <kglobal.h>
+#include <kkeynative.h>
+#include "kkeyserver.h"
+#include <klocale.h>
+#include "kshortcutmenu.h"
+
+//---------------------------------------------------------------------
+// class KAccelBase::ActionInfo
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+// class KAccelBase
+//---------------------------------------------------------------------
+
+KAccelBase::KAccelBase( int fInitCode )
+:	m_rgActions( this )
+{
+	kdDebug(125) << "KAccelBase(): this = " << this << endl;
+	m_bNativeKeys = fInitCode & NATIVE_KEYS;
+	m_bEnabled = true;
+	m_sConfigGroup = "Shortcuts";
+	m_bConfigIsGlobal = false;
+	m_bAutoUpdate = false;
+	mtemp_pActionRemoving = 0;
+}
+
+KAccelBase::~KAccelBase()
+{
+	kdDebug(125) << "~KAccelBase(): this = " << this << endl;
+}
+
+uint KAccelBase::actionCount() const { return m_rgActions.count(); }
+KAccelActions& KAccelBase::actions() { return m_rgActions; }
+bool KAccelBase::isEnabled() const { return m_bEnabled; }
+// see KGlobalAccel::blockShortcuts() stuff - it's to temporarily block
+// all global shortcuts, so that the key grabs are released, but from the app's
+// point of view the KGlobalAccel is still enabled, so KGlobalAccel needs
+// to disable key grabbing even if enabled
+bool KAccelBase::isEnabledInternal() const { return isEnabled(); }
+
+KAccelAction* KAccelBase::actionPtr( const QString& sAction )
+	{ return m_rgActions.actionPtr( sAction ); }
+
+const KAccelAction* KAccelBase::actionPtr( const QString& sAction ) const
+	{ return m_rgActions.actionPtr( sAction ); }
+
+KAccelAction* KAccelBase::actionPtr( const KKeyServer::Key& key )
+{
+	if( !m_mapKeyToAction.contains( key ) )
+		return 0;
+	// Note: If more than one action is connected to a single key, nil will be returned.
+	return m_mapKeyToAction[key].pAction;
+}
+
+KAccelAction* KAccelBase::actionPtr( const KKey& key )
+{
+	KKeyServer::Key k2;
+	k2.init( key, !m_bNativeKeys );
+	return actionPtr( k2 );
+}
+
+void KAccelBase::setConfigGroup( const QString& sConfigGroup )
+	{ m_sConfigGroup = sConfigGroup; }
+
+void KAccelBase::setConfigGlobal( bool global )
+	{ m_bConfigIsGlobal = global; }
+
+bool KAccelBase::setActionEnabled( const QString& sAction, bool bEnable )
+{
+	KAccelAction* pAction = actionPtr( sAction );
+	if( pAction ) {
+		if( pAction->m_bEnabled != bEnable ) {
+			kdDebug(125) << "KAccelBase::setActionEnabled( " << sAction << ", " << bEnable << " )" << endl;
+			pAction->m_bEnabled = bEnable;
+			if( m_bAutoUpdate ) {
+				// FIXME: the action may already have it's connections inserted!
+				if( bEnable )
+					insertConnection( pAction );
+				else if( pAction->isConnected() )
+					removeConnection( pAction );
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+bool KAccelBase::setAutoUpdate( bool bAuto )
+{
+	kdDebug(125) << "KAccelBase::setAutoUpdate( " << bAuto << " ): m_bAutoUpdate on entrance = " << m_bAutoUpdate << endl;
+	bool b = m_bAutoUpdate;
+	if( !m_bAutoUpdate && bAuto )
+		updateConnections();
+	m_bAutoUpdate = bAuto;
+	return b;
+}
+
+KAccelAction* KAccelBase::insert( const QString& sAction, const QString& sDesc, const QString& sHelp,
+			const KShortcut& rgCutDefaults3, const KShortcut& rgCutDefaults4,
+			const QObject* pObjSlot, const char* psMethodSlot,
+			bool bConfigurable, bool bEnabled )
+{
+	//kdDebug(125) << "KAccelBase::insert() begin" << endl;
+	KAccelAction* pAction = m_rgActions.insert(
+		sAction, sDesc, sHelp,
+		rgCutDefaults3, rgCutDefaults4,
+		pObjSlot, psMethodSlot,
+		bConfigurable, bEnabled );
+
+	if( pAction && m_bAutoUpdate )
+		insertConnection( pAction );
+
+	//kdDebug(125) << "KAccelBase::insert() end" << endl;
+	return pAction;
+}
+
+KAccelAction* KAccelBase::insert( const QString& sName, const QString& sDesc )
+	{ return m_rgActions.insert( sName, sDesc ); }
+
+bool KAccelBase::remove( const QString& sAction )
+{
+	return m_rgActions.remove( sAction );
+}
+
+void KAccelBase::slotRemoveAction( KAccelAction* pAction )
+{
+	removeConnection( pAction );
+}
+
+bool KAccelBase::setActionSlot( const QString& sAction, const QObject* pObjSlot, const char* psMethodSlot )
+{
+	kdDebug(125) << "KAccelBase::setActionSlot( " << sAction << ", " << pObjSlot << ", " << psMethodSlot << " )\n";
+	KAccelAction* pAction = m_rgActions.actionPtr( sAction );
+	if( pAction ) {
+		// If there was a previous connection, remove it.
+		if( m_bAutoUpdate && pAction->isConnected() ) {
+			kdDebug(125) << "\tm_pObjSlot = " << pAction->m_pObjSlot << " m_psMethodSlot = " << pAction->m_psMethodSlot << endl;
+			removeConnection( pAction );
+		}
+
+		pAction->m_pObjSlot = pObjSlot;
+		pAction->m_psMethodSlot = psMethodSlot;
+
+		// If we're setting a connection,
+		if( m_bAutoUpdate && pObjSlot && psMethodSlot )
+			insertConnection( pAction );
+
+		return true;
+	} else
+		return false;
+}
+
+/*
+KAccelBase
+	Run Command=Meta+Enter;Alt+F2
+	KAccelAction = "Run Command"
+		1) KAccelKeySeries = "Meta+Enter"
+			1a) Meta+Enter
+			1b) Meta+Keypad_Enter
+		2) KAccelKeySeries = "Alt+F2"
+			1a) Alt+F2
+
+	Konqueror=Meta+I,I
+	KAccelAction = "Konqueror"
+		1) KAccelKeySeries = "Meta+I,I"
+			1a) Meta+I
+			2a) I
+
+	Something=Meta+Asterisk,X
+	KAccelAction = "Something"
+		1) KAccelKeySeries = "Meta+Asterisk,X"
+			1a) Meta+Shift+8
+			1b) Meta+Keypad_8
+			2a) X
+
+read in a config entry
+	split by ';'
+	find key sequences to disconnect
+	find new key sequences to connect
+check for conflicts with implicit keys
+	disconnect conflicting implicit keys
+connect new key sequences
+*/
+/*
+{
+	For {
+		for( KAccelAction::iterator itAction = m_rgActions.begin(); itAction != m_rgActions.end(); ++itAction ) {
+			KAccelAction& action = *itAction;
+			for( KAccelSeries::iterator itSeries = action.m_rgSeries.begin(); itSeries != action.m_rgSeries.end(); ++itSeries ) {
+				KAccelSeries& series = *itSeries;
+				if(
+			}
+		}
+	}
+	Sort by: iVariation, iSequence, iSeries, iAction
+
+	1) KAccelAction = "Run Command"
+		1) KAccelKeySeries = "Meta+Enter"
+			1a) Meta+Enter
+			1b) Meta+Keypad_Enter
+		2) KAccelKeySeries = "Alt+F2"
+			1a) Alt+F2
+
+	2) KAccelAction = "Enter Calculation"
+		1) KAccelKeySeries = "Meta+Keypad_Enter"
+			1a) Meta+Keypad_Enter
+
+	List =
+		Meta+Enter		-> 1, 1, 1a
+		Meta+Keypad_Enter	-> 2, 1, 1a
+		Alt+F2			-> 1, 2, 1a
+		[Meta+Keypad_Enter]	-> [1, 1, 1b]
+
+}
+*/
+
+#ifdef Q_WS_X11
+struct KAccelBase::X
+{
+	uint iAction, iSeq, iVari;
+	KKeyServer::Key key;
+
+	X() {}
+	X( uint _iAction, uint _iSeq, uint _iVari, const KKeyServer::Key& _key )
+		{ iAction = _iAction; iSeq = _iSeq; iVari = _iVari; key = _key; }
+
+	int compare( const X& x )
+	{
+		int n = key.compare( x.key );
+		if( n != 0 )           return n;
+		if( iVari != x.iVari ) return iVari - x.iVari;
+		if( iSeq != x.iSeq )   return iSeq - x.iSeq;
+		return 0;
+	}
+
+	bool operator <( const X& x )  { return compare( x ) < 0; }
+	bool operator >( const X& x )  { return compare( x ) > 0; }
+	bool operator <=( const X& x ) { return compare( x ) <= 0; }
+};
+#endif //Q_WS_X11
+
+/*
+#1 Ctrl+A
+#2 Ctrl+A
+#3 Ctrl+B
+   ------
+   Ctrl+A => Null
+   Ctrl+B => #3
+
+#1 Ctrl+A
+#1 Ctrl+B;Ctrl+A
+   ------
+   Ctrl+A => #1
+   Ctrl+B => #2
+
+#1 Ctrl+A
+#1 Ctrl+B,C
+#1 Ctrl+B,D
+   ------
+   Ctrl+A => #1
+   Ctrl+B => Null
+
+#1 Ctrl+A
+#2 Ctrl+Plus(Ctrl+KP_Add)
+   ------
+   Ctrl+A => #1
+   Ctrl+Plus => #2
+   Ctrl+KP_Add => #2
+
+#1 Ctrl+Plus(Ctrl+KP_Add)
+#2 Ctrl+KP_Add
+   ------
+   Ctrl+Plus => #1
+   Ctrl+KP_Add => #2
+
+#1 Ctrl+Plus(Ctrl+KP_Add)
+#2 Ctrl+A;Ctrl+KP_Add
+   ------
+   Ctrl+A => #2
+   Ctrl+Plus => #1
+   Ctrl+KP_Add => #2
+*/
+
+bool KAccelBase::updateConnections()
+{
+#ifdef Q_WS_X11
+	kdDebug(125) << "KAccelBase::updateConnections()  this = " << this << endl;
+	// Retrieve the list of keys to be connected, sorted by priority.
+	//  (key, variation, seq)
+	QValueVector<X> rgKeys;
+	createKeyList( rgKeys );
+	m_rgActionsNonUnique.clear();
+
+	KKeyToActionMap mapKeyToAction;
+	for( uint i = 0; i < rgKeys.size(); i++ ) {
+		X& x = rgKeys[i];
+		KKeyServer::Key& key = x.key;
+		ActionInfo info;
+		bool bNonUnique = false;
+
+		info.pAction = m_rgActions.actionPtr( x.iAction );
+		info.iSeq = x.iSeq;
+		info.iVariation = x.iVari;
+
+		// If this is a multi-key shortcut,
+		if( info.pAction->shortcut().seq(info.iSeq).count() > 1 )
+			bNonUnique = true;
+		// If this key is requested by more than one action,
+		else if( i < rgKeys.size() - 1 && key == rgKeys[i+1].key ) {
+			// If multiple actions requesting this key
+			//  have the same priority as the first one,
+			if( info.iVariation == rgKeys[i+1].iVari && info.iSeq == rgKeys[i+1].iSeq )
+				bNonUnique = true;
+
+			kdDebug(125) << "key conflict = " << key.key().toStringInternal()
+				<< " action1 = " << info.pAction->name()
+				<< " action2 = " << m_rgActions.actionPtr( rgKeys[i+1].iAction )->name()
+				<< " non-unique = " << bNonUnique << endl;
+
+			// Skip over the other records with this same key.
+			while( i < rgKeys.size() - 1 && key == rgKeys[i+1].key )
+				i++;
+		}
+
+		if( bNonUnique ) {
+			// Remove connection to single action if there is one
+			if( m_mapKeyToAction.contains( key ) ) {
+				KAccelAction* pAction = m_mapKeyToAction[key].pAction;
+				if( pAction ) {
+					m_mapKeyToAction.remove( key );
+					disconnectKey( *pAction, key );
+					pAction->decConnections();
+					m_rgActionsNonUnique.append( pAction );
+				}
+			}
+			// Indicate that no single action is associated with this key.
+			m_rgActionsNonUnique.append( info.pAction );
+			info.pAction = 0;
+		}
+
+		//kdDebug(125) << "mapKeyToAction[" << key.toStringInternal() << "] = " << info.pAction << endl;
+		mapKeyToAction[key] = info;
+	}
+
+	// Disconnect keys which no longer have bindings:
+	for( KKeyToActionMap::iterator it = m_mapKeyToAction.begin(); it != m_mapKeyToAction.end(); ++it ) {
+		const KKeyServer::Key& key = it.key();
+		KAccelAction* pAction = (*it).pAction;
+		// If this key is longer used or it points to a different action now,
+		if( !mapKeyToAction.contains( key ) || mapKeyToAction[key].pAction != pAction ) {
+			if( pAction ) {
+				disconnectKey( *pAction, key );
+				pAction->decConnections();
+			} else
+				disconnectKey( key );
+		}
+	}
+
+	// Connect any unconnected keys:
+	// In other words, connect any keys which are present in the
+	//  new action map, but which are _not_ present in the old one.
+	for( KKeyToActionMap::iterator it = mapKeyToAction.begin(); it != mapKeyToAction.end(); ++it ) {
+		const KKeyServer::Key& key = it.key();
+		KAccelAction* pAction = (*it).pAction;
+		if( !m_mapKeyToAction.contains( key ) || m_mapKeyToAction[key].pAction != pAction ) {
+			// TODO: Decide what to do if connect fails.
+			//  Probably should remove this item from map.
+			if( pAction ) {
+				if( connectKey( *pAction, key ) )
+					pAction->incConnections();
+			} else
+				connectKey( key );
+		}
+	}
+
+	// Store new map.
+	m_mapKeyToAction = mapKeyToAction;
+
+#ifndef NDEBUG
+	for( KKeyToActionMap::iterator it = m_mapKeyToAction.begin(); it != m_mapKeyToAction.end(); ++it ) {
+		kdDebug(125) << "Key: " << it.key().key().toStringInternal() << " => '"
+			<< (((*it).pAction) ? (*it).pAction->name() : QString::null) << "'" << endl;
+	}
+#endif
+#endif //Q_WS_X11
+	return true;
+}
+
+#ifdef Q_WS_X11
+// Construct a list of keys to be connected, sorted highest priority first.
+void KAccelBase::createKeyList( QValueVector<struct X>& rgKeys )
+{
+	//kdDebug(125) << "KAccelBase::createKeyList()" << endl;
+	if( !isEnabledInternal())
+		return;
+
+	// create the list
+	// For each action
+	for( uint iAction = 0; iAction < m_rgActions.count(); iAction++ ) {
+		KAccelAction* pAction = m_rgActions.actionPtr( iAction );
+		if( pAction && pAction->m_pObjSlot && pAction->m_psMethodSlot && pAction != mtemp_pActionRemoving ) {
+			// For each key sequence associated with action
+			for( uint iSeq = 0; iSeq < pAction->shortcut().count(); iSeq++ ) {
+				const KKeySequence& seq = pAction->shortcut().seq(iSeq);
+				if( seq.count() > 0 ) {
+					KKeyServer::Variations vars;
+					vars.init( seq.key(0), !m_bNativeKeys );
+					for( uint iVari = 0; iVari < vars.count(); iVari++ ) {
+						if( vars.key(iVari).code() && vars.key(iVari).sym() )
+							rgKeys.push_back( X( iAction, iSeq, iVari, vars.key( iVari ) ) );
+						//kdDebug(125) << "\t" << pAction->name() << ": " << vars.key(iVari).toStringInternal() << endl;
+					}
+				}
+				//else
+				//	kdDebug(125) << "\t*" << pAction->name() << ":" << endl;
+			}
+		}
+	}
+
+	// sort by priority: iVariation[of first key], iSequence, iAction
+	qHeapSort( rgKeys.begin(), rgKeys.end() );
+}
+#endif //Q_WS_X11
+
+bool KAccelBase::insertConnection( KAccelAction* pAction )
+{
+	if( !pAction->m_pObjSlot || !pAction->m_psMethodSlot )
+		return true;
+
+	kdDebug(125) << "KAccelBase::insertConnection( " << pAction << "=\"" << pAction->m_sName << "\"; shortcut = " << pAction->shortcut().toStringInternal() << " )  this = " << this << endl;
+
+	// For each sequence associated with the given action:
+	for( uint iSeq = 0; iSeq < pAction->shortcut().count(); iSeq++ ) {
+		// Get the first key of the sequence.
+		KKeyServer::Variations vars;
+		vars.init( pAction->shortcut().seq(iSeq).key(0), !m_bNativeKeys );
+		for( uint iVari = 0; iVari < vars.count(); iVari++ ) {
+			const KKeyServer::Key& key = vars.key( iVari );
+
+			//if( !key.isNull() ) {
+			if( key.sym() ) {
+				if( !m_mapKeyToAction.contains( key ) ) {
+					// If this is a single-key shortcut,
+					if( pAction->shortcut().seq(iSeq).count() == 1 ) {
+						m_mapKeyToAction[key] = ActionInfo( pAction, iSeq, iVari );
+						if( connectKey( *pAction, key ) )
+							pAction->incConnections();
+					}
+					// Else this is a multi-key shortcut,
+					else {
+						m_mapKeyToAction[key] = ActionInfo( 0, 0, 0 );
+						// Insert into non-unique list if it's not already there.
+						if( m_rgActionsNonUnique.findIndex( pAction ) == -1 )
+							m_rgActionsNonUnique.append( pAction );
+						if( connectKey( key ) )
+							pAction->incConnections();
+					}
+				} else {
+					// There is a key conflict.  A full update
+					//  check is necessary.
+					// TODO: make this more efficient where possible.
+					if( m_mapKeyToAction[key].pAction != pAction
+					    && m_mapKeyToAction[key].pAction != 0 ) {
+						kdDebug(125) << "Key conflict with action = " << m_mapKeyToAction[key].pAction->name() 
+							<< " key = " << key.key().toStringInternal() << " : call updateConnections()" << endl;
+						return updateConnections();
+					}
+				}
+			}
+		}
+	}
+
+	//kdDebug(125) << "\tActions = " << m_rgActions.size() << endl;
+	//for( KAccelActions::const_iterator it = m_rgActions.begin(); it != m_rgActions.end(); ++it ) {
+	//	kdDebug(125) << "\t" << &(*it) << " '" << (*it).m_sName << "'" << endl;
+	//}
+
+	//kdDebug(125) << "\tKeys = " << m_mapKeyToAction.size() << endl;
+	//for( KKeyToActionMap::iterator it = m_mapKeyToAction.begin(); it != m_mapKeyToAction.end(); ++it ) {
+	//	//kdDebug(125) << "\tKey: " << it.key().toString() << " => '" << (*it)->m_sName << "'" << endl;
+	//	kdDebug(125) << "\tKey: " << it.key().toString() << " => '" << *it << "'" << endl;
+	//	kdDebug(125) << "\t\t'" << (*it)->m_sName << "'" << endl;
+	//}
+
+	return true;
+}
+
+bool KAccelBase::removeConnection( KAccelAction* pAction )
+{
+	kdDebug(125) << "KAccelBase::removeConnection( " << pAction << " = \"" << pAction->m_sName << "\"; shortcut = " << pAction->m_cut.toStringInternal() << " ): this = " << this << endl;
+
+	//for( KKeyToActionMap::iterator it = m_mapKeyToAction.begin(); it != m_mapKeyToAction.end(); ++it )
+	//	kdDebug(125) << "\tKey: " << it.key().toString() << " => '" << (*it)->m_sName << "'" << " " << *it << endl;
+
+	if( m_rgActionsNonUnique.findIndex( pAction ) >= 0 ) {
+		mtemp_pActionRemoving = pAction;
+		bool b = updateConnections();
+		mtemp_pActionRemoving = 0;
+		return b;
+	}
+
+	KKeyToActionMap::iterator it = m_mapKeyToAction.begin();
+	while( it != m_mapKeyToAction.end() ) {
+		KKeyServer::Key key = it.key();
+		ActionInfo* pInfo = &(*it);
+
+		// If the given action is connected to this key,
+		if( pAction == pInfo->pAction ) {
+			disconnectKey( *pAction, key );
+			pAction->decConnections();
+
+			KKeyToActionMap::iterator itRemove = it++;
+			m_mapKeyToAction.remove( itRemove );
+		} else
+			++it;
+	}
+	return true;
+}
+
+bool KAccelBase::setShortcut( const QString& sAction, const KShortcut& cut )
+{
+	KAccelAction* pAction = actionPtr( sAction );
+	if( pAction ) {
+		if( m_bAutoUpdate )
+			removeConnection( pAction );
+
+		pAction->setShortcut( cut );
+
+		if( m_bAutoUpdate && !pAction->shortcut().isNull() )
+			insertConnection( pAction );
+		return true;
+	} else
+		return false;
+}
+
+void KAccelBase::readSettings( KConfigBase* pConfig )
+{
+	m_rgActions.readActions( m_sConfigGroup, pConfig );
+	if( m_bAutoUpdate )
+		updateConnections();
+}
+
+void KAccelBase::writeSettings( KConfigBase* pConfig ) const
+{
+	m_rgActions.writeActions( m_sConfigGroup, pConfig, m_bConfigIsGlobal, m_bConfigIsGlobal );
+}
+
+QPopupMenu* KAccelBase::createPopupMenu( QWidget* pParent, const KKeySequence& seq )
+{
+	KShortcutMenu* pMenu = new KShortcutMenu( pParent, &actions(), seq );
+
+	bool bActionInserted = false;
+	bool bInsertSeparator = false;
+	for( uint i = 0; i < actionCount(); i++ ) {
+		const KAccelAction* pAction = actions().actionPtr( i );
+
+		if( !pAction->isEnabled() )
+			continue;
+
+		// If an action has already been inserted into the menu
+		//  and we have a label instead of an action here,
+		//  then indicate that we should insert a separator before the next menu entry.
+		if( bActionInserted && !pAction->isConfigurable() && pAction->name().contains( ':' ) )
+			bInsertSeparator = true;
+
+		for( uint iSeq = 0; iSeq < pAction->shortcut().count(); iSeq++ ) {
+			const KKeySequence& seqAction = pAction->shortcut().seq(iSeq);
+			if( seqAction.startsWith( seq ) ) {
+				if( bInsertSeparator ) {
+					pMenu->insertSeparator();
+					bInsertSeparator = false;
+				}
+
+				pMenu->insertAction( i, seqAction );
+
+				//kdDebug(125) << "sLabel = " << sLabel << ", seq = " << (QString)seqMenu.qt() << ", i = " << i << endl;
+				//kdDebug(125) << "pMenu->accel(" << i << ") = " << (QString)pMenu->accel(i) << endl;
+				bActionInserted = true;
+				break;
+			}
+		}
+	}
+	pMenu->updateShortcuts();
+	return pMenu;
+}