• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

KDECore

kcompletion.h

Go to the documentation of this file.

/* This file is part of the KDE libraries
   Copyright (C) 1999,2000 Carsten Pfeiffer <pfeiffer@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 KCOMPLETION_H
#define KCOMPLETION_H

#include <qmap.h>
#include <qptrlist.h>
#include <qobject.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qguardedptr.h>

#include "kdelibs_export.h"
#include <kglobalsettings.h>
#include <ksortablevaluelist.h>
#include <kshortcut.h>

class KCompTreeNode;
class KCompletionPrivate;
class KCompletionBasePrivate;
class KCompletionMatchesWrapper;
class KCompletionMatches;
class QPopupMenu;

class KDECORE_EXPORT KCompletion : public QObject
{
    Q_ENUMS( CompOrder )
    Q_PROPERTY( CompOrder order READ order WRITE setOrder )
    Q_PROPERTY( bool ignoreCase READ ignoreCase WRITE setIgnoreCase )
    Q_PROPERTY( QStringList items READ items WRITE setItems )
    Q_OBJECT

public:
    enum CompOrder { Sorted,    
                     Insertion, 
                     Weighted   
    };

    KCompletion();

    // FIXME: copy constructor, assignment operator...

    virtual ~KCompletion();

    virtual QString makeCompletion( const QString& string );

    QStringList substringCompletion( const QString& string ) const;

    QString previousMatch();

    QString nextMatch();

    virtual const QString& lastMatch() const { return myLastMatch; }

    QStringList items() const;
    
    bool isEmpty() const;

    virtual void setCompletionMode( KGlobalSettings::Completion mode );

    KGlobalSettings::Completion completionMode() const {
        return myCompletionMode;
    }

    virtual void setOrder( CompOrder order );

    CompOrder order() const { return myOrder; }

    virtual void setIgnoreCase( bool ignoreCase );

    bool ignoreCase() const { return myIgnoreCase; }

    QStringList allMatches();

    QStringList allMatches( const QString& string );

    KCompletionMatches allWeightedMatches();

    KCompletionMatches allWeightedMatches( const QString& string );

    virtual void setEnableSounds( bool enable ) { myBeep = enable; }

    bool isSoundsEnabled() const { return myBeep; }

    bool hasMultipleMatches() const { return myHasMultipleMatches; }

#ifndef KDE_NO_COMPAT

    void enableSounds() { myBeep = true; }

    void disableSounds() { myBeep = false; }
#endif
    
public slots:
    void slotMakeCompletion( const QString& string ) {
        (void) makeCompletion( string );
    }

    void slotPreviousMatch() {
        (void) previousMatch();
    }

    void slotNextMatch() {
        (void) nextMatch();
    }

    // FIXME ###: KDE4: unify the nomenclature.  We have insertItems, addItem,
    //            setItems...
    void insertItems( const QStringList& items );

    virtual void setItems( const QStringList& list);

    void addItem( const QString& item);

    void addItem( const QString& item, uint weight );

    void removeItem( const QString& item);

    virtual void clear();


signals:
    void match( const QString& item);

    void matches( const QStringList& matchlist);

    void multipleMatches();

protected:
    virtual void postProcessMatch( QString *match ) const { Q_UNUSED(match) }

    virtual void postProcessMatches( QStringList * matches ) const { Q_UNUSED(matches)}

    virtual void postProcessMatches( KCompletionMatches * matches ) const {Q_UNUSED(matches)}

private:
    void            addWeightedItem( const QString& );
    QString         findCompletion( const QString& string );
    void            findAllCompletions( const QString&,
                                        KCompletionMatchesWrapper *matches,
                                        bool& hasMultipleMatches ) const;

    void extractStringsFromNode( const KCompTreeNode *,
                                 const QString& beginning,
                                 KCompletionMatchesWrapper *matches,
                                 bool addWeight = false ) const;
    void extractStringsFromNodeCI( const KCompTreeNode *,
                                   const QString& beginning,
                                   const QString& restString,
                                   KCompletionMatchesWrapper *matches) const;

    enum        BeepMode { NoMatch, PartialMatch, Rotation };
    void        doBeep( BeepMode ) const;

    KGlobalSettings::Completion myCompletionMode;

    CompOrder       myOrder;
    QString         myLastString;
    QString         myLastMatch;
    QString         myCurrentMatch;
    KCompTreeNode * myTreeRoot;
    QStringList     myRotations;
    bool            myBeep;
    bool            myIgnoreCase;
    bool            myHasMultipleMatches;
    uint            myRotationIndex;


protected:
    virtual void virtual_hook( int id, void* data );
private:
    KCompletionPrivate *d;
};

// some more helper stuff
typedef KSortableValueList<QString> KCompletionMatchesList;
class KCompletionMatchesPrivate;

class KDECORE_EXPORT KCompletionMatches : public KCompletionMatchesList
{
public:
    KCompletionMatches( bool sort );
    KCompletionMatches( const KCompletionMatchesWrapper& matches );
    ~KCompletionMatches();
    void removeDuplicates();
    QStringList list( bool sort = true ) const;
    bool sorting() const {
        return _sorting;
    }
private:
    bool _sorting;
    KCompletionMatchesPrivate* d;
};

class KDECORE_EXPORT KCompletionBase
{
public:
    enum KeyBindingType {
        TextCompletion,
        PrevCompletionMatch,
        NextCompletionMatch,
        SubstringCompletion
    };


    // Map for the key binding types mentioned above.
    typedef QMap<KeyBindingType, KShortcut> KeyBindingMap;

    KCompletionBase();

    virtual ~KCompletionBase();
    
    KCompletion* completionObject( bool hsig = true );
    
    virtual void setCompletionObject( KCompletion* compObj, bool hsig = true );

    virtual void setHandleSignals( bool handle );

    bool isCompletionObjectAutoDeleted() const {
        return m_delegate ? m_delegate->isCompletionObjectAutoDeleted() : m_bAutoDelCompObj;
    }

    void setAutoDeleteCompletionObject( bool autoDelete ) {
        if ( m_delegate )
            m_delegate->setAutoDeleteCompletionObject( autoDelete );
        else
            m_bAutoDelCompObj = autoDelete;
    }

    void setEnableSignals( bool enable ) {
        if ( m_delegate )
            m_delegate->setEnableSignals( enable );
        else
            m_bEmitSignals = enable;
    }

    bool handleSignals() const { return m_delegate ? m_delegate->handleSignals() : m_bHandleSignals; }

    bool emitSignals() const { return m_delegate ? m_delegate->emitSignals() : m_bEmitSignals; }

    virtual void setCompletionMode( KGlobalSettings::Completion mode );

    KGlobalSettings::Completion completionMode() const {
        return m_delegate ? m_delegate->completionMode() : m_iCompletionMode;
    }

    bool setKeyBinding( KeyBindingType item , const KShortcut& key );

    const KShortcut& getKeyBinding( KeyBindingType item ) const {
        return m_delegate ? m_delegate->getKeyBinding( item ) : m_keyMap[ item ];
    }

    void useGlobalKeyBindings();

    virtual void setCompletedText( const QString& text ) = 0;

    virtual void setCompletedItems( const QStringList& items ) = 0;

    KCompletion* compObj() const { return m_delegate ? m_delegate->compObj() : (KCompletion*) m_pCompObj; }

protected:
    KeyBindingMap getKeyBindings() const { return m_delegate ? m_delegate->getKeyBindings() : m_keyMap; }

    void setDelegate( KCompletionBase *delegate );

    KCompletionBase *delegate() const { return m_delegate; }

private:
    // This method simply sets the autodelete boolean for
    // the completion object, the emit signals and handle
    // signals internally flags to the provided values.
    void setup( bool, bool, bool );

    // Flag that determined whether the completion object
    // should be deleted when this object is destroyed.
    bool m_bAutoDelCompObj;
    // Determines whether this widget handles completion signals
    // internally or not
    bool m_bHandleSignals;
    // Determines whether this widget fires rotation signals
    bool m_bEmitSignals;
    // Stores the completion mode locally.
    KGlobalSettings::Completion m_iCompletionMode;
    // Pointer to Completion object.
    QGuardedPtr<KCompletion> m_pCompObj;
    // Keybindings
    KeyBindingMap m_keyMap;
    // we may act as a proxy to another KCompletionBase object
    KCompletionBase *m_delegate;

    // BCI
protected:
    virtual void virtual_hook( int id, void* data );
private:
    KCompletionBasePrivate *d;
};

#endif // KCOMPLETION_H

KDECore

Skip menu "KDECore"

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

API Reference

Skip menu "API Reference"

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

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