kcompletion.h

/* 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 <tqmap.h>
#include <tqptrlist.h>
#include <tqobject.h>
#include <tqstring.h>
#include <tqstringlist.h>
#include <tqguardedptr.h>
 
#include "tdelibs_export.h"
#include <tdeglobalsettings.h>
#include <ksortablevaluelist.h>
#include <tdeshortcut.h>
 
class TDECompTreeNode;
class TDECompletionPrivate;
class TDECompletionBasePrivate;
class TDECompletionMatchesWrapper;
class TDECompletionMatches;
class TQPopupMenu;
 
class TDECORE_EXPORT TDECompletion : public TQObject
{
    TQ_ENUMS( CompOrder )
    TQ_PROPERTY( CompOrder order READ order WRITE setOrder )
    TQ_PROPERTY( bool ignoreCase READ ignoreCase WRITE setIgnoreCase )
    TQ_PROPERTY( TQStringList items READ items WRITE setItems )
    TQ_OBJECT
 
public:
    enum CompOrder { Sorted,    
                     Insertion, 
                     Weighted   
    };
 
    TDECompletion();
 
    // FIXME: copy constructor, assignment operator...
 
    virtual ~TDECompletion();
 
    virtual TQString makeCompletion( const TQString& string );
 
    TQStringList substringCompletion( const TQString& string ) const;
 
    TQString previousMatch();
 
    TQString nextMatch();
 
    virtual const TQString& lastMatch() const { return myLastMatch; }
 
    TQStringList items() const;
    
    bool isEmpty() const;
 
    virtual void setCompletionMode( TDEGlobalSettings::Completion mode );
 
    TDEGlobalSettings::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; }
 
    TQStringList allMatches();
 
    TQStringList allMatches( const TQString& string );
 
    TDECompletionMatches allWeightedMatches();
 
    TDECompletionMatches allWeightedMatches( const TQString& 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 TQString& 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 TQStringList& items );
 
    virtual void setItems( const TQStringList& list);
 
    void addItem( const TQString& item);
 
    void addItem( const TQString& item, uint weight );
 
    void removeItem( const TQString& item);
 
    virtual void clear();
 
 
signals:
    void match( const TQString& item);
 
    void matches( const TQStringList& matchlist);
 
    void multipleMatches();
 
protected:
    virtual void postProcessMatch( TQString *match ) const { Q_UNUSED(match) }
 
    virtual void postProcessMatches( TQStringList * matches ) const { Q_UNUSED(matches)}
 
    virtual void postProcessMatches( TDECompletionMatches * matches ) const {Q_UNUSED(matches)}
 
private:
    void            addWeightedItem( const TQString& );
    TQString         findCompletion( const TQString& string );
    void            findAllCompletions( const TQString&,
                                        TDECompletionMatchesWrapper *matches,
                                        bool& hasMultipleMatches ) const;
 
    void extractStringsFromNode( const TDECompTreeNode *,
                                 const TQString& beginning,
                                 TDECompletionMatchesWrapper *matches,
                                 bool addWeight = false ) const;
    void extractStringsFromNodeCI( const TDECompTreeNode *,
                                   const TQString& beginning,
                                   const TQString& restString,
                                   TDECompletionMatchesWrapper *matches) const;
 
    enum        BeepMode { NoMatch, PartialMatch, Rotation };
    void        doBeep( BeepMode ) const;
 
    TDEGlobalSettings::Completion myCompletionMode;
 
    CompOrder       myOrder;
    TQString         myLastString;
    TQString         myLastMatch;
    TQString         myCurrentMatch;
    TDECompTreeNode * myTreeRoot;
    TQStringList     myRotations;
    bool            myBeep;
    bool            myIgnoreCase;
    bool            myHasMultipleMatches;
    uint            myRotationIndex;
 
 
protected:
    virtual void virtual_hook( int id, void* data );
private:
    TDECompletionPrivate *d;
};
 
// some more helper stuff
typedef KSortableValueList<TQString> TDECompletionMatchesList;
class TDECompletionMatchesPrivate;
 
class TDECORE_EXPORT TDECompletionMatches : public TDECompletionMatchesList
{
public:
    TDECompletionMatches( bool sort );
    TDECompletionMatches( const TDECompletionMatchesWrapper& matches );
    ~TDECompletionMatches();
    void removeDuplicates();
    TQStringList list( bool sort = true ) const;
    bool sorting() const {
        return _sorting;
    }
private:
    bool _sorting;
    TDECompletionMatchesPrivate* d;
};
 
class TDECORE_EXPORT TDECompletionBase
{
public:
    enum KeyBindingType {
        TextCompletion,
        PrevCompletionMatch,
        NextCompletionMatch,
        SubstringCompletion
    };
 
 
    // Map for the key binding types mentioned above.
    typedef TQMap<KeyBindingType, TDEShortcut> KeyBindingMap;
 
    TDECompletionBase();
 
    virtual ~TDECompletionBase();
    
    TDECompletion* completionObject( bool hsig = true );
    
    virtual void setCompletionObject( TDECompletion* 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( TDEGlobalSettings::Completion mode );
 
    TDEGlobalSettings::Completion completionMode() const {
        return m_delegate ? m_delegate->completionMode() : m_iCompletionMode;
    }
 
    bool setKeyBinding( KeyBindingType item , const TDEShortcut& key );
 
    const TDEShortcut& getKeyBinding( KeyBindingType item ) const {
        return m_delegate ? m_delegate->getKeyBinding( item ) : m_keyMap[ item ];
    }
 
    void useGlobalKeyBindings();
 
    virtual void setCompletedText( const TQString& text ) = 0;
 
    virtual void setCompletedItems( const TQStringList& items ) = 0;
 
    TDECompletion* compObj() const { return m_delegate ? m_delegate->compObj() : (TDECompletion*) m_pCompObj; }
 
protected:
    KeyBindingMap getKeyBindings() const { return m_delegate ? m_delegate->getKeyBindings() : m_keyMap; }
 
    void setDelegate( TDECompletionBase *delegate );
 
    TDECompletionBase *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.
    TDEGlobalSettings::Completion m_iCompletionMode;
    // Pointer to Completion object.
    TQGuardedPtr<TDECompletion> m_pCompObj;
    // Keybindings
    KeyBindingMap m_keyMap;
    // we may act as a proxy to another TDECompletionBase object
    TDECompletionBase *m_delegate;
 
    // BCI
protected:
    virtual void virtual_hook( int id, void* data );
private:
    TDECompletionBasePrivate *d;
};
 
#endif // KCOMPLETION_H