diff options
Diffstat (limited to 'tdecore/kcompletion.cpp')
| -rw-r--r-- | tdecore/kcompletion.cpp | 892 |
1 files changed, 892 insertions, 0 deletions
diff --git a/tdecore/kcompletion.cpp b/tdecore/kcompletion.cpp new file mode 100644 index 000000000..813b56027 --- /dev/null +++ b/tdecore/kcompletion.cpp @@ -0,0 +1,892 @@ +/* This file is part of the KDE libraries + Copyright (C) 1999,2000,2001 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. +*/ + + +#include <kapplication.h> +#include <kdebug.h> +#include <klocale.h> +#include <knotifyclient.h> +#include <kglobal.h> + +#include <tqptrvector.h> + +#include "kcompletion.h" +#include "kcompletion_private.h" + + +class KCompletionPrivate +{ +public: + // not a member to avoid #including kcompletion_private.h from kcompletion.h + // list used for nextMatch() and previousMatch() + KCompletionMatchesWrapper matches; +}; + +KCompletion::KCompletion() +{ + d = new KCompletionPrivate; + + myCompletionMode = KGlobalSettings::completionMode(); + myTreeRoot = new KCompTreeNode; + myBeep = true; + myIgnoreCase = false; + myHasMultipleMatches = false; + myRotationIndex = 0; + setOrder( Insertion ); +} + +KCompletion::~KCompletion() +{ + delete d; + delete myTreeRoot; +} + +void KCompletion::setOrder( CompOrder order ) +{ + myOrder = order; + d->matches.setSorting( order == Weighted ); +} + +void KCompletion::setIgnoreCase( bool ignoreCase ) +{ + myIgnoreCase = ignoreCase; +} + +void KCompletion::setItems( const TQStringList& items ) +{ + clear(); + insertItems( items ); +} + + +void KCompletion::insertItems( const TQStringList& items ) +{ + bool weighted = (myOrder == Weighted); + TQStringList::ConstIterator it; + if ( weighted ) { // determine weight + for ( it = items.begin(); it != items.end(); ++it ) + addWeightedItem( *it ); + } + else { + for ( it = items.begin(); it != items.end(); ++it ) + addItem( *it, 0 ); + } +} + +TQStringList KCompletion::items() const +{ + KCompletionMatchesWrapper list; // unsorted + bool addWeight = (myOrder == Weighted); + extractStringsFromNode( myTreeRoot, TQString::null, &list, addWeight ); + + return list.list(); +} + +bool KCompletion::isEmpty() const +{ + return (myTreeRoot->childrenCount() == 0); +} + +void KCompletion::addItem( const TQString& item ) +{ + d->matches.clear(); + myRotationIndex = 0; + myLastString = TQString::null; + + addItem( item, 0 ); +} + +void KCompletion::addItem( const TQString& item, uint weight ) +{ + if ( item.isEmpty() ) + return; + + KCompTreeNode *node = myTreeRoot; + uint len = item.length(); + + bool sorted = (myOrder == Sorted); + bool weighted = ((myOrder == Weighted) && weight > 1); + + // knowing the weight of an item, we simply add this weight to all of its + // nodes. + + for ( uint i = 0; i < len; i++ ) { + node = node->insert( item.tqat(i), sorted ); + if ( weighted ) + node->confirm( weight -1 ); // node->insert() sets weighting to 1 + } + + // add 0x0-item as delimiter with evtl. weight + node = node->insert( 0x0, true ); + if ( weighted ) + node->confirm( weight -1 ); +// qDebug("*** added: %s (%i)", item.latin1(), node->weight()); +} + +void KCompletion::addWeightedItem( const TQString& item ) +{ + if ( myOrder != Weighted ) { + addItem( item, 0 ); + return; + } + + uint len = item.length(); + uint weight = 0; + + // find out the weighting of this item (appended to the string as ":num") + int index = item.findRev(':'); + if ( index > 0 ) { + bool ok; + weight = item.mid( index + 1 ).toUInt( &ok ); + if ( !ok ) + weight = 0; + + len = index; // only insert until the ':' + } + + addItem( item.left( len ), weight ); + return; +} + + +void KCompletion::removeItem( const TQString& item ) +{ + d->matches.clear(); + myRotationIndex = 0; + myLastString = TQString::null; + + myTreeRoot->remove( item ); +} + + +void KCompletion::clear() +{ + d->matches.clear(); + myRotationIndex = 0; + myLastString = TQString::null; + + delete myTreeRoot; + myTreeRoot = new KCompTreeNode; +} + + +TQString KCompletion::makeCompletion( const TQString& string ) +{ + if ( myCompletionMode == KGlobalSettings::CompletionNone ) + return TQString::null; + + //kdDebug(0) << "KCompletion: completing: " << string << endl; + + d->matches.clear(); + myRotationIndex = 0; + myHasMultipleMatches = false; + myLastMatch = myCurrentMatch; + + // in Shell-completion-mode, emit all matches when we get the same + // complete-string twice + if ( myCompletionMode == KGlobalSettings::CompletionShell && + string == myLastString ) { + // Don't use d->matches since calling postProcessMatches() + // on d->matches here would interfere with call to + // postProcessMatch() during rotation + + findAllCompletions( string, &d->matches, myHasMultipleMatches ); + TQStringList l = d->matches.list(); + postProcessMatches( &l ); + emit matches( l ); + + if ( l.isEmpty() ) + doBeep( NoMatch ); + + return TQString::null; + } + + TQString completion; + // in case-insensitive popup mode, we search all completions at once + if ( myCompletionMode == KGlobalSettings::CompletionPopup || + myCompletionMode == KGlobalSettings::CompletionPopupAuto ) { + findAllCompletions( string, &d->matches, myHasMultipleMatches ); + if ( !d->matches.isEmpty() ) + completion = d->matches.first(); + } + else + completion = findCompletion( string ); + + if ( myHasMultipleMatches ) + emit multipleMatches(); + + myLastString = string; + myCurrentMatch = completion; + + postProcessMatch( &completion ); + + if ( !string.isEmpty() ) { // only emit match when string is not empty + //kdDebug(0) << "KCompletion: Match: " << completion << endl; + emit match( completion ); + } + + if ( completion.isNull() ) + doBeep( NoMatch ); + + return completion; +} + + +TQStringList KCompletion::substringCompletion( const TQString& string ) const +{ + // get all items in the tree, possibly in sorted order + bool sorted = (myOrder == Weighted); + KCompletionMatchesWrapper allItems( sorted ); + extractStringsFromNode( myTreeRoot, TQString::null, &allItems, false ); + + TQStringList list = allItems.list(); + + // subStringMatches is invoked manually, via a shortcut, so we should + // beep here, if necessary. + if ( list.isEmpty() ) { + doBeep( NoMatch ); + return list; + } + + if ( string.isEmpty() ) { // shortcut + postProcessMatches( &list ); + return list; + } + + TQStringList matches; + TQStringList::ConstIterator it = list.begin(); + + for( ; it != list.end(); ++it ) { + TQString item = *it; + if ( item.find( string, 0, false ) != -1 ) { // always case insensitive + matches.append( item ); + } + } + + postProcessMatches( &matches ); + + if ( matches.isEmpty() ) + doBeep( NoMatch ); + + return matches; +} + + +void KCompletion::setCompletionMode( KGlobalSettings::Completion mode ) +{ + myCompletionMode = mode; +} + +TQStringList KCompletion::allMatches() +{ + // Don't use d->matches since calling postProcessMatches() + // on d->matches here would interfere with call to + // postProcessMatch() during rotation + KCompletionMatchesWrapper matches( myOrder == Weighted ); + bool dummy; + findAllCompletions( myLastString, &matches, dummy ); + TQStringList l = matches.list(); + postProcessMatches( &l ); + return l; +} + +KCompletionMatches KCompletion::allWeightedMatches() +{ + // Don't use d->matches since calling postProcessMatches() + // on d->matches here would interfere with call to + // postProcessMatch() during rotation + KCompletionMatchesWrapper matches( myOrder == Weighted ); + bool dummy; + findAllCompletions( myLastString, &matches, dummy ); + KCompletionMatches ret( matches ); + postProcessMatches( &ret ); + return ret; +} + +TQStringList KCompletion::allMatches( const TQString &string ) +{ + KCompletionMatchesWrapper matches( myOrder == Weighted ); + bool dummy; + findAllCompletions( string, &matches, dummy ); + TQStringList l = matches.list(); + postProcessMatches( &l ); + return l; +} + +KCompletionMatches KCompletion::allWeightedMatches( const TQString &string ) +{ + KCompletionMatchesWrapper matches( myOrder == Weighted ); + bool dummy; + findAllCompletions( string, &matches, dummy ); + KCompletionMatches ret( matches ); + postProcessMatches( &ret ); + return ret; +} + +///////////////////////////////////////////////////// +///////////////// tree operations /////////////////// + + +TQString KCompletion::nextMatch() +{ + TQString completion; + myLastMatch = myCurrentMatch; + + if ( d->matches.isEmpty() ) { + findAllCompletions( myLastString, &d->matches, myHasMultipleMatches ); + completion = d->matches.first(); + myCurrentMatch = completion; + myRotationIndex = 0; + postProcessMatch( &completion ); + emit match( completion ); + return completion; + } + + TQStringList matches = d->matches.list(); + myLastMatch = matches[ myRotationIndex++ ]; + + if ( myRotationIndex == matches.count() -1 ) + doBeep( Rotation ); // indicate last matching item -> rotating + + else if ( myRotationIndex == matches.count() ) + myRotationIndex = 0; + + completion = matches[ myRotationIndex ]; + myCurrentMatch = completion; + postProcessMatch( &completion ); + emit match( completion ); + return completion; +} + + + +TQString KCompletion::previousMatch() +{ + TQString completion; + myLastMatch = myCurrentMatch; + + if ( d->matches.isEmpty() ) { + findAllCompletions( myLastString, &d->matches, myHasMultipleMatches ); + completion = d->matches.last(); + myCurrentMatch = completion; + myRotationIndex = 0; + postProcessMatch( &completion ); + emit match( completion ); + return completion; + } + + TQStringList matches = d->matches.list(); + myLastMatch = matches[ myRotationIndex ]; + if ( myRotationIndex == 1 ) + doBeep( Rotation ); // indicate first item -> rotating + + else if ( myRotationIndex == 0 ) + myRotationIndex = matches.count(); + + myRotationIndex--; + + completion = matches[ myRotationIndex ]; + myCurrentMatch = completion; + postProcessMatch( &completion ); + emit match( completion ); + return completion; +} + + + +// tries to complete "string" from the tree-root +TQString KCompletion::findCompletion( const TQString& string ) +{ + TQChar ch; + TQString completion; + const KCompTreeNode *node = myTreeRoot; + + // start at the tree-root and try to find the search-string + for( uint i = 0; i < string.length(); i++ ) { + ch = string.tqat( i ); + node = node->find( ch ); + + if ( node ) + completion += ch; + else + return TQString::null; // no completion + } + + // Now we have the last node of the to be completed string. + // Follow it as long as it has exactly one child (= longest possible + // completion) + + while ( node->childrenCount() == 1 ) { + node = node->firstChild(); + if ( !node->isNull() ) + completion += *node; + } + // if multiple matches and auto-completion mode + // -> find the first complete match + if ( node && node->childrenCount() > 1 ) { + myHasMultipleMatches = true; + + if ( myCompletionMode == KGlobalSettings::CompletionAuto ) { + myRotationIndex = 1; + if (myOrder != Weighted) { + while ( (node = node->firstChild()) ) { + if ( !node->isNull() ) + completion += *node; + else + break; + } + } + else { + // don't just find the "first" match, but the one with the + // highest priority + + const KCompTreeNode* temp_node = 0L; + while(1) { + int count = node->childrenCount(); + temp_node = node->firstChild(); + uint weight = temp_node->weight(); + const KCompTreeNode* hit = temp_node; + for( int i = 1; i < count; i++ ) { + temp_node = node->tqchildAt(i); + if( temp_node->weight() > weight ) { + hit = temp_node; + weight = hit->weight(); + } + } + // 0x0 has the highest priority -> we have the best match + if ( hit->isNull() ) + break; + + node = hit; + completion += *node; + } + } + } + + else + doBeep( PartialMatch ); // partial match -> beep + } + + return completion; +} + + +void KCompletion::findAllCompletions(const TQString& string, + KCompletionMatchesWrapper *matches, + bool& hasMultipleMatches) const +{ + //kdDebug(0) << "*** finding all completions for " << string << endl; + + if ( string.isEmpty() ) + return; + + if ( myIgnoreCase ) { // case insensitive completion + extractStringsFromNodeCI( myTreeRoot, TQString::null, string, matches ); + hasMultipleMatches = (matches->count() > 1); + return; + } + + TQChar ch; + TQString completion; + const KCompTreeNode *node = myTreeRoot; + + // start at the tree-root and try to find the search-string + for( uint i = 0; i < string.length(); i++ ) { + ch = string.tqat( i ); + node = node->find( ch ); + + if ( node ) + completion += ch; + else + return; // no completion -> return empty list + } + + // Now we have the last node of the to be completed string. + // Follow it as long as it has exactly one child (= longest possible + // completion) + + while ( node->childrenCount() == 1 ) { + node = node->firstChild(); + if ( !node->isNull() ) + completion += *node; + // kdDebug() << completion << node->latin1(); + } + + + // there is just one single match) + if ( node->childrenCount() == 0 ) + matches->append( node->weight(), completion ); + + else { + // node has more than one child + // -> recursively find all remaining completions + hasMultipleMatches = true; + extractStringsFromNode( node, completion, matches ); + } +} + + +void KCompletion::extractStringsFromNode( const KCompTreeNode *node, + const TQString& beginning, + KCompletionMatchesWrapper *matches, + bool addWeight ) const +{ + if ( !node || !matches ) + return; + + // kDebug() << "Beginning: " << beginning << endl; + const KCompTreeChildren *list = node->children(); + TQString string; + TQString w; + + // loop thru all children + for ( KCompTreeNode *cur = list->begin(); cur ; cur = cur->next) { + string = beginning; + node = cur; + if ( !node->isNull() ) + string += *node; + + while ( node && node->childrenCount() == 1 ) { + node = node->firstChild(); + if ( node->isNull() ) + break; + string += *node; + } + + if ( node && node->isNull() ) { // we found a leaf + if ( addWeight ) { + // add ":num" to the string to store the weighting + string += ':'; + w.setNum( node->weight() ); + string.append( w ); + } + matches->append( node->weight(), string ); + } + + // recursively find all other strings. + if ( node && node->childrenCount() > 1 ) + extractStringsFromNode( node, string, matches, addWeight ); + } +} + +void KCompletion::extractStringsFromNodeCI( const KCompTreeNode *node, + const TQString& beginning, + const TQString& restString, + KCompletionMatchesWrapper *matches ) const +{ + if ( restString.isEmpty() ) { + extractStringsFromNode( node, beginning, matches, false /*noweight*/ ); + return; + } + + TQChar ch1 = restString.tqat(0); + TQString newRest = restString.mid(1); + KCompTreeNode *child1, *child2; + + child1 = node->find( ch1 ); // the correct match + if ( child1 ) + extractStringsFromNodeCI( child1, beginning + *child1, newRest, + matches ); + + // append the case insensitive matches, if available + if ( ch1.isLetter() ) { + // find out if we have to lower or upper it. Is there a better way? + TQChar ch2 = ch1.lower(); + if ( ch1 == ch2 ) + ch2 = ch1.upper(); + if ( ch1 != ch2 ) { + child2 = node->find( ch2 ); + if ( child2 ) + extractStringsFromNodeCI( child2, beginning + *child2, newRest, + matches ); + } + } +} + +void KCompletion::doBeep( BeepMode mode ) const +{ + if ( !myBeep ) + return; + + TQString text, event; + + switch ( mode ) { + case Rotation: + event = TQString::tqfromLatin1("Textcompletion: rotation"); + text = i18n("You reached the end of the list\nof matching items.\n"); + break; + case PartialMatch: + if ( myCompletionMode == KGlobalSettings::CompletionShell || + myCompletionMode == KGlobalSettings::CompletionMan ) { + event = TQString::tqfromLatin1("Textcompletion: partial match"); + text = i18n("The completion is ambiguous, more than one\nmatch is available.\n"); + } + break; + case NoMatch: + if ( myCompletionMode == KGlobalSettings::CompletionShell ) { + event = TQString::tqfromLatin1("Textcompletion: no match"); + text = i18n("There is no matching item available.\n"); + } + break; + } + + if ( !text.isEmpty() ) + KNotifyClient::event( event, text ); +} + + +///////////////////////////////// +///////// + + +// Implements the tree. Every node is a TQChar and has a list of children, which +// are Nodes as well. +// TQChar( 0x0 ) is used as the delimiter of a string; the last child of each +// inserted string is 0x0. + +KCompTreeNode::~KCompTreeNode() +{ + // delete all children + KCompTreeNode *cur = myChildren.begin(); + while (cur) { + KCompTreeNode * next = cur->next; + delete myChildren.remove(cur); + cur = next; + } +} + + +// Adds a child-node "ch" to this node. If such a node is already existant, +// it will not be created. Returns the new/existing node. +KCompTreeNode * KCompTreeNode::insert( const TQChar& ch, bool sorted ) +{ + KCompTreeNode *child = find( ch ); + if ( !child ) { + child = new KCompTreeNode( ch ); + + // FIXME, first (slow) sorted insertion implementation + if ( sorted ) { + KCompTreeNode * prev = 0; + KCompTreeNode * cur = myChildren.begin(); + while ( cur ) { + if ( ch > *cur ) { + prev = cur; + cur = cur->next; + } else + break; + } + if (prev) + myChildren.insert( prev, child ); + else + myChildren.prepend(child); + } + + else + myChildren.append( child ); + } + + // implicit weighting: the more often an item is inserted, the higher + // priority it gets. + child->confirm(); + + return child; +} + + +// Iteratively removes a string from the tree. The nicer recursive +// version apparently was a little memory hungry (see #56757) +void KCompTreeNode::remove( const TQString& str ) +{ + TQString string = str; + string += TQChar(0x0); + + TQPtrVector<KCompTreeNode> deletables( string.length() + 1 ); + + KCompTreeNode *child = 0L; + KCompTreeNode *parent = this; + deletables.insert( 0, parent ); + + uint i = 0; + for ( ; i < string.length(); i++ ) + { + child = parent->find( string.tqat( i ) ); + if ( child ) + deletables.insert( i + 1, child ); + else + break; + + parent = child; + } + + for ( ; i >= 1; i-- ) + { + parent = deletables.tqat( i - 1 ); + child = deletables.tqat( i ); + if ( child->myChildren.count() == 0 ) + delete parent->myChildren.remove( child ); + } +} + +TQStringList KCompletionMatchesWrapper::list() const +{ + if ( sortedList && dirty ) { + sortedList->sort(); + dirty = false; + + stringList.clear(); + + // high weight == sorted last -> reverse the sorting here + TQValueListConstIterator<KSortableItem<TQString> > it; + for ( it = sortedList->begin(); it != sortedList->end(); ++it ) + stringList.prepend( (*it).value() ); + } + + return stringList; +} + +KCompletionMatches::KCompletionMatches( bool sort_P ) + : _sorting( sort_P ) +{ +} + +KCompletionMatches::KCompletionMatches( const KCompletionMatchesWrapper& matches ) + : _sorting( matches.sorting()) +{ + if( matches.sortedList != 0L ) + KCompletionMatchesList::operator=( *matches.sortedList ); + else { + TQStringList l = matches.list(); + for( TQStringList::ConstIterator it = l.begin(); + it != l.end(); + ++it ) + prepend( KSortableItem<TQString, int>( 1, *it ) ); + } +} + +KCompletionMatches::~KCompletionMatches() +{ +} + +TQStringList KCompletionMatches::list( bool sort_P ) const +{ + if( _sorting && sort_P ) + const_cast< KCompletionMatches* >( this )->sort(); + TQStringList stringList; + // high weight == sorted last -> reverse the sorting here + for ( ConstIterator it = begin(); it != end(); ++it ) + stringList.prepend( (*it).value() ); + return stringList; +} + +void KCompletionMatches::removeDuplicates() +{ + Iterator it1, it2; + for ( it1 = begin(); it1 != end(); ++it1 ) { + for ( (it2 = it1), ++it2; it2 != end();) { + if( (*it1).value() == (*it2).value()) { + // use the max height + (*it1).first = kMax( (*it1).index(), (*it2).index()); + it2 = remove( it2 ); + continue; + } + ++it2; + } + } +} + +void KCompTreeNodeList::append(KCompTreeNode *item) +{ + m_count++; + if (!last) { + last = item; + last->next = 0; + first = item; + return; + } + last->next = item; + item->next = 0; + last = item; +} + +void KCompTreeNodeList::prepend(KCompTreeNode *item) +{ + m_count++; + if (!last) { + last = item; + last->next = 0; + first = item; + return; + } + item->next = first; + first = item; +} + +void KCompTreeNodeList::insert(KCompTreeNode *after, KCompTreeNode *item) +{ + if (!after) { + append(item); + return; + } + + m_count++; + + item->next = after->next; + after->next = item; + + if (after == last) + last = item; +} + +KCompTreeNode *KCompTreeNodeList::remove(KCompTreeNode *item) +{ + if (!first || !item) + return 0; + KCompTreeNode *cur = 0; + + if (item == first) + first = first->next; + else { + cur = first; + while (cur && cur->next != item) cur = cur->next; + if (!cur) + return 0; + cur->next = item->next; + } + if (item == last) + last = cur; + m_count--; + return item; +} + +KCompTreeNode *KCompTreeNodeList::tqat(uint index) const +{ + KCompTreeNode *cur = first; + while (index-- && cur) cur = cur->next; + return cur; +} + +KZoneAllocator KCompTreeNode::alloc(8192); + +void KCompletion::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +void KCompletionBase::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +#include "kcompletion.moc" |