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