diff options
Diffstat (limited to 'extra/kde315')
| -rw-r--r-- | extra/kde315/kaccelaction.h | 564 | ||||
| -rw-r--r-- | extra/kde315/kaccelbase.h | 229 | ||||
| -rw-r--r-- | extra/kde315/kicontheme.h | 331 | ||||
| -rw-r--r-- | extra/kde315/kkeyserver_x11.h | 435 | ||||
| -rw-r--r-- | extra/kde315/konsole_part.h | 223 | ||||
| -rw-r--r-- | extra/kde315/kpanelmenu.h | 181 | ||||
| -rw-r--r-- | extra/kde315/krecentdirs.h | 68 | ||||
| -rw-r--r-- | extra/kde315/ksycocafactory.h | 137 | ||||
| -rw-r--r-- | extra/kde315/ktoolbarbutton.h | 317 | ||||
| -rw-r--r-- | extra/kde315/kurifilter.h | 602 |
10 files changed, 3087 insertions, 0 deletions
diff --git a/extra/kde315/kaccelaction.h b/extra/kde315/kaccelaction.h new file mode 100644 index 0000000..7a368a9 --- /dev/null +++ b/extra/kde315/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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, 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 @ref KShortcut. The user can configure and + * enable/disable them using @ref KKeyDialog. + * + * <pre> + * 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 + * </pre> + * @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 @ref 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 @ref 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 @ref 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 @ref 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 @ref 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 @ref 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/extra/kde315/kaccelbase.h b/extra/kde315/kaccelbase.h new file mode 100644 index 0000000..219eaf4 --- /dev/null +++ b/extra/kde315/kaccelbase.h @@ -0,0 +1,229 @@ +/* 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, 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 + * @ref KKeyChooser GUI. + * + * A @ref 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 + * @ref 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 @ref insertItem() is used only + * in the configuration dialog. + *<pre> + * 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(); + *</pre> + * + * If a shortcut has a menu entry as well, you could insert them like + * this. The example is again the @ref KStdAccel::Print from above. + * + * <pre> + * int id; + * id = popup->insertItem("&Print",this, SLOT(printDoc())); + * a->changeMenuAccel(popup, id, KStdAccel::Print ); + * </pre> + * + * 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 + * + * <pre> + * id = popup->insertItem(i18n"Scroll &up",this, SLOT(scrollUp())); + * a->changeMenuAccel(popup, id, "Scroll Up" ); + * </pre> + * + * Please keep the order right: First insert all functions in the + * acceleratior, then call a -> @ref readSettings() and @em then build your + * menu structure. + * + * @short Configurable key binding support. + * @version $Id: kaccelbase.h,v 1.22 2002/10/06 18:19:39 ellis 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 + * @ref KGlobal::config(). + * + * The group in which the configuration is stored can be + * set with @ref 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* ); + + 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/extra/kde315/kicontheme.h b/extra/kde315/kicontheme.h new file mode 100644 index 0000000..faf34ab --- /dev/null +++ b/extra/kde315/kicontheme.h @@ -0,0 +1,331 @@ +/* vi: ts=8 sts=4 sw=4 + * + * $Id: kicontheme.h,v 1.26.2.1 2003/09/21 20:10:28 mcamen 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, + /// medium sized icons for the desktop + SizeMedium=32, + /// large sized icons for the panel + SizeLarge=48 }; + + /** + * 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 @ref #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 @ref #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/extra/kde315/kkeyserver_x11.h b/extra/kde315/kkeyserver_x11.h new file mode 100644 index 0000000..d458922 --- /dev/null +++ b/extra/kde315/kkeyserver_x11.h @@ -0,0 +1,435 @@ +#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 }; + + struct CodeMod { int code, mod; }; + + /** + * 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 succesful, 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 succesful, 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 @ref KKey::ModFlag's. For example, Break requires a + * Ctrl to be valid. + * @return the required @ref 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 @ref 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 @ref 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 @ref 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 @ref KKey::ModFlag modifiers to + * a mask of ORed Qt key code modifiers. + * @param the mask of @ref KKey::ModFlag modifiers + * @param 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 @ref KKey::ModFlag modifiers to + * a mask of ORed X11 modifiers. + * @param the mask of @ref KKey::ModFlag modifiers + * @param 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 the mask of X11 modifiers + * @param 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 @ref KKey::ModFlag modifiers. + * @param the mask of X11 modifiers + * @param the mask of @ref 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 sym 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 @ref KKey::ModFlag modifiers to a + * user-readable string. + * @param mod the mask of ORed @ref 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/extra/kde315/konsole_part.h b/extra/kde315/konsole_part.h new file mode 100644 index 0000000..ba89800 --- /dev/null +++ b/extra/kde315/konsole_part.h @@ -0,0 +1,223 @@ +/* + 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, 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(); + + 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; + + 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; +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/extra/kde315/kpanelmenu.h b/extra/kde315/kpanelmenu.h new file mode 100644 index 0000000..1857f5d --- /dev/null +++ b/extra/kde315/kpanelmenu.h @@ -0,0 +1,181 @@ +/***************************************************************** + +Copyright (c) 1996-2000 the kicker authors. See file AUTHORS. + (c) 2001 Michael Goffioul <goffioul@imec.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; + +/** + * Base class to build dynamically loaded menu entries for the K-menu, or the panel. + * + * 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 @ref slotExec(). You also have to provide a factory + * object in your library, see @ref 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 <goffioul@imec.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 + * @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 + * @ref 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 @ref 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/extra/kde315/krecentdirs.h b/extra/kde315/krecentdirs.h new file mode 100644 index 0000000..71f771b --- /dev/null +++ b/extra/kde315/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/extra/kde315/ksycocafactory.h b/extra/kde315/ksycocafactory.h new file mode 100644 index 0000000..15554eb --- /dev/null +++ b/extra/kde315/ksycocafactory.h @@ -0,0 +1,137 @@ +/* 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., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + **/ + +#ifndef __ksycocafactory_h__ +#define __ksycocafactory_h__ "$Id: ksycocafactory.h,v 1.13 2002/09/21 15:07:27 tjansen 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); + + /** + * 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/extra/kde315/ktoolbarbutton.h b/extra/kde315/ktoolbarbutton.h new file mode 100644 index 0000000..121ecc6 --- /dev/null +++ b/extra/kde315/ktoolbarbutton.h @@ -0,0 +1,317 @@ +/* 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// $Id: ktoolbarbutton.h,v 1.26 2002/09/28 15:16:22 tjansen Exp $ +#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 @ref 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) + */ + 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 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) + */ + 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 @ref 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); + + /** + * @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); + + /** + * @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); +#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 @ref 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 @ref #generate is + * true. This function is preferred over @ref setPixmap + * + * @param icon The name of the active icon + * @param generate If true, then the other icons are automagically + * generated from this one + */ + void setIcon(const QString &icon, bool /*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); + + /** + * @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); +#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 @ref 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(); + + /** + * Give this button a popup menu. There will not be a delay when + * you press the button. Use @ref setDelayedPopup if you want that + * behavior. You can also make the popup-menu + * "sticky", i.e. visible until a selection is made or the mouse is + * clikced elsewhere, by simply setting the second argument to true. + * This "sticky" button feature allows you to make a selection without + * having to press and hold down the mouse while making a selection. + * + * @param p The new popup menu + * @param toggle if true, makes the button "sticky" (toggled) + */ + void setPopup (QPopupMenu *p, bool toggle = 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. You can also make the popup-menu + * "sticky", i.e. visible until a selection is made or the mouse is + * clikced elsewhere, by simply setting the second argument to true. + * This "sticky" button feature allows you to make a selection without + * having to press and hold down the mouse while making a selection. + * + * @param p the new popup menu + * @param toggle if true, makes the button "sticky" (toggled) + */ + void setDelayedPopup(QPopupMenu *p, bool toggle = 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 + * explicitely 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 @ref KToolBarButton objects. +* @internal +* @version $Id: ktoolbarbutton.h,v 1.26 2002/09/28 15:16:22 tjansen Exp $ +*/ +class KToolBarButtonList : public QIntDict<KToolBarButton> +{ +public: + KToolBarButtonList(); + ~KToolBarButtonList() {} +}; + +#endif diff --git a/extra/kde315/kurifilter.h b/extra/kde315/kurifilter.h new file mode 100644 index 0000000..2b62e4c --- /dev/null +++ b/extra/kde315/kurifilter.h @@ -0,0 +1,602 @@ +/* + * This file is part of the KDE libraries + * 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., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + **/ + +#ifndef __kurifilter_h__ +#define __kurifilter_h__ "$Id: kurifilter.h,v 1.27.2.1 2003/06/06 09:12:16 mueller Exp $" + +#include <qstringlist.h> +#include <qobject.h> + +#include <kurl.h> + +class KURIFilterPrivate; +class KURIFilterDataPrivate; + +class QStringList; +class KCModule; + +/** +* This is a basic message object used for exchanging filtering +* information between the filter plugins and the application +* whenever the application requires more information about the +* URI than just a filtered version of it. Any application can +* create an instance of this class and send it to @ref KURIFilter +* to have the filter plugins fill the necessary information. +* +* @sect Example +* <pre> +* QString text = "kde.org"; +* KURIFilterData d = text; +* bool filtered = KURIFilter::self()->filter( d ); +* if( filtered ) +* print ( "URI: %s\n"Filtered URI: %s\n URI Type: %i\n"Was Filtered: %i" +* text.latin1(), d.uri().url().latin1(), d.uriType(), filtered ); +* </pre> +* +* The above code should yield the following output: +* <pre> +* URI: kde.org +* Filtered URI: http://kde.org +* URI Type: 0 <== means NET_PROTOCOL +* Was Filtered: 1 <== means the URL was successfully filtered +* </pre> +* +* @short A message object for exchanging filtering URI info. +*/ + +class KURIFilterData +{ +friend class KURIFilterPlugin; + +public: + /** + * Describes the type of URI to be filtered. + * + * This enumerator prvoides the return value for + * @ref uriType. A brief description for each value: + * + * @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 + * @ref KURIFilter::filterURI() calls. + * + * @deprecated + */ + bool hasBeenFiltered() const { return m_bFiltered; } + + /** + * Returns the filtered or the original URL. + * + * This function returns the filtered url if one + * of the plugins sucessfully filtered the original + * URL. Otherwise, it returns the original URL. + * See @ref #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. + */ + 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 works only for a local resource and + * expects the absolute path to the relative URL set in this + * meta object. If you are extracting the absolute path from + * a KURL object, make sure you always set the argument below + * using KURL::path() instead of KURL::url() so that "file:/" + * would not be appended! Otherwise, the filter might not be + * able to make correct determination whether the relative URL + * locally exists! + * + * @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. + */ + QString absolutePath() const; + + /** + * Returns true if the supplied data has an absolute path. + */ + 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; + + /** + * Returns true if the current data is a local resource with + * 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 + */ + QString iconName(); + + /** + * 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. + */ + void init( const KURL& url = QString::null ); + +private: + bool m_bFiltered; + 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 functionalities + * should inherit from this abstract class and provide a + * specific filtering implementation. + * + * All inheriting classes need to implement the pure + * virtual function @ref filterURI. Otherwise, they + * would also become abstract. + * + * @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. + * @param name the name of the plugin. + * @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 responsability of the caller to delete the module + * once it is not needed anymore. + * + * @return A configuration module, @p null 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 @p 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; +}; + + +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 a URI. + * + * 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. That is, new filters can be added in + * the future by simply inheriting from @ref KURIFilterPlugin and + * implementing the @ref 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. + * + * @sect Example + * + * To simply filter a given string: + * <pre> + * bool filtered = KURIFilter::self()->filterURI( "kde.org" ); + * </pre> + * + * You can alternatively use a KURL: + * <pre> + * KURL url = "kde.org"; + * bool filtered = KURIFilter::self()->filterURI( url ); + * </pre> + * + * 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: + * <pre> + * QString u = KURIFilter::self()->filteredURI( "kde.org" ); + * </pre> + * + * You can also specify only specific filter(s) to be applied + * by supplying the name(s) of the filter(s). By defualt all + * filters that are found are loaded when the KURIFilter object + * is created will be used. These names are taken from the + * enteries in the \".desktop\" files. Here are a couple of + * examples: + * <pre> + * QString text = "kde.org"; + * bool filtered = KURIFilter::self()->filterURI( text, "KShortURIFilter" ); + * + * QStringList list; + * list << "KShortURIFilter" << "MyFilter"; + * bool filtered = KURIFilter::self()->filterURI( text, list ); + * </pre> + * + * 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 @ref KURIFilterData for examples and details. + * + * @short Filters a given URL into its proper format whenever possible. + */ + +class KURIFilter +{ +public: + /** + * Destructor + */ + ~KURIFilter (); + + /** + * Return a static instance of KURIFilter. + */ + static KURIFilter* self(); + + /** + * Filters the URI given by the object URIFilterData. + * + * This filters the given data based on the specified + * filter list. If the list is empty all avaliable + * filter plugins would be used. If not, only those + * given in the list are used. + * + * @param data object that contains the URI to be filtered. + * @param filters specify the list 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. + * + * This filters the given URL based on the specified + * filter list. If the list is empty all avaliable + * filter plugins would be used. If not, only those + * given in the list are 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. + * + * This filters the given string based on the specified + * filter list. If the list is empty all avaliable + * filter plugins would be used. If not, only those + * given in the list are used. + * + * @param uri The URI to filter. + * @param filters specify the list 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. + * + * This filters the given URL based on the specified + * filter list. If the list is empty all avaliable + * filter plugins would be used. If not, only those + * given in the list are used. + * + * @param uri The URI to filter. + * @param filters specify the list 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. + * + * This filters the given URL based on the specified + * filter list. If the list is empty all avaliable + * filter plugins would be used. If not, only those + * given in the list are used. + * + * @param uri the URI to filter. + * @param filters specify the list 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 + * + * @since 3.1 + * + * @return a QStringList of plugin names + */ + QStringList pluginNames() const; + +protected: + + /** + * A protected constructor. + * + * This constructor creates a KURIFilter and + * initializes all plugins it can find by invoking + * @ref loadPlugins. + */ + KURIFilter(); + + /** + * Loads all allowed plugins. + * + * This function loads all filters that have not + * been dis + */ + void loadPlugins(); + +private: + + static KURIFilter *m_self; + KURIFilterPluginList m_lstPlugins; + KURIFilterPrivate *d; + +}; + +#endif + |