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/kdebindings@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

13 files changed, 3465 insertions, 0 deletions

diff --git a/python/pykde/extra/kde331/configwidget.h b/python/pykde/extra/kde331/configwidget.h
new file mode 100644
index 00000000..4eb9c4f9
--- /dev/null
+++ b/python/pykde/extra/kde331/configwidget.h
@@ -0,0 +1,58 @@
+/*
+    This file is part of libkresources.
+    Copyright (c) 2002 Tobias Koenig <tokoe@kde.org>
+    Copyright (c) 2002 Jan-Pascal van Best <janpascal@vanbest.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., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+
+#ifndef KRESOURCES_CONFIGWIDGET_H
+#define KRESOURCES_CONFIGWIDGET_H
+
+#include "resource.h"
+
+#include <kconfig.h>
+
+#include <qwidget.h>
+
+namespace KRES {
+
+class ConfigWidget : public QWidget
+{
+    Q_OBJECT
+  public:
+    ConfigWidget( QWidget *parent = 0, const char *name = 0 );
+
+    /**
+      Sets the widget to 'edit' mode. Reimplement this method if you are
+      interested in the mode change (to disable some GUI element for
+      example). By default the widget is in 'create new' mode.
+    */
+    virtual void setInEditMode( bool value );
+
+  public slots:
+    virtual void loadSettings( Resource *resource ) = 0;
+    virtual void saveSettings( Resource *resource ) = 0;
+
+  signals:
+    void setReadOnly( bool value );
+
+  protected:
+    Resource *mResource;
+};
+
+}
+#endif
diff --git a/python/pykde/extra/kde331/kaccelaction.h b/python/pykde/extra/kde331/kaccelaction.h
new file mode 100644
index 00000000..30823a88
--- /dev/null
+++ b/python/pykde/extra/kde331/kaccelaction.h
@@ -0,0 +1,564 @@
+/* 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., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+
+#ifndef _KACCELACTION_H
+#define _KACCELACTION_H
+
+#include <qmap.h>
+#include <qptrvector.h>
+#include <qstring.h>
+#include <qvaluevector.h>
+
+#include <kshortcut.h>
+
+class KAccelBase;
+
+class QObject;
+class KConfig;
+class KConfigBase;
+
+/**
+ * @internal
+ * A KAccelAction prepresents an action that can be executed using 
+ * an accelerator key. Each KAccelAction has a name, a label, a 
+ * "What's this" string and a KShortcut. The user can configure and 
+ * enable/disable them using KKeyDialog. 
+ *
+ * \code
+ *	1) KAccelAction = "Run Command"
+ *		Default3 = "Alt+F2"
+ *		Default4 = "Meta+Enter;Alt+F2"
+ *		1) KShortcut = "Meta+Enter"
+ *			1) KKeySequence = "Meta+Enter"
+ *				1) KKey = "Meta+Enter"
+ *					1) Meta+Enter
+ *					2) Meta+Keypad_Enter
+ *		2) KShortcut = "Alt+F2"
+ *			1) KKeySequence = "Alt+F2"
+ *				1) Alt+F2
+ *	2) KAccelAction = "Something"
+ *		Default3 = ""
+ *		Default4 = ""
+ *		1) KShortcut = "Meta+X,Asterisk"
+ *			1) KKeySequence = "Meta+X,Asterisk"
+ *				1) KKey = "Meta+X"
+ *					1) Meta+X
+ *				2) KKey = "Asterisk"
+ *					1) Shift+8 (English layout)
+ *					2) Keypad_Asterisk
+ * \endcode
+ * @short An accelerator action
+ * @see KAccel
+ * @see KGlobalAccel
+ * @see KKeyChooser
+ * @see KKeyDialog
+ */
+class KAccelAction
+{
+ public:
+        /**
+	 * Creates an empty KAccelAction.
+	 * @see clear()
+	 */
+	KAccelAction();
+
+	/**
+	 * Copy constructor.
+	 */
+	KAccelAction( const KAccelAction& );
+
+	/**
+	 * Creates a new KAccelAction.
+	 * @param sName the name of the accelerator
+	 * @param sLabel the label of the accelerator (i18n!)
+	 * @param sWhatsThis the What's This text (18n!)
+	 * @param cutDef3 the default shortcut for 3 modifier systems
+	 * @param cutDef4 the default shortcut for 4 modifier systems
+	 * @param pObjSlot the receiver of a signal when the key has been 
+	 *                 pressed
+	 * @param psMethodSlot the slot to connect for key presses. Receives
+	 *                     an int, as set by setID(), as only argument
+	 * @param bConfigurable if true the user can configure the shortcut
+	 * @param bEnabled true if the accelerator should be enabled
+	 */
+	KAccelAction( const QString& sName, const QString& sLabel, const QString& sWhatsThis,
+			const KShortcut& cutDef3, const KShortcut& cutDef4,
+			const QObject* pObjSlot, const char* psMethodSlot,
+			bool bConfigurable, bool bEnabled );
+	~KAccelAction();
+
+	/**
+	 * Clears the accelerator.
+	 */
+	void clear();
+
+	/**
+	 * Re-initialized the KAccelAction.
+	 * @param sName the name of the accelerator
+	 * @param sLabel the label of the accelerator (i18n!)
+	 * @param sWhatsThis the What's This text (18n!)
+	 * @param cutDef3 the default shortcut for 3 modifier systems
+	 * @param cutDef4 the default shortcut for 4 modifier systems
+	 * @param pObjSlot the receiver of a signal when the key has been 
+	 *                 pressed
+	 * @param psMethodSlot the slot to connect for key presses. Receives
+	 *                     an int, as set by setID(), as only argument
+	 * @param bConfigurable if true the user can configure the shortcut
+	 * @param bEnabled true if the accelerator should be enabled
+	 * @return true if successful, false otherwise
+	 */
+	bool init( const QString& sName, const QString& sLabel, const QString& sWhatsThis,
+			const KShortcut& cutDef3, const KShortcut& cutDef4,
+			const QObject* pObjSlot, const char* psMethodSlot,
+			bool bConfigurable, bool bEnabled );
+
+	/**
+	 * Copies this KAccelAction.
+	 */
+	KAccelAction& operator=( const KAccelAction& );
+
+	/**
+	 * Returns the name of the accelerator action.
+	 * @return the name of the accelerator action, can be null if not 
+	 *         set
+	 */
+	const QString& name() const                { return m_sName; }
+
+	/**
+	 * Returns the label of the accelerator action.
+	 * @return the label of the accelerator action, can be null if
+	 *         not set
+	 */
+	const QString& label() const               { return m_sLabel; }
+
+	/**
+	 * Returns the What's This text of the accelerator action.
+	 * @return the What's This text of the accelerator action, can be
+	 *         null if not set
+	 */
+	const QString& whatsThis() const           { return m_sWhatsThis; }
+	
+	/**
+	 * The shortcut that is actually used (may be used configured).
+	 * @return the shortcut of the KAccelAction, can be null if not set
+	 * @see shortcutDefault()
+	 */
+	const KShortcut& shortcut() const          { return m_cut; }
+
+	/**
+	 * The default shortcut for this system.
+	 * @return the default shortcut on this system, can be null if not set
+	 * @see shortcut()
+	 * @see shortcutDefault3()
+	 * @see shortcutDefault4()
+	 */
+	const KShortcut& shortcutDefault() const;
+
+	/**
+	 * The default shortcut for 3 modifier systems.
+	 * @return the default shortcut for 3 modifier systems, can be null
+	 *           if not set
+	 * @see shortcutDefault()
+	 * @see shortcutDefault4()
+	 * @see useFourModifierKeys()
+	 */
+	const KShortcut& shortcutDefault3() const  { return m_cutDefault3; }
+
+	/**
+	 * The default shortcut for 4 modifier systems.
+	 * @return the default shortcut for 4 modifier systems, can be null 
+	 *         if not set
+	 * @see shortcutDefault()
+	 * @see shortcutDefault3()
+	 * @see useFourModifierKeys()
+	 */
+	const KShortcut& shortcutDefault4() const  { return m_cutDefault4; }
+
+	/**
+	 * Returns the receiver of signals.
+	 * @return the receiver of signals (can be 0 if not set)
+	 */
+	const QObject* objSlotPtr() const          { return m_pObjSlot; }
+
+	/**
+	 * Returns the slot for the signal.
+	 * @return the slot for the signal
+	 */
+	const char* methodSlotPtr() const          { return m_psMethodSlot; }
+
+	/**
+	 * Checks whether the user can configure the action.
+	 * @return true if configurable, false otherwise
+	 */
+	bool isConfigurable() const                { return m_bConfigurable; }
+
+	/**
+	 * Checks whether the action is enabled.
+	 * @return true if enabled, false otherwise
+	 */
+	bool isEnabled() const                     { return m_bEnabled; }
+
+	/**
+	 * Sets the name of the accelerator action.
+	 * @param name the new name
+	 */
+	void setName( const QString& name );
+
+	/**
+	 * Sets the user-readable label of the accelerator action.
+	 * @param label the new label (i18n!)
+	 */
+	void setLabel( const QString& label );
+
+	/**
+	 * Sets the What's This text for the accelerator action.
+	 * @param whatsThis the new What's This text (i18n!)
+	 */
+	void setWhatsThis( const QString& whatsThis );
+
+	/**
+	 * Sets the new shortcut of the accelerator action.
+	 * @param rgCuts the shortcut to set
+	 * @return true if successful, false otherwise
+	 */
+	bool setShortcut( const KShortcut& rgCuts );
+
+	/**
+	 * Sets the slot of the accelerator action.
+	 * @param pObjSlot the receiver object of the signal
+	 * @param psMethodSlot the slot for the signal
+	 */
+	void setSlot( const QObject* pObjSlot, const char* psMethodSlot );
+
+	/**
+	 * Enables or disabled configuring the action.
+	 * @param configurable true to enable configurability, false to disable
+	 */
+	void setConfigurable( bool configurable );
+
+	/**
+	 * Enables or disabled the action.
+	 * @param configurable true to enable the action, false to disable
+	 */
+	void setEnabled( bool enable );
+
+	/**
+	 * Retrieves the id set using setID.
+	 * @return the id of the accelerator action
+	 */
+	int getID() const   { return m_nIDAccel; }
+
+	/**
+	 * Allows you to set an id that will be used as the action 
+	 * signal's argument.
+	 *
+	 * @param n the new id
+	 * @see getID()
+	 */
+	void setID( int n ) { m_nIDAccel = n; }
+
+	/**
+	 * Checkes whether the action is connected (emits signals).
+	 * @return true if connected, false otherwise
+	 */
+	bool isConnected() const;
+
+	/**
+	 * Sets a key sequence of the action's shortcut.
+	 * @param i the position of the sequence
+	 * @param keySeq the new new sequence
+	 * @return true if successful, false otherwise
+	 * @see KShortcut::setSeq()
+	 */
+	bool setKeySequence( uint i, const KKeySequence &keySeq );
+	
+	/**
+	 * Clears the action's shortcut. It will not contain any sequences after
+	 * calling this method.
+	 * @see KShortcut::clear()
+	 */
+	void clearShortcut();
+	
+	/**
+	 * Checks whether the action's shortcut contains the given key sequence.
+	 * @param keySeq the key sequence to check
+	 * @return true if the shortcut contains the given sequence
+	 * @see KShortcut::contains()
+	 */
+	bool contains( const KKeySequence &keySeq );
+
+	/**
+	 * Returns the string representation of the action's shortcut.
+	 * @return the string representation of the action's shortcut.
+	 * @see KShortcut::toString()
+	 */
+	QString toString() const;
+
+	/**
+	 * @internal
+	 */
+	QString toStringInternal() const;
+
+	/**
+	 * Returns true if four modifier keys will be used.
+	 * @return true if four modifier keys will be used.
+	 */
+	static bool useFourModifierKeys();
+
+	/**
+	 * Selects 3 or 4 modifier default shortcuts.
+	 * @param use true to use 4 modifier shortcuts, false to use
+	 *            3 modifier shortcuts
+	 */
+	static void useFourModifierKeys( bool use );
+
+ protected:
+	QString m_sName,
+	        m_sLabel,
+	        m_sWhatsThis;
+	KShortcut m_cut;
+	KShortcut m_cutDefault3, m_cutDefault4;
+	const QObject* m_pObjSlot;
+	const char* m_psMethodSlot;
+	bool m_bConfigurable,
+	     m_bEnabled;
+	int m_nIDAccel;
+	uint m_nConnections;
+
+	void incConnections();
+	void decConnections();
+
+ private:
+	static int g_bUseFourModifierKeys;
+	class KAccelActionPrivate* d;
+
+	friend class KAccelActions;
+	friend class KAccelBase;
+};
+
+//---------------------------------------------------------------------
+// KAccelActions
+//---------------------------------------------------------------------
+
+/**
+ * @internal
+ * This class represents a collection of KAccelAction objects.
+ *
+ * @short A collection of accelerator actions
+ * @see KAccelAction
+ */
+class KAccelActions
+{
+ public:
+       /**
+	* Creates a new, empty KAccelActions object.
+	*/
+	KAccelActions();
+
+	/**
+	 * Copy constructor (deep copy).
+	 */
+	KAccelActions( const KAccelActions& );
+	virtual ~KAccelActions();
+
+	/**
+	 * Removes all items from this collection.
+	 */
+	void clear();
+
+	/**
+	 * Initializes this object with the given actions.
+	 * It will make a deep copy of all actions.
+	 * @param actions the actions to copy
+	 * @return true if successful, false otherwise
+	 */
+	bool init( const KAccelActions &actions );
+
+	/**
+	 * Loads the actions from the given configuration file.
+	 *
+	 * @param config the configuration file to load from
+	 * @param sGroup the group in the configuration file
+	 * @return true if successful, false otherwise
+	 */
+	bool init( KConfigBase& config, const QString& sGroup );
+
+	/**
+	 * Updates the shortcuts of all actions in this object
+	 * with the shortcuts from the given object.
+	 * @param shortcuts the collection that contains the new
+	 *        shortcuts
+	 */
+	void updateShortcuts( KAccelActions &shortcuts );
+
+	/**
+	 * Retrieves the index of the action with the given name.
+	 * @param sAction the action to search
+	 * @return the index of the action, or -1 if not found
+	 */
+	int actionIndex( const QString& sAction ) const;
+
+	/**
+	 * Returns the action with the given @p index.
+	 * @param index the index of an action. You must not
+	 *         use an index that is too high.
+	 * @return the KAccelAction with the given index
+	 * @see count()
+	 */
+	KAccelAction* actionPtr( uint index );
+
+	/**
+	 * Returns the action with the given @p index.
+	 * @param index the index of an action. You must not
+	 *         use an index that is too high.
+	 * @return the KAccelAction with the given index
+	 * @see count()
+	 */
+	const KAccelAction* actionPtr( uint index ) const;
+
+	/**
+	 * Returns the action with the given name.
+	 * @param aAction the name of the action to search
+	 * @return the KAccelAction with the given name, or 0
+	 *          if not found
+	 */
+	KAccelAction* actionPtr( const QString& sAction );
+
+	/**
+	 * Returns the action with the given name.
+	 * @param aAction the name of the action to search
+	 * @return the KAccelAction with the given name, or 0
+	 *          if not found
+	 */
+	const KAccelAction* actionPtr( const QString& sAction ) const;
+
+	/**
+	 * Returns the action with the given key sequence.
+	 * @param cut the sequence to search for
+	 * @return the KAccelAction with the given sequence, or 0
+	 *          if not found
+	 */
+	KAccelAction* actionPtr( KKeySequence cut );
+
+	/**
+	 * Returns the action with the given @p index.
+	 * @param index the index of an action. You must not
+	 *         use an index that is too high.
+	 * @return the KAccelAction with the given index
+	 * @see actionPtr()
+	 * @see count()
+	 */
+	KAccelAction& operator []( uint index );
+
+	/**
+	 * Returns the action with the given @p index.
+	 * @param index the index of an action. You must not
+	 *         use an index that is too high.
+	 * @return the KAccelAction with the given index
+	 * @see actionPtr()
+	 * @see count()
+	 */
+	const KAccelAction& operator []( uint index ) const;
+
+	/**
+	 * Inserts an action into the collection.
+	 * @param sName the name of the accelerator
+	 * @param sLabel the label of the accelerator (i18n!)
+	 * @param sWhatsThis the What's This text (18n!)
+	 * @param cutDef3 the default shortcut for 3 modifier systems
+	 * @param cutDef4 the default shortcut for 4 modifier systems
+	 * @param pObjSlot the receiver of a signal when the key has been 
+	 *                 pressed
+	 * @param psMethodSlot the slot to connect for key presses. Receives
+	 *                     an int, as set by setID(), as only argument
+	 * @param bConfigurable if true the user can configure the shortcut
+	 * @param bEnabled true if the accelerator should be enabled
+	 * @return the new action
+	 */
+	KAccelAction* insert( const QString& sAction, const QString& sLabel, const QString& sWhatsThis,
+			const KShortcut& rgCutDefaults3, const KShortcut& rgCutDefaults4,
+			const QObject* pObjSlot = 0, const char* psMethodSlot = 0,
+			bool bConfigurable = true, bool bEnabled = true );
+
+	/**
+	 * Inserts an action into the collection.
+	 * @param sName the name of the accelerator
+	 * @param sLabel the label of the accelerator (i18n!)
+	 * @return the new action
+	 */
+	KAccelAction* insert( const QString& sName, const QString& sLabel );
+
+	/**
+	 * Removes the given action.
+	 * @param sAction the name of the action.
+	 * @return true if successful, false otherwise
+	 */
+	bool remove( const QString& sAction );
+
+	/**
+	 * Loads the actions from the given configuration file.
+	 *
+	 * @param sConfigGroup the group in the configuration file
+	 * @param pConfig the configuration file to load from
+	 * @return true if successful, false otherwise
+	 */
+	bool readActions( const QString& sConfigGroup = "Shortcuts", KConfigBase* pConfig = 0 );
+
+	/**
+	 * Writes the actions to the given configuration file.
+	 *
+	 * @param sConfigGroup the group in the configuration file
+	 * @param pConfig the configuration file to save to
+	 * @param bWriteAll true to write all actions
+	 * @param bGlobal true to write to the global configuration file
+	 * @return true if successful, false otherwise
+	 */
+	bool writeActions( const QString& sConfigGroup = "Shortcuts", KConfigBase* pConfig = 0,
+			bool bWriteAll = false, bool bGlobal = false ) const;
+
+	/**
+	 * Emit a keycodeChanged signal.
+	 */
+	void emitKeycodeChanged();
+
+	/**
+	 * Returns the number of actions in the collection.
+	 * @return the number of actions
+	 */
+	uint count() const;
+
+ protected:
+	KAccelBase* m_pKAccelBase;
+	KAccelAction** m_prgActions;
+	uint m_nSizeAllocated, m_nSize;
+
+	void resize( uint );
+	void insertPtr( KAccelAction* );
+
+ private:
+	class KAccelActionsPrivate* d;
+
+	KAccelActions( KAccelBase* );
+	void initPrivate( KAccelBase* );
+	KAccelActions& operator =( KAccelActions& );
+
+	friend class KAccelBase;
+};
+
+#endif // _KACCELACTION_H
diff --git a/python/pykde/extra/kde331/kaccelbase.h b/python/pykde/extra/kde331/kaccelbase.h
new file mode 100644
index 00000000..c5433e04
--- /dev/null
+++ b/python/pykde/extra/kde331/kaccelbase.h
@@ -0,0 +1,230 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 2001 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., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+
+#ifndef _KACCELBASE_H
+#define _KACCELBASE_H
+
+#include <qmap.h>
+#include <qptrvector.h>
+#include <qstring.h>
+#include <qvaluevector.h>
+#include <qvaluelist.h>
+
+#include "kaccelaction.h"
+#include "kkeyserver_x11.h"
+
+class QPopupMenu;
+class QWidget;
+
+//----------------------------------------------------
+
+/**
+ * @internal
+ * Handle keyboard accelerators.
+ *
+ * Allow an user to configure
+ * key bindings through application configuration files or through the
+ * KKeyChooser GUI.
+ *
+ * A KAccel contains a list of accelerator items. Each accelerator item
+ * consists of an action name and a keyboard code combined with modifiers
+ * (Shift, Ctrl and Alt.)
+ *
+ * For example, "Ctrl+P" could be a shortcut for printing a document. The key
+ * codes are listed in ckey.h. "Print" could be the action name for printing.
+ * The action name identifies the key binding in configuration files and the
+ * KKeyChooser GUI.
+ *
+ * When pressed, an accelerator key calls the slot to which it has been
+ * connected. Accelerator items can be connected so that a key will activate
+ * two different slots.
+ *
+ * A KAccel object handles key events sent to its parent widget and to all
+ * children of this parent widget.
+ *
+ * Key binding reconfiguration during run time can be prevented by specifying
+ * that an accelerator item is not configurable when it is inserted. A special
+ * group of non-configurable key bindings are known as the
+ * standard accelerators.
+ *
+ * The standard accelerators appear repeatedly in applications for
+ * standard document actions such as printing and saving. Convenience methods are
+ * available to insert and connect these accelerators which are configurable on
+ * a desktop-wide basis.
+ *
+ * It is possible for a user to choose to have no key associated with
+ * an action.
+ *
+ * The translated first argument for insertItem() is used only
+ * in the configuration dialog.
+ *\code
+ * KAccel *a = new KAccel( myWindow );
+ * // Insert an action "Scroll Up" which is associated with the "Up" key:
+ * a->insertItem( i18n("Scroll Up"), "Scroll Up", "Up" );
+ * // Insert an action "Scroll Down" which is not associated with any key:
+ * a->insertItem( i18n("Scroll Down"), "Scroll Down", 0);
+ * a->connectItem( "Scroll up", myWindow, SLOT( scrollUp() ) );
+ * // a->insertStdItem( KStdAccel::Print ); //not necessary, since it
+ *	// is done automatially with the
+ *	// connect below!
+ * a->connectItem(KStdAccel::Print, myWindow, SLOT( printDoc() ) );
+ *
+ * a->readSettings();
+ *\endcode
+ *
+ * If a shortcut has a menu entry as well, you could insert them like
+ * this. The example is again the KStdAccel::Print from above.
+ *
+ * \code
+ * int id;
+ * id = popup->insertItem("&Print",this, SLOT(printDoc()));
+ * a->changeMenuAccel(popup, id, KStdAccel::Print );
+ * \endcode
+ *
+ * If you want a somewhat "exotic" name for your standard print action, like
+ *   id = popup->insertItem(i18n("Print &Document"),this, SLOT(printDoc()));
+ * it might be a good idea to insert the standard action before as
+ *          a->insertStdItem( KStdAccel::Print, i18n("Print Document") )
+ * as well, so that the user can easily find the corresponding function.
+ *
+ * This technique works for other actions as well.  Your "scroll up" function
+ * in a menu could be done with
+ *
+ * \code
+ *    id = popup->insertItem(i18n"Scroll &up",this, SLOT(scrollUp()));
+ *    a->changeMenuAccel(popup, id, "Scroll Up" );
+ * \endcode
+ *
+ * Please keep the order right:  First insert all functions in the
+ * acceleratior, then call a -> readSettings() and @em then build your
+ * menu structure.
+ *
+ * @short Configurable key binding support.
+ * @version $Id: kaccelbase.h,v 1.26 2003/08/16 19:44:57 coolo Exp $
+ */
+
+class KAccelBase
+{
+ public:
+	enum Init { QT_KEYS = 0x00, NATIVE_KEYS = 0x01 };
+	enum Signal { KEYCODE_CHANGED };
+
+	KAccelBase( int fInitCode );
+	virtual ~KAccelBase();
+
+	uint actionCount() const;
+	KAccelActions& actions();
+	bool isEnabled() const;
+
+	KAccelAction* actionPtr( const QString& sAction );
+	const KAccelAction* actionPtr( const QString& sAction ) const;
+	KAccelAction* actionPtr( const KKey& key );
+	KAccelAction* actionPtr( const KKeyServer::Key& key );
+
+	const QString& configGroup() const { return m_sConfigGroup; }
+	void setConfigGroup( const QString& group );
+	void setConfigGlobal( bool global );
+	virtual void setEnabled( bool bEnabled ) = 0;
+	bool getAutoUpdate() { return m_bAutoUpdate; }
+	// return value of AutoUpdate flag before this call.
+	bool setAutoUpdate( bool bAuto );
+
+// Procedures for manipulating Actions.
+	//void clearActions();
+
+	KAccelAction* insert( const QString& sName, const QString& sDesc );
+	KAccelAction* insert(
+	                 const QString& sAction, const QString& sDesc, const QString& sHelp,
+	                 const KShortcut& rgCutDefaults3, const KShortcut& rgCutDefaults4,
+	                 const QObject* pObjSlot, const char* psMethodSlot,
+			 bool bConfigurable = true, bool bEnabled = true );
+	bool remove( const QString& sAction );
+	bool setActionSlot( const QString& sAction, const QObject* pObjSlot, const char* psMethodSlot );
+
+	bool updateConnections();
+
+	bool setShortcut( const QString& sAction, const KShortcut& cut );
+
+// Modify individual Action sub-items
+	bool setActionEnabled( const QString& sAction, bool bEnable );
+
+	/**
+	 * Read all key associations from @p config, or (if @p config
+	 * is zero) from the application's configuration file
+	 * KGlobal::config().
+	 *
+	 * The group in which the configuration is stored can be
+	 * set with setConfigGroup().
+	 */
+	void readSettings( KConfigBase* pConfig = 0 );
+
+	/**
+	 * Write the current configurable associations to @p config,
+         * or (if @p config is zero) to the application's
+	 * configuration file.
+	 */
+	void writeSettings( KConfigBase* pConfig = 0 ) const;
+
+	QPopupMenu* createPopupMenu( QWidget* pParent, const KKeySequence& );
+
+ // Protected methods
+ protected:
+	void slotRemoveAction( KAccelAction* );
+
+	struct X;
+	void createKeyList( QValueVector<struct X>& rgKeys );
+	bool insertConnection( KAccelAction* );
+	bool removeConnection( KAccelAction* );
+
+	virtual bool emitSignal( Signal ) = 0;
+	virtual bool connectKey( KAccelAction&, const KKeyServer::Key& ) = 0;
+	virtual bool connectKey( const KKeyServer::Key& ) = 0;
+	virtual bool disconnectKey( KAccelAction&, const KKeyServer::Key& ) = 0;
+	virtual bool disconnectKey( const KKeyServer::Key& ) = 0;
+
+ protected:
+	struct ActionInfo
+	{
+		KAccelAction* pAction;
+		uint iSeq, iVariation;
+		//ActionInfo* pInfoNext; // nil if only one action uses this key.
+
+		ActionInfo() { pAction = 0; iSeq = 0xffff; iVariation = 0xffff; }
+		ActionInfo( KAccelAction* _pAction, uint _iSeq, uint _iVariation )
+			{ pAction = _pAction; iSeq = _iSeq; iVariation = _iVariation; }
+	};
+	typedef QMap<KKeyServer::Key, ActionInfo> KKeyToActionMap;
+
+	KAccelActions m_rgActions;
+	KKeyToActionMap m_mapKeyToAction;
+	QValueList<KAccelAction*> m_rgActionsNonUnique;
+	bool m_bNativeKeys; // Use native key codes instead of Qt codes
+	bool m_bEnabled;
+	bool m_bConfigIsGlobal;
+	QString m_sConfigGroup;
+	bool m_bAutoUpdate;
+	KAccelAction* mtemp_pActionRemoving;
+
+ private:
+	KAccelBase& operator =( const KAccelBase& );
+
+	friend class KAccelActions;
+};
+
+#endif // _KACCELBASE_H
diff --git a/python/pykde/extra/kde331/kicontheme.h b/python/pykde/extra/kde331/kicontheme.h
new file mode 100644
index 00000000..9569800e
--- /dev/null
+++ b/python/pykde/extra/kde331/kicontheme.h
@@ -0,0 +1,338 @@
+/* vi: ts=8 sts=4 sw=4
+ *
+ * $Id: kicontheme.h,v 1.31 2004/05/31 17:18:02 montanaro Exp $
+ *
+ * This file is part of the KDE project, module kdecore.
+ * Copyright (C) 2000 Geert Jansen <jansen@kde.org>
+ *                    Antonio Larrosa <larrosa@kde.org>
+ *
+ * This is free software; it comes under the GNU Library General
+ * Public License, version 2. See the file "COPYING.LIB" for the
+ * exact licensing terms.
+ *
+ */
+
+#ifndef __KIconTheme_h_Included__
+#define __KIconTheme_h_Included__
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qptrlist.h>
+
+class KConfig;
+//class KIconThemeDir;
+
+class KIconThemePrivate;
+
+class KIconPrivate;
+
+/**
+ * One icon as found by KIconTheme. Also serves as a namespace containing
+ * icon related constants.
+ * @see KIconEffect
+ * @see KIconTheme
+ * @see KIconLoader
+ */
+class KIcon
+{
+public:
+    KIcon() { size = 0; }
+
+    /**
+     * Return true if this icon is valid, false otherwise.
+     */
+    bool isValid() const { return size != 0; }
+
+    /**
+     * Defines the context of the icon.
+     */
+    enum Context {
+      Any, ///< Some icon with unknown purpose.
+      Action, ///< An action icon (e.g. 'save', 'print').
+      Application, ///< An icon that represents an application.
+      Device, ///< An icon that represents a device.
+      FileSystem, ///< An icon that represents a file system.
+      MimeType ///< An icon that represents a mime type (or file type).
+    };
+
+    /**
+     * The type of the icon.
+     */
+    enum Type {
+      Fixed, ///< Fixed-size icon.
+      Scalable, ///< Scalable-size icon.
+      Threshold ///< A threshold icon.
+    };
+
+    /**
+     * The type of a match.
+     */
+    enum MatchType {
+      MatchExact, ///< Only try to find an exact match.
+      MatchBest   ///< Take the best match if there is no exact match.
+
+    };
+
+    // if you add a group here, make sure to change the config reading in
+    // KIconLoader too
+    /**
+     * The group an an icon.
+     */
+    enum Group { NoGroup=-1, Desktop=0, FirstGroup=0, Toolbar,
+        MainToolbar, Small, Panel, LastGroup, User };
+
+    /**
+     * These are the standard sizes for icons.
+     */
+    enum StdSizes {
+        /// small icons for menu entries
+        SizeSmall=16,
+        /// slightly larger small icons for toolbars, panels, etc
+        SizeSmallMedium=22,
+        /// medium sized icons for the desktop
+        SizeMedium=32,
+        /// large sized icons for the panel
+        SizeLarge=48,
+        /// huge sized icons for iconviews
+        SizeHuge=64,
+        /// enormous (ugh!) sized icons for iconviews
+        SizeEnormous=128
+         };
+
+    /**
+     * Defines the possible states of an icon.
+     */
+    enum States { DefaultState, ///< The default state.
+          ActiveState,  ///< Icon is active.
+          DisabledState, ///< Icon is disabled.
+          LastState      ///< Last state (last constant)
+    };
+
+    /**
+     * This defines an overlay, a semi-transparent image that is
+     * projected onto the icon. They are used to show that the file
+     * represented by the icon is, for example, locked, zipped or hidden.
+     */
+    enum Overlays {
+      LockOverlay=0x100, ///< a file is locked
+      ZipOverlay=0x200,  ///< a file is zipped
+      LinkOverlay=0x400, ///< a fileis a link
+      HiddenOverlay=0x800, ///< a file is hidden
+      ShareOverlay=0x1000, ///< a file is shared
+      OverlayMask = ~0xff
+    };
+
+    /**
+     * The size in pixels of the icon.
+     */
+    int size;
+
+    /**
+     * The context of the icon.
+     */
+    Context context;
+
+    /**
+     * The type of the icon: Fixed, Scalable or Threshold.
+     **/
+    Type type;
+
+    /**
+     * The threshold in case type == Threshold
+     */
+    int threshold;
+
+    /**
+     * The full path of the icon.
+     */
+    QString path;
+
+private:
+    KIconPrivate *d;
+};
+
+inline KIcon::Group& operator++(KIcon::Group& group) { group = static_cast<KIcon::Group>(group+1); return group; }
+inline KIcon::Group operator++(KIcon::Group& group,int) { KIcon::Group ret = group; ++group; return ret; }
+
+/**
+ * Class to use/access icon themes in KDE. This class is used by the
+ * iconloader but can be used by others too.
+ * @see KIconLoader
+ */
+class KIconTheme
+{
+public:
+    /**
+     * Load an icon theme by name.
+     * @param name the name of the theme (e.g. "hicolor" or "keramik")
+     * @param appName the name of the application. Can be null. This argument
+     *        allows applications to have themed application icons.
+     */
+    KIconTheme(const QString& name, const QString& appName=QString::null);
+    ~KIconTheme();
+
+    /**
+     * The stylized name of the icon theme.
+     * @return the (human-readable) name of the theme
+     */
+    QString name() const { return mName; }
+
+    /**
+     * A description for the icon theme.
+     * @return a human-readable description of the theme, QString::null
+     *         if there is none
+     */
+    QString description() const { return mDesc; }
+
+    /**
+     * Return the name of the "example" icon. This can be used to
+     * present the theme to the user.
+     * @return the name of the example icon, QString::null if there is none
+     */
+    QString example() const;
+
+    /**
+     * Return the name of the screenshot.
+     * @return the name of the screenshot, QString::null if there is none
+     */
+    QString screenshot() const;
+
+    /**
+     * Returns the name of this theme's link overlay.
+     * @return the name of the link overlay
+     */
+    QString linkOverlay() const;
+
+    /**
+     * Returns the name of this theme's zip overlay.
+     * @return the name of the zip overlay
+     */
+    QString zipOverlay() const;
+
+    /**
+     * Returns the name of this theme's lock overlay.
+     * @return the name of the lock overlay
+     */
+    QString lockOverlay() const;
+
+    /**
+     * Returns the name of this theme's share overlay.
+     * @return the name of the share overlay
+     * @since 3.1
+     */
+    QString shareOverlay () const;
+
+    /**
+     * Returns the toplevel theme directory.
+     * @return the directory of the theme
+     */
+    QString dir() const { return mDir; }
+
+    /**
+     * The themes this icon theme falls back on.
+     * @return a list of icon themes that are used as fall-backs
+     */
+    QStringList inherits() const { return mInherits; }
+
+    /**
+     * The icon theme exists?
+     * @return true if the icon theme is valid
+     */
+    bool isValid() const;
+
+    /**
+     * The icon theme should be hidden to the user?
+     * @return true if the icon theme is hidden
+     * @since 3.1
+     */
+    bool isHidden() const;
+
+    /**
+     * The minimum display depth required for this theme. This can either
+     * be 8 or 32.
+     * @return the minimum bpp (8 or 32)
+     */
+    int depth() const { return mDepth; }
+
+    /**
+     * The default size of this theme for a certain icon group.
+     * @param group The icon group. See KIcon::Group.
+     * @return The default size in pixels for the given icon group.
+     */
+    int defaultSize(KIcon::Group group) const;
+
+    /**
+     * Query available sizes for a group.
+     * @param group The icon group. See KIcon::Group.
+     * @return a list of available sized for the given group
+     */
+    QValueList<int> querySizes(KIcon::Group group) const;
+
+    /**
+     * Query available icons for a size and context.
+     * @param size the size of the icons
+     * @param context the context of the icons
+     * @return the list of icon names
+     */
+    QStringList queryIcons(int size, KIcon::Context context = KIcon::Any) const;
+
+    /**
+     * Query available icons for a context and preferred size.
+     * @param size the size of the icons
+     * @param context the context of the icons
+     * @return the list of icon names
+     */
+    QStringList queryIconsByContext(int size, KIcon::Context context = KIcon::Any) const;
+
+
+    /**
+     * Lookup an icon in the theme.
+     * @param name The name of the icon, without extension.
+     * @param size The desired size of the icon.
+     * @param match The matching mode. KIcon::MatchExact returns an icon
+     * only if matches exactly. KIcon::MatchBest returns the best matching
+     * icon.
+     * @return A KIcon class that describes the icon. If an icon is found,
+     * @see KIcon::isValid will return true, and false otherwise.
+     */
+    KIcon iconPath(const QString& name, int size, KIcon::MatchType match) const;
+
+    /**
+     * List all icon themes installed on the system, global and local.
+     * @return the list of all icon themes
+     */
+    static QStringList list();
+
+    /**
+     * Returns the current icon theme.
+     * @return the name of the current theme
+     */
+    static QString current();
+
+    /**
+     * Reconfigure the theme.
+     */
+    static void reconfigure();
+
+    /**
+     * Returns the default icon theme.
+     * @return the name of the default theme name
+     * @since 3.1
+     */
+    static QString defaultThemeName();
+
+private:
+    int mDefSize[8];
+    QValueList<int> mSizes[8];
+
+    int mDepth;
+    QString mDir, mName, mDesc;
+    QStringList mInherits;
+//    QPtrList<KIconThemeDir> mDirs;
+    KIconThemePrivate *d;
+
+    static QString *_theme;
+    static QStringList *_theme_list;
+};
+
+#endif
diff --git a/python/pykde/extra/kde331/kkeyserver_x11.h b/python/pykde/extra/kde331/kkeyserver_x11.h
new file mode 100644
index 00000000..cf1b360a
--- /dev/null
+++ b/python/pykde/extra/kde331/kkeyserver_x11.h
@@ -0,0 +1,433 @@
+#ifndef _KKEYSERVER_X11_H
+#define _KKEYSERVER_X11_H
+
+#include "kshortcut.h"
+#include "kkeynative.h"
+
+/**
+ * A collection of functions for the conversion of key presses and
+ * their modifiers from the window system (X11) specific format
+ * to the generic format and vice-versa.
+ */
+namespace KKeyServer
+{
+	/**
+	 * Supplement enum KKey::ModFlag
+	 * @since 3.1
+	 */
+	enum ExtraModFlag { MODE_SWITCH = 0x2000 };
+
+	/**
+	 * Represents a key symbol.
+	 * @see KKey
+	 * @see KKeyServer
+	 */
+	struct Sym
+	{
+	 public:
+		/// the actual value of the symbol
+		uint m_sym;
+
+		/// Creates a null symbol.
+		Sym()
+			{ m_sym = 0; }
+		/**
+		 * Creates asymbol with the given value.
+		 * @param sym the value
+		 */
+		Sym( uint sym )
+			{ m_sym = sym; }
+		/**
+		 * Creates a symbol from the given string description.
+		 * @param s the description of the symbol
+		 * @see toString()
+		 */
+		Sym( const QString& s )
+			{ init( s ); }
+
+		/**
+		 * Initializes the symbol with the given Qt key code.
+		 * @param keyQt the qt key code
+		 * @return true if successful, false otherwise
+		 * @see Qt::Key
+		 */
+		bool initQt( int keyQt );
+
+		/**
+		 * Initializes the key with the given string description.
+		 * @param s the string description
+		 * @return true if successful, false otherwise
+		 * @see toString()
+		 */
+		bool init( const QString &s );
+
+		/**
+		 * Returns the qt key code of the symbol.
+		 * @return the qt key code
+		 */
+		int qt() const;
+
+		/**
+		 * @internal
+		 */
+		QString toStringInternal() const;
+
+		/**
+		 * Returns the string representation of the symbol.
+		 * @return the string representation of the symbol
+		 */
+		QString toString() const;
+
+		/**
+		 * Returns the mods that are required for this symbol as
+		 * ORed KKey::ModFlag's. For example, Break requires a
+		 * Ctrl to be valid.
+		 * @return the required KKey::ModFlag's
+		 * @see KKey::ModFlag
+		 */
+		uint getModsRequired() const;
+
+		/**
+		 * TODO: please find out what this method does and document it
+		 */
+		uint getSymVariation() const;
+
+		/**
+		 * Casts the symbol to its integer representation.
+		 */
+		operator uint() const { return m_sym; }
+
+		/**
+		 * Overloaded operator to convert ints to Sym.
+		 */
+		Sym& operator =( uint sym ) { m_sym = sym; return *this; }
+
+	 private:
+		QString toString( bool bUserSpace ) const;
+
+		static void capitalizeKeyname( QString& );
+	};
+
+	/**
+	 * Represents a key press.
+	 * @see KKey
+	 */
+	struct Key
+	{
+		/// Code for native Keys in Qt
+		enum { CODE_FOR_QT = 256 };
+
+		/// The code of the key
+		uint m_code;
+
+		/// The modifiers of the key
+		uint m_mod;
+
+		/// The symbol of the key
+		uint m_sym;
+
+		/**
+		 * Initializes the key with a KKey.
+		 * @param key the key to get the data from
+		 * @param bQt true to take the Qt keycode, false
+		 *            for the native key code
+		 * @see Qt::Key
+		 * @see KKeyNative
+		 */
+		bool init( const KKey& key, bool bQt );
+
+		/**
+		 * Checks whether the key code is a native code.
+		 * @return true if native code of the window system,
+		 *         false if it is a Qt keycode
+		 * @see Qt::Key
+		 * @see KKeyNative
+		 */
+		bool isNative() const { return m_code != CODE_FOR_QT; }
+
+		/**
+		 * Returns the code of the key.
+		 * @return the code of the key
+		 */
+		uint code() const { return m_code; }
+
+		/**
+		 * Returns the modifiers of the key.
+		 * @return the modifiers of the key
+		 */
+		uint mod() const { return m_mod; }
+
+		/**
+		 * Returns the symbol of the key.
+		 * @return the symbol of the key
+		 */
+		uint sym() const { return m_sym; }
+
+		/**
+		 * Returns the qt key code.
+		 * @return the qt key code
+		 */
+		int keyCodeQt() const { return (int) m_sym; }
+
+		/**
+		 * Sets the qt key code.
+		 * @param keyQt the qt key code
+		 */
+		void setKeycodeQt( int keyQt )
+			{ m_code = CODE_FOR_QT; m_sym = keyQt; }
+
+		/**
+		 * Initializes this key with a KKeyNative.
+		 * @return this key
+		 */
+		Key& operator =( const KKeyNative& key );
+
+		/**
+		 * Compares this key with the given Key object. Returns a
+		 * negative number if the given Key is larger, 0 if they
+		 * are equal and a positive number this Key is larger. The
+		 * returned value is the difference between the symbol, modifier
+		 * or code, whatever is non-zero first.
+		 *
+		 * @param key the key to compare with this key
+		 * @return a negative number if the given Key is larger, 0 if
+		 * they are equal and a positive number this Key is larger
+		 */
+		int compare( const Key& key ) const;
+
+		/**
+		 * Compares the symbol, modifiers and code of both keys.
+		 * @see compare()
+		 */
+		bool operator ==( const Key& b ) const
+			{ return compare( b ) == 0; }
+
+		/**
+		 * Compares the symbol, modifiers and code of both keys.
+		 * @see compare()
+		 */
+		bool operator <( const Key& b ) const
+			{ return compare( b ) < 0; }
+
+		/**
+		 * Converts this Key to a KKey.
+		 * @return the KKey
+		 */
+		KKey key() const;
+	};
+
+	/**
+	 * TODO: please document this class
+	 */
+	struct Variations
+	{
+		enum { MAX_VARIATIONS = 4 };
+
+		Key m_rgkey[MAX_VARIATIONS];
+		uint m_nVariations;
+
+		Variations() { m_nVariations = 0; }
+
+		void init( const KKey&, bool bQt );
+
+		uint count() const { return m_nVariations; }
+		const Key& key( uint i ) const { return m_rgkey[i]; }
+	};
+
+	/// TODO: please document
+	bool initializeMods();
+
+	/**
+	 * Returns the equivalent X modifier mask of the given modifier flag.
+	 * @param modFlag the generic flags to check
+	 * @return the window system specific flags
+	 */
+	uint modX( KKey::ModFlag modFlag );
+
+	/**
+	 * Returns true if the current keyboard layout supports the Win key.
+	 * Specifically, whether the Super or Meta keys are assigned to an X modifier.
+	 * @return true if the keyboard has a Win key
+	 * @see modXWin()
+	 */
+	bool keyboardHasWinKey();
+
+	/**
+	 * Returns the X11 Shift modifier mask/flag.
+	 * @return the X11 Shift modifier mask/flag.
+	 * @see accelModMaskX()
+	 */
+	uint modXShift();
+
+	/**
+	 * Returns the X11 Lock modifier mask/flag.
+	 * @return the X11 Lock modifier mask/flag.
+	 * @see accelModMaskX()
+	 */
+	uint modXLock();
+
+	/**
+	 * Returns the X11 Ctrl modifier mask/flag.
+	 * @return the X11 Ctrl modifier mask/flag.
+	 * @see accelModMaskX()
+	 */
+	uint modXCtrl();
+
+	/**
+	 * Returns the X11 Alt (Mod1) modifier mask/flag.
+	 * @return the X11 Alt (Mod1) modifier mask/flag.
+	 * @see accelModMaskX()
+	 */
+	uint modXAlt();
+
+	/**
+	 * Returns the X11 NumLock modifier mask/flag.
+	 * @return the X11 NumLock modifier mask/flag.
+	 * @see accelModMaskX()
+	 */
+	uint modXNumLock();
+
+	/**
+	 * Returns the X11 Win (Mod3) modifier mask/flag.
+	 * @return the X11 Win (Mod3) modifier mask/flag.
+	 * @see keyboardHasWinKey()
+	 * @see accelModMaskX()
+	 */
+	uint modXWin();
+
+	/**
+	 * Returns the X11 ScrollLock modifier mask/flag.
+	 * @return the X11 ScrollLock modifier mask/flag.
+	 * @see accelModMaskX()
+	 */
+	uint modXScrollLock();
+
+	/**
+	 * Returns bitwise OR'ed mask containing Shift, Ctrl, Alt, and
+	 * Win (if available).
+	 * @see modXShift()
+	 * @see modXLock()
+	 * @see modXCtrl()
+	 * @see modXAlt()
+	 * @see modXNumLock()
+	 * @see modXWin()
+	 * @see modXScrollLock()
+	 */
+	uint accelModMaskX();
+
+	/**
+	 * Extracts the symbol from the given Qt key and
+	 * converts it to a symbol.
+	 * @param keyQt the qt key code
+	 * @param sym if successful, the symbol will be written here
+	 * @return true if successful, false otherwise
+	 * @see Qt::Key
+	 * @see Sym
+	 */
+	bool keyQtToSym( int keyQt, uint& sym );
+
+	/**
+	 * Extracts the modifiers from the given Qt key and
+	 * converts them in a mask of ORed KKey::ModFlag modifiers.
+	 * @param keyQt the qt key code
+	 * @param mod if successful, the modifiers will be written here
+	 * @return true if successful, false otherwise
+	 * @see Qt::Key
+	 */
+	bool keyQtToMod( int keyQt, uint& mod );
+
+	/**
+	 * Converts the given symbol to a Qt key code.
+	 * @param sym the symbol
+	 * @param keyQt if successful, the qt key code will be written here
+	 * @return true if successful, false otherwise
+	 * @see Qt::Key
+	 * @see Sym
+	 */
+	bool symToKeyQt( uint sym, int& keyQt );
+
+	/**
+	 * Converts the mask of ORed KKey::ModFlag modifiers to
+	 * a mask of ORed Qt key code modifiers.
+	 * @param mod the mask of KKey::ModFlag modifiers
+	 * @param modQt the mask of Qt key code modifiers will be written here,
+	 *        if successful
+	 * @return true if successful, false otherwise
+	 * @see Qt::Key
+	 * @see KKey
+	 */
+	bool modToModQt( uint mod, int& modQt );
+
+	/**
+	 * Converts the mask of ORed KKey::ModFlag modifiers to
+	 * a mask of ORed X11 modifiers.
+	 * @param mod the mask of KKey::ModFlag modifiers
+	 * @param modX the mask of X11 modifiers will be written here,
+	 *        if successful
+	 * @return true if successful, false otherwise
+	 * @see KKey
+	 */
+	bool modToModX( uint mod, uint& modX );
+
+	/**
+	 * Converts the mask of ORed X11 modifiers to
+	 * a mask of ORed Qt key code modifiers.
+	 * @param modX the mask of X11 modifiers
+	 * @param modQt the mask of Qt key code modifiers will be written here
+	 *        if successful
+	 * @return true if successful, false otherwise
+	 * @see Qt::Key
+	 */
+	bool modXToModQt( uint modX, int& modQt );
+
+	/**
+	 * Converts the mask of ORed X11 modifiers to
+	 * a mask of ORed KKey::ModFlag modifiers.
+	 * @param modX the mask of X11 modifiers
+	 * @param mod the mask of KKey::ModFlag modifiers will be written here,
+	 *        if successful
+	 * @return true if successful, false otherwise
+	 * @see KKey
+	 */
+	bool modXToMod( uint modX, uint& mod );
+
+	/**
+	 * Converts a X11 key code and a mask of ORed X11 modifiers
+	 * into a X11 symbol.
+	 * converts it to a symbol.
+	 * @param codeX the X11 key code
+	 * @param modX the mask of ORed X11 modifiers
+	 * @param symX if successful, the X11 symbol will be written here
+	 * @return true if successful, false otherwise
+	 * @see Qt::Key
+	 * @see Sym
+	 */
+	bool codeXToSym( uchar codeX, uint modX, uint& symX );
+
+	/**
+	 * @internal
+	 */
+	QString modToStringInternal( uint mod );
+
+	/**
+	 * Converts the mask of ORed KKey::ModFlag modifiers to a
+	 * user-readable string.
+	 * @param mod the mask of ORed KKey::ModFlag modifiers
+	 * @return the user-readable string
+	 */
+	QString modToStringUser( uint mod );
+
+	/**
+	 * @internal
+	 * Unimplemented?
+	 */
+	bool stringToSymMod( const QString&, uint& sym, uint& mod );
+
+	/**
+	 * @internal
+	 * Unimplemented?
+	 */
+	void keyQtToKeyX( uint keyCombQt, unsigned char *pKeyCodeX, uint *pKeySymX, uint *pKeyModX );
+}
+
+#endif // !_KKEYSERVER_X11_H
diff --git a/python/pykde/extra/kde331/konsole_part.h b/python/pykde/extra/kde331/konsole_part.h
new file mode 100644
index 00000000..83998884
--- /dev/null
+++ b/python/pykde/extra/kde331/konsole_part.h
@@ -0,0 +1,229 @@
+/*
+    This file is part of the KDE system
+    Copyright (C)  1999,2000 Boloni Laszlo
+
+    This program 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 program 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., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __KONSOLE_PART_H__
+#define __KONSOLE_PART_H__
+
+#include <kparts/browserextension.h>
+#include <kparts/factory.h>
+
+
+#include <kdialogbase.h>
+
+#include <kde_terminal_interface.h>
+
+//#include "schema.h"
+//#include "session.h"
+
+class KInstance;
+class konsoleBrowserExtension;
+class QPushButton;
+class QSpinBox;
+class KPopupMenu;
+class QCheckBox;
+class KRootPixmap;
+class KToggleAction;
+class KSelectAction;
+
+namespace KParts { class GUIActivateEvent; }
+
+class konsoleFactory : public KParts::Factory
+{
+    Q_OBJECT
+public:
+    konsoleFactory();
+    virtual ~konsoleFactory();
+
+    virtual KParts::Part* createPartObject(QWidget *parentWidget = 0, const char *widgetName = 0,
+                                     QObject* parent = 0, const char* name = 0,
+                                     const char* classname = "KParts::Part",
+                                     const QStringList &args = QStringList());
+
+    static KInstance *instance();
+
+ private:
+    static KInstance *s_instance;
+    static KAboutData *s_aboutData;
+};
+
+//////////////////////////////////////////////////////////////////////
+
+class konsolePart: public KParts::ReadOnlyPart, public TerminalInterface
+{
+    Q_OBJECT
+    public:
+    konsolePart(QWidget *parentWidget, const char *widgetName, QObject * parent, const char *name, const char *classname = 0);
+    virtual ~konsolePart();
+
+signals:
+    void processExited();
+    void receivedData( const QString& s );
+ protected:
+    virtual bool openURL( const KURL & url );
+    virtual bool openFile() {return false;} // never used
+    virtual bool closeURL() {return true;}
+    virtual void guiActivateEvent( KParts::GUIActivateEvent * event );
+
+ protected slots:
+    void showShell();
+    void slotProcessExited();
+    void slotReceivedData( const QString& s );
+
+//    void doneSession(TESession*);
+    void sessionDestroyed();
+//    void configureRequest(TEWidget*,int,int x,int y);
+    void updateTitle();
+    void enableMasterModeConnections();
+
+ private slots:
+    void emitOpenURLRequest(const QString &url);
+
+    void readProperties();
+    void saveProperties();
+
+    void sendSignal(int n);
+    void closeCurrentSession();
+
+    void notifySize(int,int);
+
+    void slotToggleFrame();
+    void slotSelectScrollbar();
+    void slotSelectFont();
+    void schema_menu_check();
+    void keytab_menu_activated(int item);
+    void updateSchemaMenu();
+    void setSchema(int n);
+    void pixmap_menu_activated(int item);
+    void schema_menu_activated(int item);
+    void slotHistoryType();
+    void slotSelectBell();
+    void slotSelectLineSpacing();
+    void slotBlinkingCursor();
+    void slotWordSeps();
+    void fontNotFound();
+    void slotSetEncoding();
+    void slotFontChanged();
+
+ private:
+    konsoleBrowserExtension *m_extension;
+    KURL currentURL;
+
+    void makeGUI();
+    void applySettingsToGUI();
+
+    void setFont(int fontno);
+//    void setSchema(ColorSchema* s);
+    void updateKeytabMenu();
+
+    bool doOpenStream( const QString& );
+    bool doWriteStream( const QByteArray& );
+    bool doCloseStream();
+
+    QWidget* parentWidget;
+//    TEWidget* te;
+//    TESession* se;
+//    ColorSchemaList* colors;
+    KRootPixmap* rootxpm;
+
+    KToggleAction* blinkingCursor;
+    KToggleAction* showFrame;
+
+    KSelectAction* selectBell;
+    KSelectAction* selectFont;
+    KSelectAction* selectLineSpacing;
+    KSelectAction* selectScrollbar;
+    KSelectAction* selectSetEncoding;
+
+    KPopupMenu* m_keytab;
+    KPopupMenu* m_schema;
+    KPopupMenu* m_signals;
+    KPopupMenu* m_options;
+    KPopupMenu* m_popupMenu;
+
+    QFont       defaultFont;
+
+    QString     pmPath; // pixmap path
+    QString     s_schema;
+    QString     s_kconfigSchema;
+    QString     s_word_seps;            // characters that are considered part of a word
+    QString     fontNotFound_par;
+
+    bool        b_framevis:1;
+    bool        b_histEnabled:1;
+
+    int         curr_schema; // current schema no
+    int         n_bell;
+    int         n_font;
+    int         n_keytab;
+    int         n_render;
+    int         n_scroll;
+    unsigned    m_histSize;
+    bool        m_runningShell;
+    bool        m_streamEnabled;
+    int         n_encoding;
+
+public:
+    // these are the implementations for the TermEmuInterface
+    // functions...
+    void startProgram( const QString& program,
+                       const QStrList& args );
+    void showShellInDir( const QString& dir );
+    void sendInput( const QString& text );
+};
+
+//////////////////////////////////////////////////////////////////////
+
+/*class HistoryTypeDialog : public KDialogBase
+{
+    Q_OBJECT
+public:
+  HistoryTypeDialog(const HistoryType& histType,
+                    unsigned int histSize,
+                    QWidget *parent);
+
+public slots:
+  void slotDefault();
+  void slotSetUnlimited();
+  void slotHistEnable(bool);
+
+  unsigned int nbLines() const;
+  bool isOn() const;
+
+protected:
+  QCheckBox* m_btnEnable;
+  QSpinBox*  m_size;
+  QPushButton* m_setUnlimited;
+};
+
+//////////////////////////////////////////////////////////////////////
+*/
+
+class konsoleBrowserExtension : public KParts::BrowserExtension
+{
+    Q_OBJECT
+    friend class konsolePart;
+ public:
+    konsoleBrowserExtension(konsolePart *parent);
+    virtual ~konsoleBrowserExtension();
+
+    void emitOpenURLRequest(const KURL &url);
+};
+
+#endif
diff --git a/python/pykde/extra/kde331/kpanelmenu.h b/python/pykde/extra/kde331/kpanelmenu.h
new file mode 100644
index 00000000..57f77a45
--- /dev/null
+++ b/python/pykde/extra/kde331/kpanelmenu.h
@@ -0,0 +1,181 @@
+/*****************************************************************
+
+Copyright (c) 1996-2000 the kicker authors. See file AUTHORS.
+          (c) 2001 Michael Goffioul <kdeprint@swing.be>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+******************************************************************/
+
+#ifndef __KPANELMENU_H__
+#define __KPANELMENU_H__
+
+#include <qstring.h>
+#include <kpopupmenu.h>
+#include <kgenericfactory.h>
+
+class KPanelMenuPrivate;
+
+/**
+ * This class allows to build menu entries that will be dynamically added either to
+ * the K-menu, or to the panel as a normal button. These dynamic menus are located
+ * in shared libraries that will be loaded at runtime by Kicker (the KDE panel).
+ *
+ * To build such a menu, you have to inherit this class and implement the pure virtual
+ * functions #initialize() and slotExec(). You also have to provide a factory
+ * object in your library, see KLibFactory. This factory is only used to construct
+ * the menu object.
+ *
+ * Finally, you also have to provide a desktop file describing your dynamic menu. The
+ * relevant entries are: Name, Comment, Icon and X-KDE-Library (which contains the
+ * library name without any extension). This desktop file has to be installed in
+ * $KDEDIR/share/apps/kicker/menuext/.
+ *
+ * @short Base class to build dynamically loaded menu entries for the K-menu, or the panel.
+ * @author The kicker maintainer, Michael Goffioul <kdeprint@swing.be>
+ */
+class KPanelMenu : public KPopupMenu
+{
+    Q_OBJECT
+
+public:
+    /**
+     * Construct a KPanelMenu object. This is the normal constructor to use when
+     * building extrernal menu entries.
+     */
+    KPanelMenu(QWidget *parent=0, const char *name=0);
+    /**
+     * Constructor used internally by Kicker. You don't really want to use it.
+     * @param startDir a directory to associate with this menu
+     * @param parent parent object
+     * @param name name of the object
+     * @see path(), setPath()
+     */
+    KPanelMenu(const QString &startDir, QWidget *parent=0, const char *name=0);
+    /**
+     * Destructor.
+     */
+    virtual ~KPanelMenu();
+
+    /**
+     * Get the directory path associated with this menu, or QString::null if
+     * there's no such associated path.
+     * @return the associated directory path
+     * @see setPath()
+     */
+    const QString& path() const;
+    /**
+     * Set a directory path to be associated with this menu.
+     * @param p the directory path
+     * @see path()
+     */
+    void setPath(const QString &p);
+    /**
+     * Tell if the menu has been initialized, that is it already contains items.
+     * This is useful when you need to know if you have to clear the menu, or to
+     * fill it.
+     * @return the initial state
+     * @see setInitialized(), initialize()
+     */
+    bool initialized() const;
+    /**
+     * Set the initial state. Set it to true when you menu is filled with the items
+     * you want.
+     * @param on the initial state
+     * @see initialized(), initialize()
+     */
+    void setInitialized(bool on);
+
+    /**
+     * Disable the automatic clearing of the menu. Kicker uses a cache system for
+     * its menus. After a specific configurable delay, the menu will be cleared.
+     * Use this function if you want to disable kicker's cache system, and avoid
+     * the clearing of your menu.
+     */
+    void disableAutoClear();
+
+public slots:
+    /**
+     * Reinitialize the menu: the menu is first cleared, the initial state is set
+     * to false, and finally #initialize() is called. Use this if you want to
+     * refill your menu immediately.
+     */
+    void reinitialize();
+    /**
+     * Deinitialize the menu: the menu is cleared and the initialized state is set to
+     * false. #initialize() is NOT called. It will be called before the menu is
+     * next shown, however. Use this slot if you want a delayed reinitialization.
+     * @since 3.1
+     */
+    void deinitialize();
+
+protected slots:
+    /**
+     * This slot is called just before the menu is shown. This allows your menu
+     * to update itself if needed. However you should instead re-implement
+     * #initialize to provide this feature. This function is responsible for
+     * the cache system handling, so if you re-implement it, you should call
+     * the base function also. Calls #initialize().
+     * @see disableAutoClear()
+     */
+    virtual void slotAboutToShow();
+    /**
+     * This is slot is called when an item from the menu has been selected. Your
+     * applet is then supposed to perform some action. You must re-implement this
+     * function.
+     * @param id the ID associated with the selected item
+     */
+    virtual void slotExec(int id) = 0;
+    /**
+     * This slots is called to initialize the menu. It is called automatically by
+     * slotAboutToShow(). By re-implementing this functions, you can reconstruct
+     * the menu before it is being shown. At the end of this function, you should
+     * call setInitialize() with true to tell the system that the menu is OK.
+     * You applet must re-implement this function.
+     * @see slotAboutToShow(), initialized(), setInitialized()
+     */
+    virtual void initialize() = 0;
+    /**
+     * Clears the menu, and update the initial state accordingly.
+     * @see initialized()
+     */
+    void slotClear();
+
+protected:
+    /**
+     * Re-implemented for internal reasons.
+     */
+    virtual void hideEvent(QHideEvent *ev);
+    /**
+     * For internal use only. Used by constructors.
+     */
+    void init(const QString& path = QString::null);
+
+protected:
+    virtual void virtual_hook( int id, void* data );
+private:
+    void internalInitialize();
+    KPanelMenuPrivate *d;
+};
+
+#define K_EXPORT_KICKER_MENUEXT( libname, classname )                       \
+    K_EXPORT_COMPONENT_FACTORY(                                             \
+        kickermenu_##libname,                                               \
+        KGenericFactory<classname>("libkickermenu_" #libname) )
+
+#endif
diff --git a/python/pykde/extra/kde331/krecentdirs.h b/python/pykde/extra/kde331/krecentdirs.h
new file mode 100644
index 00000000..71f771b1
--- /dev/null
+++ b/python/pykde/extra/kde331/krecentdirs.h
@@ -0,0 +1,68 @@
+/* -*- c++ -*-
+ * Copyright (C)2000 Waldo Bastian <bastian@kde.org>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+#ifndef __KRECENTDIRS_H
+#define __KRECENTDIRS_H
+
+#include <qstringlist.h>
+
+/**
+ * The goal of this class is to make sure that, when the user needs to 
+ * specify a file via the file selection dialog, this dialog will start 
+ * in the directory most likely to contain the desired files.
+ *
+ * This works as follows: Each time the file selection dialog is
+ * shown, the programmer can specify a "file-class". The file-dialog will
+ * then start with the directory associated with this file-class. When
+ * the dialog closes, the directory currently shown in the file-dialog
+ * will be associated with the file-class.
+ *
+ * A file-class can either start with ':' or with '::'. If it starts with
+ * a single ':' the file-class is specific to the current application.
+ * If the file-class starts with '::' it is global to all applications.
+ */
+class KRecentDirs
+{
+public:
+    /**
+     * Returns a list of directories associated with this file-class.
+     * The most recently used directory is at the front of the list.
+     */
+    static QStringList list(const QString &fileClass);
+    
+    /**
+     * Returns the most recently used directory accociated with this file-class.
+     */
+    static QString dir(const QString &fileClass);
+    
+    /**
+     * Associates @p directory with @p fileClass
+     */
+    static void add(const QString &fileClass, const QString &directory);
+};
+
+#endif
diff --git a/python/pykde/extra/kde331/ksharedptr.h b/python/pykde/extra/kde331/ksharedptr.h
new file mode 100644
index 00000000..d951f39b
--- /dev/null
+++ b/python/pykde/extra/kde331/ksharedptr.h
@@ -0,0 +1,175 @@
+/* This file is part of the KDE libraries
+   Copyright (c) 1999 Waldo Bastian <bastian@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 version 2 as published by the Free Software Foundation.
+
+   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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+*/
+#ifndef KSharedPTR_H
+#define KSharedPTR_H
+
+/**
+ * Reference counting for shared objects.  If you derive your object
+ * from this class, then you may use it in conjunction with
+ * KSharedPtr to control the lifetime of your object.
+ *
+ * Specifically, all classes that derive from KShared have an internal
+ * counter keeping track of how many other objects have a reference to
+ * their object.  If used with KSharedPtr, then your object will
+ * not be deleted until all references to the object have been
+ * released.
+ *
+ * You should probably not ever use any of the methods in this class
+ * directly -- let the KSharedPtr take care of that.  Just derive
+ * your class from KShared and forget about it.
+ *
+ * @author Waldo Bastian <bastian@kde.org>
+ * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $
+ */
+class KShared {
+public:
+   /**
+    * Standard constructor.  This will initialize the reference count
+    * on this object to 0.
+    */
+   KShared() : count(0) { }
+
+   /**
+    * Copy constructor.  This will @em not actually copy the objects
+    * but it will initialize the reference count on this object to 0.
+    */
+   KShared( const KShared & ) : count(0) { }
+
+   /**
+    * Overloaded assignment operator.
+    */
+   KShared &operator=(const KShared & ) { return *this; }
+
+   /**
+    * Increases the reference count by one.
+    */
+   void _KShared_ref() const { count++; }
+
+   /**
+    * Releases a reference (decreases the reference count by one).  If
+    * the count goes to 0, this object will delete itself.
+    */
+   void _KShared_unref() const { if (!--count) delete this; }
+
+   /**
+    * Return the current number of references held.
+    *
+    * @return Number of references
+    */
+   int _KShared_count() const { return count; }
+
+protected:
+   virtual ~KShared() { }
+private:
+   mutable int count;
+};
+
+/**
+ * Can be used to control the lifetime of an object that has derived
+ * KShared. As long a someone holds a KSharedPtr on some KShared
+ * object it won't become deleted but is deleted once its reference
+ * count is 0.  This struct emulates C++ pointers virtually perfectly.
+ * So just use it like a simple C++ pointer.
+ *
+ * KShared and KSharedPtr are preferred over QShared / QSharedPtr
+ * since they are more safe.
+ *
+ * WARNING: Please note that this class template provides an implicit
+ * conversion to T*. Do *not* change this pointer or the pointee (don't
+ * call delete on it, for instance) behind KSharedPtr's back.
+ *
+ * @author Waldo Bastian <bastian@kde.org>
+ * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $
+ */
+template< class T >
+struct KSharedPtr
+{
+public:
+/**
+ * Creates a null pointer.
+ */
+  KSharedPtr()
+    : ptr(0) { }
+  /**
+   * Creates a new pointer.
+   * @param t the pointer
+   */
+  KSharedPtr( T* t )
+    : ptr(t) { if ( ptr ) ptr->_KShared_ref(); }
+
+  /**
+   * Copies a pointer.
+   * @param p the pointer to copy
+   */
+  KSharedPtr( const KSharedPtr& p )
+    : ptr(p.ptr) { if ( ptr ) ptr->_KShared_ref(); }
+
+  /**
+   * Unreferences the object that this pointer points to. If it was
+   * the last reference, the object will be deleted.
+   */
+  ~KSharedPtr() { if ( ptr ) ptr->_KShared_unref(); }
+
+  KSharedPtr<T>& operator= ( const KSharedPtr<T>& p ) {
+    if ( ptr == p.ptr ) return *this;
+    if ( ptr ) ptr->_KShared_unref();
+    ptr = p.ptr;
+    if ( ptr ) ptr->_KShared_ref();
+    return *this;
+  }
+  KSharedPtr<T>& operator= ( T* p ) {
+    if ( ptr == p ) return *this;
+    if ( ptr ) ptr->_KShared_unref();
+    ptr = p;
+    if ( ptr ) ptr->_KShared_ref();
+    return *this;
+  }
+  bool operator== ( const KSharedPtr<T>& p ) const { return ( ptr == p.ptr ); }
+  bool operator!= ( const KSharedPtr<T>& p ) const { return ( ptr != p.ptr ); }
+  bool operator== ( const T* p ) const { return ( ptr == p ); }
+  bool operator!= ( const T* p ) const { return ( ptr != p ); }
+  bool operator!() const { return ( ptr == 0 ); }
+  operator T*() const { return ptr; }
+
+  /**
+   * Returns the pointer.
+   * @return the pointer
+   */
+  T* data() { return ptr; }
+
+  /**
+   * Returns the pointer.
+   * @return the pointer
+   */
+  const T* data() const { return ptr; }
+
+  const T& operator*() const { return *ptr; }
+  T& operator*() { return *ptr; }
+  const T* operator->() const { return ptr; }
+  T* operator->() { return ptr; }
+
+  /**
+   * Returns the number of references.
+   * @return the number of references
+   */
+  int count() const { return ptr->_KShared_count(); } // for debugging purposes
+private:
+  T* ptr;
+};
+
+#endif
diff --git a/python/pykde/extra/kde331/ksycocafactory.h b/python/pykde/extra/kde331/ksycocafactory.h
new file mode 100644
index 00000000..3a422957
--- /dev/null
+++ b/python/pykde/extra/kde331/ksycocafactory.h
@@ -0,0 +1,143 @@
+/*  This file is part of the KDE libraries
+ *  Copyright (C) 1999 Waldo Bastian <bastian@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 version 2 as published by the Free Software Foundation;
+ *
+ *  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., 59 Temple Place - Suite 330,
+ *  Boston, MA 02111-1307, USA.
+ **/
+
+#ifndef __ksycocafactory_h__
+#define __ksycocafactory_h__ "$Id: ksycocafactory.h,v 1.14 2003/10/29 17:59:18 waba Exp $"
+
+#include "ksycocatype.h"
+#include "ksycocaentry.h"
+
+#include <qdict.h>
+#include <qptrlist.h>
+class KSycoca;
+class QStringList;
+class QString;
+class KSycocaDict;
+class KSycocaResourceList;
+
+typedef QDict<KSycocaEntry::Ptr> KSycocaEntryDict;
+
+/**
+ * @internal
+ * Base class for sycoca factories
+ */
+class KSycocaFactory
+{
+public:
+   virtual KSycocaFactoryId factoryId() const = 0;
+ 
+protected: // virtual class
+   /**
+    * Create a factory which can be used to lookup from/create a database
+    * (depending on KSycoca::isBuilding())
+    */
+   KSycocaFactory( KSycocaFactoryId factory_id );
+
+public:
+   virtual ~KSycocaFactory();
+
+   /**
+    * @return the position of the factory in the sycoca file
+    */
+   int offset() { return mOffset; }
+
+   /**
+    * @return the dict, for special use by KBuildSycoca
+    */
+   KSycocaEntryDict * entryDict() { return m_entryDict; }
+
+   /**
+    * Construct an entry from a config file.
+    * To be implemented in the real factories.
+    */
+   virtual KSycocaEntry *createEntry(const QString &file, const char *resource) = 0;
+
+   /**
+    * Add an entry
+    */
+   virtual void addEntry(KSycocaEntry *newEntry, const char *resource);
+
+   /**
+    * Remove an entry
+    * Not very fast, use with care. O(N)
+    */
+   void removeEntry(KSycocaEntry *newEntry);
+
+   /**
+    * Read an entry from the database
+    */
+   virtual KSycocaEntry *createEntry(int offset)=0;
+
+   /**
+    * Get a list of all entries from the database.
+    */
+   KSycocaEntry::List allEntries();
+
+   /**
+    * Saves all entries it maintains as well as index files
+    * for these entries to the stream 'str'.
+    *
+    * Also sets mOffset to the starting position.
+    *
+    * The stream is positioned at the end of the last index.
+    *
+    * Don't forget to call the parent first when you override 
+    * this function.
+    */
+   virtual void save(QDataStream &str);
+
+   /**
+    * Writes out a header to the stream 'str'.
+    * The baseclass positions the stream correctly.
+    *
+    * Don't forget to call the parent first when you override 
+    * this function.
+    */
+   virtual void saveHeader(QDataStream &str);
+
+   /**
+    * @return the resources for which this factory is responsible.
+    */
+   virtual const KSycocaResourceList * resourceList() const { return m_resourceList; }
+
+private:
+   int mOffset;
+
+protected:
+   int m_sycocaDictOffset;
+   int m_beginEntryOffset;
+   int m_endEntryOffset;
+   QDataStream *m_str;
+
+   KSycocaResourceList *m_resourceList;
+   KSycocaEntryDict *m_entryDict;
+   KSycocaDict *m_sycocaDict;
+protected:
+   virtual void virtual_hook( int id, void* data );
+};
+
+/** This, instead of a typedef, allows to declare "class ..." in header files
+ * @internal
+ */
+class KSycocaFactoryList : public QPtrList<KSycocaFactory>
+{
+public:
+   KSycocaFactoryList() { }
+};
+
+#endif
diff --git a/python/pykde/extra/kde331/ktoolbarbutton.h b/python/pykde/extra/kde331/ktoolbarbutton.h
new file mode 100644
index 00000000..39907a75
--- /dev/null
+++ b/python/pykde/extra/kde331/ktoolbarbutton.h
@@ -0,0 +1,315 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 1997, 1998 Stephan Kulow (coolo@kde.org)
+              (C) 1997, 1998 Sven Radej (radej@kde.org)
+              (C) 1997, 1998 Mark Donohoe (donohoe@kde.org)
+              (C) 1997, 1998 Matthias Ettrich (ettrich@kde.org)
+              (C) 2000 Kurt Granroth (granroth@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 version 2 as published by the Free Software Foundation.
+
+    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., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+
+#ifndef _KTOOLBARBUTTON_H
+#define _KTOOLBARBUTTON_H
+
+#include <qpixmap.h>
+#include <qtoolbutton.h>
+#include <qintdict.h>
+#include <qstring.h>
+#include <kglobal.h>
+
+class KToolBar;
+class KToolBarButtonPrivate;
+class KInstance;
+class QEvent;
+class QPopupMenu;
+class QPainter;
+
+/**
+ * A toolbar button. This is used internally by KToolBar, use the
+ * KToolBar methods instead.
+ * @internal
+ */
+class KToolBarButton : public QToolButton
+{
+  Q_OBJECT
+
+public:
+  /**
+   * Construct a button with an icon loaded by the button itself.
+   * This will trust the button to load the correct icon with the
+   * correct size.
+   *
+   * @param icon   Name of icon to load (may be absolute or relative)
+   * @param id     Id of this button
+   * @param parent This button's parent
+   * @param name   This button's internal name
+   * @param txt    This button's text (in a tooltip or otherwise)
+   * @param _instance the instance to use for this button
+   */
+  KToolBarButton(const QString& icon, int id, QWidget *parent,
+                 const char *name=0L, const QString &txt=QString::null,
+                 KInstance *_instance = KGlobal::instance());
+
+  /**
+   * Construct a button with an existing pixmap.  It is not
+   * recommended that you use this as the internal icon loading code
+   * will almost always get it "right".
+   *
+   * @param pixmap Name of icon to load (may be absolute or relative)
+   * @param id     Id of this button
+   * @param parent This button's parent
+   * @param name   This button's internal name
+   * @param txt    This button's text (in a tooltip or otherwise)
+   */
+  KToolBarButton(const QPixmap& pixmap, int id, QWidget *parent,
+                 const char *name=0L, const QString &txt=QString::null);
+
+  /**
+   * Construct a separator button
+   *
+   * @param parent This button's parent
+   * @param name   This button's internal name
+   */
+  KToolBarButton(QWidget *parent=0L, const char *name=0L);
+
+  /**
+   * Standard destructor
+   */
+  ~KToolBarButton();
+
+#ifndef KDE_NO_COMPAT
+  /**
+   * @deprecated
+   * Set the pixmap directly for this button.  This pixmap should be
+   * the active one... the dimmed and disabled pixmaps are constructed
+   * based on this one.  However, don't use this function unless you
+   * are positive that you don't want to use setIcon.
+   *
+   * @param pixmap The active pixmap
+   */
+  // this one is from QButton, so #ifdef-ing it out doesn't break BC
+  virtual void setPixmap(const QPixmap &pixmap) KDE_DEPRECATED;
+
+  /**
+   * @deprecated
+   * Force the button to use this pixmap as the default one rather
+   * then generating it using effects.
+   *
+   * @param pixmap The pixmap to use as the default (normal) one
+   */
+  void setDefaultPixmap(const QPixmap& pixmap) KDE_DEPRECATED;
+
+  /**
+   * @deprecated
+   * Force the button to use this pixmap when disabled one rather then
+   * generating it using effects.
+   *
+   * @param pixmap The pixmap to use when disabled
+   */
+  void setDisabledPixmap(const QPixmap& pixmap) KDE_DEPRECATED;
+#endif
+
+  /**
+   * Set the text for this button.  The text will be either used as a
+   * tooltip (IconOnly) or will be along side the icon
+   *
+   * @param text The button (or tooltip) text
+   */
+  virtual void setText(const QString &text);
+
+  /**
+   * Set the icon for this button. The icon will be loaded internally
+   * with the correct size. This function is preferred over setIconSet
+   *
+   * @param icon The name of the icon
+   */
+  virtual void setIcon(const QString &icon);
+
+  /// @since 3.1
+  virtual void setIcon( const QPixmap &pixmap )
+  { QToolButton::setIcon( pixmap ); }
+
+  /**
+   * Set the pixmaps for this toolbar button from a QIconSet.
+   * If you call this you don't need to call any of the other methods
+   * that set icons or pixmaps.
+   * @param iconset  The iconset to use
+   */
+  virtual void setIconSet( const QIconSet &iconset );
+
+#ifndef KDE_NO_COMPAT
+  /**
+   * @deprecated
+   * Set the active icon for this button.  The pixmap itself is loaded
+   * internally based on the icon size...  .. the disabled and default
+   * pixmaps, however will only be constructed if generate is
+   * true.  This function is preferred over setPixmap
+   *
+   * @param icon     The name of the active icon
+   * @param generate If true, then the other icons are automagically
+   *                 generated from this one
+   */
+  KDE_DEPRECATED void setIcon(const QString &icon, bool generate ) { Q_UNUSED(generate); setIcon( icon ); }
+
+  /**
+   * @deprecated
+   * Force the button to use this icon as the default one rather
+   * then generating it using effects.
+   *
+   * @param icon The icon to use as the default (normal) one
+   */
+  void setDefaultIcon(const QString& icon) KDE_DEPRECATED;
+
+  /**
+   * @deprecated
+   * Force the button to use this icon when disabled one rather then
+   * generating it using effects.
+   *
+   * @param icon The icon to use when disabled
+   */
+  void setDisabledIcon(const QString& icon) KDE_DEPRECATED;
+#endif
+
+  /**
+   * Turn this button on or off
+   *
+   * @param flag true or false
+   */
+  void on(bool flag = true);
+
+  /**
+   * Toggle this button
+   */
+  void toggle();
+
+  /**
+   * Turn this button into a toggle button or disable the toggle
+   * aspects of it.  This does not toggle the button itself.
+   * Use toggle() for that.
+   *
+   * @param toggle true or false
+   */
+  void setToggle(bool toggle = true);
+
+  /**
+   * Return a pointer to this button's popup menu (if it exists)
+   */
+  QPopupMenu *popup();
+
+  /**
+   * Returns the button's id.
+   * @since 3.2
+   */
+  int id() const;
+
+  /**
+   * Give this button a popup menu.  There will not be a delay when
+   * you press the button.  Use setDelayedPopup if you want that
+   * behavior.
+   *
+   * @param p The new popup menu
+   * @param unused Has no effect - ignore it.
+   */
+  void setPopup (QPopupMenu *p, bool unused = false);
+
+  /**
+   * Gives this button a delayed popup menu.
+   *
+   * This function allows you to add a delayed popup menu to the button.
+   * The popup menu is then only displayed when the button is pressed and
+   * held down for about half a second.
+   *
+   * @param p the new popup menu
+   * @param unused Has no effect - ignore it.
+   */
+  void setDelayedPopup(QPopupMenu *p, bool unused = false);
+
+  /**
+   * Turn this button into a radio button
+   *
+   * @param f true or false
+   */
+  void setRadio(bool f = true);
+
+  /**
+   * Toolbar buttons naturally will assume the global styles
+   * concerning icons, icons sizes, etc.  You can use this function to
+   * explicitly turn this off, if you like.
+   *
+   * @param no_style Will disable styles if true
+   */
+  void setNoStyle(bool no_style = true);
+
+signals:
+  void clicked(int);
+  void doubleClicked(int);
+  void pressed(int);
+  void released(int);
+  void toggled(int);
+  void highlighted(int, bool);
+
+public slots:
+  /**
+   * This slot should be called whenever the toolbar mode has
+   * potentially changed.  This includes such events as text changing,
+   * orientation changing, etc.
+   */
+   void modeChange();
+   virtual void setTextLabel(const QString&, bool tipToo);
+
+protected:
+  void paletteChange(const QPalette &);
+  void leaveEvent(QEvent *e);
+  void enterEvent(QEvent *e);
+  void drawButton(QPainter *p);
+  bool eventFilter (QObject *o, QEvent *e);
+  void showMenu();
+  QSize sizeHint() const;
+  QSize minimumSizeHint() const;
+  QSize minimumSize() const;
+
+  /// @since 3.1
+  bool isRaised() const;
+  /// @since 3.1
+  bool isActive() const;
+  /// @since 3.1
+  int iconTextMode() const;
+
+protected slots:
+  void slotClicked();
+  void slotPressed();
+  void slotReleased();
+  void slotToggled();
+  void slotDelayTimeout();
+
+protected:
+  virtual void virtual_hook( int id, void* data );
+private:
+  KToolBarButtonPrivate *d;
+};
+
+/**
+* List of KToolBarButton objects.
+* @internal
+* @version $Id: ktoolbarbutton.h,v 1.36 2004/03/18 02:50:16 bmeyer Exp $
+*/
+class KToolBarButtonList : public QIntDict<KToolBarButton>
+{
+public:
+   KToolBarButtonList();
+   ~KToolBarButtonList() {}
+};
+
+#endif
diff --git a/python/pykde/extra/kde331/kurifilter.h b/python/pykde/extra/kde331/kurifilter.h
new file mode 100644
index 00000000..51d040a3
--- /dev/null
+++ b/python/pykde/extra/kde331/kurifilter.h
@@ -0,0 +1,644 @@
+/*
+ *  This file is part of the KDE libraries
+ *  Copyright (C) 2000-2001,2003 Dawit Alemayehu <adawit at kde.org>
+ *
+ *  Original author
+ *  Copyright (C) 2000 Yves Arrouye <yves@realnames.com>
+ *
+ *
+ *  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., 59 Temple Place - Suite 330,
+ *  Boston, MA 02111-1307, USA.
+ **/
+
+#ifndef __kurifilter_h__
+#define __kurifilter_h__ "$Id: kurifilter.h,v 1.41 2003/08/30 08:56:21 raabe Exp $"
+
+#include <qptrlist.h>
+#include <qobject.h>
+#include <qstringlist.h>
+
+#include <kurl.h>
+#include <kdemacros.h>
+
+class KURIFilterPrivate;
+class KURIFilterDataPrivate;
+
+class KCModule;
+
+/**
+* A basic message object used for exchanging filtering
+* information between the filter plugins and the application
+* requesting the filtering service.
+*
+* Use this object if you require a more detailed information
+* about the URI you want to filter. Any application can create
+* an instance of this class and send it to KURIFilter to
+* have the plugins fill out all possible information about the
+* URI.
+*
+* \b Example
+*
+* \code
+*   QString text = "kde.org";
+*   KURIFilterData d = text;
+*   bool filtered = KURIFilter::self()->filter( d );
+*   cout << "URL: " << text.latin1() << endl
+*        << "Filtered URL: " << d.uri().url().latin1() << endl
+*        << "URI Type: " << d.uriType() << endl
+*        << "Was Filtered: " << filtered << endl;
+* \endcode
+*
+* The above code should yield the following output:
+* \code
+*   URI: kde.org
+*   Filtered URI: http://kde.org
+*   URI Type: 0            <== means NET_PROTOCOL
+*   Was Filtered: 1        <== means the URL was successfully filtered
+* \endcode
+*
+* @short A message object for exchanging filtering URI info.
+* @author Dawit Alemayehu <adawit at kde.org>
+*/
+
+class KURIFilterData
+{
+friend class KURIFilterPlugin;
+
+public:
+    /**
+     * Describes the type of the URI that was filtered.
+     * Here is a brief description of the types:
+     *
+     * @li NET_PROTOCOL - Any network protocol: http, ftp, nttp, pop3, etc...
+     * @li LOCAL_FILE   - A local file whose executable flag is not set
+     * @li LOCAL_DIR    - A local directory
+     * @li EXECUTABLE   - A local file whose executable flag is set
+     * @li HELP         - A man or info page
+     * @li SHELL        - A shell executable (ex: echo "Test..." >> ~/testfile)
+     * @li BLOCKED      - A URI that should be blocked/filtered (ex: ad filtering)
+     * @li ERROR        - An incorrect URI (ex: "~johndoe" when user johndoe
+     *                    does not exist in that system )
+     * @li UNKNOWN      - A URI that is not identified. Default value when
+     *                    a KURIFilterData is first created.
+     */
+    enum URITypes { NET_PROTOCOL=0, LOCAL_FILE, LOCAL_DIR, EXECUTABLE, HELP, SHELL, BLOCKED, ERROR, UNKNOWN };
+
+    /**
+     * Default constructor.
+     *
+     * Creates a URIFilterData object.
+     */
+    KURIFilterData() { init(); }
+
+    /**
+     * Creates a URIFilterData object from the given URL.
+     *
+     * @param url is the URL to be filtered.
+     */
+    KURIFilterData( const KURL& url ) { init( url); }
+
+    /**
+     * Creates a URIFilterData object from the given string.
+     *
+     * @param url is the string to be filtered.
+     */
+    KURIFilterData( const QString& url ) { init( url ); }
+
+    /**
+     * Copy constructor.
+     *
+     * Creates a URIFilterData object from another
+     * URI filter data object.
+     *
+     * @param data the uri filter data to be copied.
+     */
+    KURIFilterData( const KURIFilterData& data);
+
+    /**
+     * Destructor.
+     */
+    ~KURIFilterData();
+
+    /**
+     * This method has been deprecated and will always return
+     * true.  You should instead use the result from the
+     * KURIFilter::filterURI() calls.
+     *
+     * @deprecated
+     */
+    KDE_DEPRECATED bool hasBeenFiltered() const { return true; }
+
+    /**
+     * Returns the filtered or the original URL.
+     *
+     * This function returns the filtered url if one
+     * of the plugins successfully filtered the original
+     * URL.  Otherwise, it returns the original URL.
+     * See hasBeenFiltered() and
+     *
+     * @return the filtered or original url.
+     */
+    KURL uri() const { return m_pURI; }
+
+    /**
+     * Returns an error message.
+     *
+     * This functions returns the error message set
+     * by the plugin whenever the uri type is set to
+     * KURIFilterData::ERROR.  Otherwise, it returns
+     * a QString::null.
+     *
+     * @return the error message or a NULL when there is none.
+     */
+    QString errorMsg() const { return m_strErrMsg; }
+
+    /**
+     * Returns the URI type.
+     *
+     * This method always returns KURIFilterData::UNKNOWN
+     * if the given URL was not filtered.
+     * @return the type of the URI
+     */
+    URITypes uriType() const { return m_iType; }
+
+    /**
+     * Sets the URL to be filtered.
+     *
+     * Use this function to set the string to be
+     * filtered when you construct an empty filter
+     * object.
+     *
+     * @param url the string to be filtered.
+     */
+    void setData( const QString& url ) { init( url ); }
+
+    /**
+     * Same as above except the argument is a URL.
+     *
+     * Use this function to set the string to be
+     * filtered when you construct an empty filter
+     * object.
+     *
+     * @param url the URL to be filtered.
+     */
+    void setData( const KURL& url ) { init( url ); }
+
+    /**
+     * Sets the absolute path to be used whenever the supplied
+     * data is a relative local URL.
+     *
+     * NOTE: This function should only be used for local resources,
+     * i.e. the "file:/" protocol. It is useful for specifying the
+     * absolute path in cases where the actual URL might be relative.
+     * meta object.  If deriving the path from a KURL, make sure you
+     * set the argument for this function to the result of calling
+     * path () instead of url ().
+     *
+     * @param abs_path  the abolute path to the local resource.
+     * @return true if absolute path is successfully set. Otherwise, false.
+     */
+    bool setAbsolutePath( const QString& abs_path );
+
+    /**
+     * Returns the absolute path if one has already been set.
+     * @return the absolute path, or QString::null
+     * @see hasAbsolutePath()
+     */
+    QString absolutePath() const;
+
+    /**
+     * Checks whether the supplied data had an absolute path.
+     * @return true if the supplied data has an absolute path
+     * @see absolutePath()
+     */
+    bool hasAbsolutePath() const;
+
+    /**
+     * Returns the command line options and arguments for a
+     * local resource when present.
+     *
+     * @return options and arguments when present, otherwise QString::null
+     */
+    QString argsAndOptions() const;
+
+    /**
+     * Checks whether the current data is a local resource with
+     * command line options and arguments.
+     * @return true if the current data has command line options and arguments
+     */
+    bool hasArgsAndOptions() const;
+
+    /**
+     * Returns the name of the icon that matches
+     * the current filtered URL.
+     *
+     * NOTE that this function will return a NULL
+     * string by default and when no associated icon
+     * is found.
+     *
+     * @return the name of the icon associated with the resource,
+     *         or QString::null if not found
+     */
+    QString iconName();
+
+    /**
+     * Check whether the provided uri is executable or not.
+     *
+     * Setting this to false ensures that typing the name of
+     * an executable does not start that application. This is
+     * useful in the location bar of a browser. The default
+     * value is true.
+     *
+     * @since 3.2
+     */
+    void setCheckForExecutables (bool check);
+
+    /**
+     * @return true if the filters should attempt to check whether the
+     * supplied uri is an executable. False otherwise.
+     *
+     * @since 3.2
+     */
+    bool checkForExecutables() const { return m_bCheckForExecutables; }
+
+    /**
+     * @return the string as typed by the user, before any URL processing is done
+     * @since 3.2
+     */
+    QString typedString() const;
+
+    /**
+     * Overloaded assigenment operator.
+     *
+     * This function allows you to easily assign a KURL
+     * to a KURIFilterData object.
+     *
+     * @return an instance of a KURIFilterData object.
+     */
+    KURIFilterData& operator=( const KURL& url ) { init( url ); return *this; }
+
+    /**
+     * Overloaded assigenment operator.
+     *
+     * This function allows you to easily assign a QString
+     * to a KURIFilterData object.
+     *
+     * @return an instance of a KURIFilterData object.
+     */
+    KURIFilterData& operator=( const QString& url ) { init( url ); return *this; }
+
+protected:
+
+    /**
+     * Initializes the KURIFilterData on construction.
+     * @param url the URL to initialize the object with
+     */
+    void init( const KURL& url);
+
+    /**
+     * Initializes the KURIFilterData on construction.
+     * @param url the URL to initialize the object with
+     */
+    void init( const QString& url = QString::null );
+
+private:
+    bool m_bCheckForExecutables;
+    bool m_bChanged;
+
+    QString m_strErrMsg;
+    QString m_strIconName;
+
+    KURL m_pURI;
+    URITypes m_iType;
+    KURIFilterDataPrivate *d;
+};
+
+
+/**
+ * Base class for URI filter plugins.
+ *
+ * This class applies a single filter to a URI.  All plugins designed
+ * to provide URI filtering service should inherit from this abstract
+ * class and provide a concrete implementation.
+ *
+ * All inheriting classes need to implement the pure virtual function
+ * filterURI.
+ *
+ * @short Abstract class for URI filter plugins.
+ */
+class KURIFilterPlugin : public QObject
+{
+    Q_OBJECT
+
+public:
+
+    /**
+     * Constructs a filter plugin with a given name and
+     * priority.
+     *
+     * @param parent the parent object, or 0 for no parent
+     * @param name the name of the plugin, or 0 for no name
+     * @param pri the priority of the plugin.
+     */
+    KURIFilterPlugin( QObject *parent = 0, const char *name = 0, double pri = 1.0 );
+
+    /**
+     * Returns the filter's name.
+     *
+     * @return A string naming the filter.
+     */
+    virtual QString name() const { return m_strName; }
+
+    /**
+     * Returns the filter's priority.
+     *
+     * Each filter has an assigned priority, a float from 0 to 1. Filters
+     * with the lowest priority are first given a chance to filter a URI.
+     *
+     * @return The priority of the filter.
+     */
+    virtual double priority() const { return m_dblPriority; }
+
+    /**
+     * Filters a URI.
+     *
+     * @param data the URI data to be filtered.
+     * @return A boolean indicating whether the URI has been changed.
+     */
+    virtual bool filterURI( KURIFilterData& data ) const = 0;
+
+    /**
+     * Creates a configuration module for the filter.
+     *
+     * It is the responsibility of the caller to delete the module
+     * once it is not needed anymore.
+     *
+     * @return A configuration module, 0 if the filter isn't configurable.
+     */
+    virtual KCModule *configModule( QWidget*, const char* ) const { return 0; }
+
+    /**
+     * Returns the name of the configuration module for the filter.
+     *
+     * @return the name of a configuration module or QString::null if none.
+     */
+    virtual QString configName() const { return name(); }
+
+protected:
+
+    /**
+     * Sets the the URL in @p data to @p uri.
+     */
+    void setFilteredURI ( KURIFilterData& data, const KURL& uri ) const;
+
+    /**
+     * Sets the error message in @p data to @p errormsg.
+     */
+    void setErrorMsg ( KURIFilterData& data, const QString& errmsg ) const {
+        data.m_strErrMsg = errmsg;
+    }
+
+    /**
+     * Sets the URI type in @p data to @p type.
+     */
+    void setURIType ( KURIFilterData& data, KURIFilterData::URITypes type) const {
+        data.m_iType = type;
+        data.m_bChanged = true;
+    }
+
+    /**
+     * Sets the arguments and options string in @p data
+     * to @p args if any were found during filterting.
+     */
+    void setArguments( KURIFilterData& data, const QString& args ) const;
+
+    QString m_strName;
+    double m_dblPriority;
+
+protected:
+    virtual void virtual_hook( int id, void* data );
+private:
+    class KURIFilterPluginPrivate *d;
+};
+
+
+/**
+ * A list of filter plugins.
+ */
+class KURIFilterPluginList : public QPtrList<KURIFilterPlugin>
+{
+public:
+    virtual int compareItems(Item a, Item b)
+    {
+      double diff = ((KURIFilterPlugin *) a)->priority() - ((KURIFilterPlugin *) b)->priority();
+      return diff < 0 ? -1 : (diff > 0 ? 1 : 0);
+    }
+
+private:
+    KURIFilterPrivate *d;
+
+};
+
+/**
+ * Manages the filtering of URIs.
+ *
+ * The intention of this plugin class is to allow people to extend the
+ * functionality of KURL without modifying it directly. This way KURL will
+ * remain a generic parser capable of parsing any generic URL that adheres
+ * to specifications.
+ *
+ * The KURIFilter class applies a number of filters to a URI and returns the
+ * filtered version whenever possible. The filters are implemented using
+ * plugins to provide easy extensibility of the filtering mechanism. New
+ * filters can be added in the future by simply inheriting from
+ * KURIFilterPlugin and implementing the KURIFilterPlugin::filterURI
+ * method.
+ *
+ * Use of this plugin-manager class is straight forward.  Since it is a
+ * singleton object, all you have to do is obtain an instance by doing
+ * @p KURIFilter::self() and use any of the public member functions to
+ * preform the filtering.
+ *
+ * \b Example
+ *
+ * To simply filter a given string:
+ *
+ * \code
+ * bool filtered = KURIFilter::self()->filterURI( "kde.org" );
+ * \endcode
+ *
+ * You can alternatively use a KURL:
+ *
+ * \code
+ * KURL url = "kde.org";
+ * bool filtered = KURIFilter::self()->filterURI( url );
+ * \endcode
+ *
+ * If you have a constant string or a constant URL, simply invoke the
+ * corresponding function to obtain the filtered string or URL instead
+ * of a boolean flag:
+ *
+ * \code
+ * QString u = KURIFilter::self()->filteredURI( "kde.org" );
+ * \endcode
+ *
+ * You can also restrict the filter(s) to be used by supplying
+ * the name of the filter(s) to use.  By defualt all available
+ * filters will be used. To use specific filters, add the names
+ * of the filters you want to use to a QStringList and invoke
+ * the appropriate filtering function. The examples below show
+ * the use of specific filters. The first one uses a single
+ * filter called kshorturifilter while the second example uses
+ * multiple filters:
+ *
+ * \code
+ * QString text = "kde.org";
+ * bool filtered = KURIFilter::self()->filterURI( text, "kshorturifilter" );
+ * \endcode
+ *
+ * \code
+ * QStringList list;
+ * list << "kshorturifilter" << "localdomainfilter";
+ * bool filtered = KURIFilter::self()->filterURI( text, list );
+ * \endcode
+ *
+ * KURIFilter also allows richer data exchange through a simple
+ * meta-object called @p KURIFilterData. Using this meta-object
+ * you can find out more information about the URL you want to
+ * filter. See KURIFilterData for examples and details.
+ *
+ * @short Filters a given URL into its proper format whenever possible.
+ */
+
+class KURIFilter
+{
+public:
+    /**
+     *  Destructor
+     */
+    ~KURIFilter ();
+
+    /**
+     * Returns an instance of KURIFilter.
+     */
+    static KURIFilter* self();
+
+    /**
+     * Filters the URI given by the object URIFilterData.
+     *
+     * The given URL is filtered based on the specified list of filters.
+     * If the list is empty all available filters would be used.
+     *
+     * @param data object that contains the URI to be filtered.
+     * @param filters specify the list of filters to be used.
+     *
+     * @return a boolean indicating whether the URI has been changed
+     */
+    bool filterURI( KURIFilterData& data, const QStringList& filters = QStringList() );
+
+    /**
+     * Filters the URI given by the URL.
+     *
+     * The given URL is filtered based on the specified list of filters.
+     * If the list is empty all available filters would be used.
+     *
+     * @param uri the URI to filter.
+     * @param filters specify the list of filters to be used.
+     *
+     * @return a boolean indicating whether the URI has been changed
+     */
+    bool filterURI( KURL &uri, const QStringList& filters = QStringList() );
+
+    /**
+     * Filters a string representing a URI.
+     *
+     * The given URL is filtered based on the specified list of filters.
+     * If the list is empty all available filters would be used.
+     *
+     * @param uri The URI to filter.
+     * @param filters specify the list of filters to be used.
+     *
+     * @return a boolean indicating whether the URI has been changed
+     */
+    bool filterURI( QString &uri, const QStringList& filters = QStringList() );
+
+    /**
+     * Returns the filtered URI.
+     *
+     * The given URL is filtered based on the specified list of filters.
+     * If the list is empty all available filters would be used.
+     *
+     * @param uri The URI to filter.
+     * @param filters specify the list of filters to be used.
+     *
+     * @return the filtered URI or null if it cannot be filtered
+     */
+    KURL filteredURI( const KURL &uri, const QStringList& filters = QStringList() );
+
+    /**
+     * Return a filtered string representation of a URI.
+     *
+     * The given URL is filtered based on the specified list of filters.
+     * If the list is empty all available filters would be used.
+     *
+     * @param uri the URI to filter.
+     * @param filters specify the list of filters to be used.
+     *
+     * @return the filtered URI or null if it cannot be filtered
+     */
+    QString filteredURI( const QString &uri, const QStringList& filters = QStringList() );
+
+    /**
+     * Return an iterator to iterate over all loaded
+     * plugins.
+     *
+     * @return a plugin iterator.
+     */
+    QPtrListIterator<KURIFilterPlugin> pluginsIterator() const;
+
+    /**
+     * Return a list of the names of all loaded plugins.
+     *
+     * @return a QStringList of plugin names
+     * @since 3.1
+     */
+    QStringList pluginNames() const;
+
+protected:
+
+    /**
+     * A protected constructor.
+     *
+     * This constructor creates a KURIFilter and
+     * initializes all plugins it can find by invoking
+     * loadPlugins.
+     */
+    KURIFilter();
+
+    /**
+     * Loads all allowed plugins.
+     *
+     * This function loads all filters that have not
+     * been disbled.
+     */
+    void loadPlugins();
+
+private:
+    static KURIFilter *m_self;
+    KURIFilterPluginList m_lstPlugins;
+    KURIFilterPrivate *d;
+};
+
+#endif
diff --git a/python/pykde/extra/kde331/selectdialog.h b/python/pykde/extra/kde331/selectdialog.h
new file mode 100644
index 00000000..e366e492
--- /dev/null
+++ b/python/pykde/extra/kde331/selectdialog.h
@@ -0,0 +1,87 @@
+/*
+    This file is part of libkresources.
+
+    Copyright (c) 2002 Tobias Koenig <tokoe@kde.org>
+    Copyright (c) 2002 Jan-Pascal van Best <janpascal@vanbest.org>
+    Copyright (c) 2003 Cornelius Schumacher <schumacher@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., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+
+#ifndef KRESOURCES_SELECTDIALOG_H
+#define KRESOURCES_SELECTDIALOG_H
+
+#include <qobject.h>
+#include <qptrlist.h>
+#include <qmap.h>
+
+#include <kdialog.h>
+
+class KListBox;
+
+namespace KRES {
+
+class Resource;
+
+/**
+ * Dialog for selecting a resource.
+ *
+ * Example:
+ *
+ * \code
+ *
+ * QPtrList<Resource> list = ... // can be retrived from KRES::Manager (e.g. KABC::AddressBook)
+ *
+ * KABC::Resource *res = KABC::SelectDialog::getResource( list, parentWdg );
+ * if ( !res ) {
+ *   // no resource selected
+ * } else {
+ *   // do something with resource
+ * }
+ * \endcode
+ */
+class SelectDialog
+{
+  public:
+    /**
+     * Constructor.
+     * @param list   The list of available resources
+     * @param parent The parent widget
+     * @param name   The name of the dialog
+     */
+    SelectDialog( QPtrList<Resource> list, QWidget *parent = 0,
+        const char *name = 0);
+
+    /**
+     * Returns selected resource.
+     */
+    Resource *resource();
+
+    /**
+     * Opens a dialog showing the available resources and returns the resource the
+     * user has selected. Returns 0, if the dialog was canceled.
+     */
+    static Resource *getResource( QPtrList<Resource> list, QWidget *parent = 0 );
+
+  private:
+    KListBox *mResourceId;
+
+    QMap<int, Resource*> mResourceMap;
+};
+
+}
+
+#endif