summaryrefslogtreecommitdiffstats
path: root/tdeui/kcombobox.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <[email protected]>2011-11-06 15:56:40 -0600
committerTimothy Pearson <[email protected]>2011-11-06 15:56:40 -0600
commite16866e072f94410321d70daedbcb855ea878cac (patch)
treeee3f52eabde7da1a0e6ca845fb9c2813cf1558cf /tdeui/kcombobox.cpp
parenta58c20c1a7593631a1b50213c805507ebc16adaf (diff)
downloadtdelibs-e16866e072f94410321d70daedbcb855ea878cac.tar.gz
tdelibs-e16866e072f94410321d70daedbcb855ea878cac.zip
Actually move the kde files that were renamed in the last commit
Diffstat (limited to 'tdeui/kcombobox.cpp')
-rw-r--r--tdeui/kcombobox.cpp797
1 files changed, 797 insertions, 0 deletions
diff --git a/tdeui/kcombobox.cpp b/tdeui/kcombobox.cpp
new file mode 100644
index 000000000..2b6b0098c
--- /dev/null
+++ b/tdeui/kcombobox.cpp
@@ -0,0 +1,797 @@
+/* This file is part of the KDE libraries
+
+ Copyright (c) 2000,2001 Dawit Alemayehu <[email protected]>
+ Copyright (c) 2000,2001 Carsten Pfeiffer <[email protected]>
+ Copyright (c) 2000 Stefan Schimanski <[email protected]>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License (LGPL) 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser 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 <tqclipboard.h>
+#include <tqlistbox.h>
+#include <tqpopupmenu.h>
+#include <tqapplication.h>
+
+#include <kcompletionbox.h>
+#include <kcursor.h>
+#include <kiconloader.h>
+#include <kicontheme.h>
+#include <klistviewsearchline.h>
+#include <klineedit.h>
+#include <klocale.h>
+#include <knotifyclient.h>
+#include <kpixmapprovider.h>
+#include <kstdaccel.h>
+#include <kurl.h>
+#include <kurldrag.h>
+
+#include <kdebug.h>
+
+#include "kcombobox.h"
+
+#include <stdlib.h> // getenv
+
+class KComboBox::KComboBoxPrivate
+{
+public:
+ KComboBoxPrivate() : klineEdit(0L)
+ {
+ }
+ ~KComboBoxPrivate()
+ {
+ }
+
+ KLineEdit *klineEdit;
+};
+
+KComboBox::KComboBox( TQWidget *parent, const char *name )
+ : TQComboBox( parent, name ), d(new KComboBoxPrivate)
+{
+ init();
+}
+
+KComboBox::KComboBox( bool rw, TQWidget *parent, const char *name )
+ : TQComboBox( rw, parent, name ), d(new KComboBoxPrivate)
+{
+ init();
+
+ if ( rw )
+ {
+ KLineEdit *edit = new KLineEdit( this, "combo lineedit" );
+ setLineEdit( edit );
+ }
+}
+
+KComboBox::~KComboBox()
+{
+ delete d;
+}
+
+void KComboBox::init()
+{
+ // Permanently set some parameters in the parent object.
+ TQComboBox::setAutoCompletion( false );
+
+ // Enable context menu by default if widget
+ // is editable.
+ setContextMenuEnabled( true );
+}
+
+
+bool KComboBox::contains( const TQString& _text ) const
+{
+ if ( _text.isEmpty() )
+ return false;
+
+ const int itemCount = count();
+ for (int i = 0; i < itemCount; ++i )
+ {
+ if ( text(i) == _text )
+ return true;
+ }
+ return false;
+}
+
+void KComboBox::setAutoCompletion( bool autocomplete )
+{
+ if ( d->klineEdit )
+ {
+ if ( autocomplete )
+ {
+ d->klineEdit->setCompletionMode( KGlobalSettings::CompletionAuto );
+ setCompletionMode( KGlobalSettings::CompletionAuto );
+ }
+ else
+ {
+ d->klineEdit->setCompletionMode( KGlobalSettings::completionMode() );
+ setCompletionMode( KGlobalSettings::completionMode() );
+ }
+ }
+}
+
+void KComboBox::setContextMenuEnabled( bool showMenu )
+{
+ if( d->klineEdit )
+ d->klineEdit->setContextMenuEnabled( showMenu );
+}
+
+
+void KComboBox::setURLDropsEnabled( bool enable )
+{
+ if ( d->klineEdit )
+ d->klineEdit->setURLDropsEnabled( enable );
+}
+
+bool KComboBox::isURLDropsEnabled() const
+{
+ return d->klineEdit && d->klineEdit->isURLDropsEnabled();
+}
+
+
+void KComboBox::setCompletedText( const TQString& text, bool marked )
+{
+ if ( d->klineEdit )
+ d->klineEdit->setCompletedText( text, marked );
+}
+
+void KComboBox::setCompletedText( const TQString& text )
+{
+ if ( d->klineEdit )
+ d->klineEdit->setCompletedText( text );
+}
+
+void KComboBox::makeCompletion( const TQString& text )
+{
+ if( d->klineEdit )
+ d->klineEdit->makeCompletion( text );
+
+ else // read-only combo completion
+ {
+ if( text.isNull() || !listBox() )
+ return;
+
+ const int index = listBox()->index( listBox()->findItem( text ) );
+ if( index >= 0 )
+ setCurrentItem( index );
+ }
+}
+
+void KComboBox::rotateText( KCompletionBase::KeyBindingType type )
+{
+ if ( d->klineEdit )
+ d->klineEdit->rotateText( type );
+}
+
+// not needed anymore
+bool KComboBox::eventFilter( TQObject* o, TQEvent* ev )
+{
+ return TQComboBox::eventFilter( o, ev );
+}
+
+void KComboBox::setTrapReturnKey( bool grab )
+{
+ if ( d->klineEdit )
+ d->klineEdit->setTrapReturnKey( grab );
+ else
+ qWarning("KComboBox::setTrapReturnKey not supported with a non-KLineEdit.");
+}
+
+bool KComboBox::trapReturnKey() const
+{
+ return d->klineEdit && d->klineEdit->trapReturnKey();
+}
+
+
+void KComboBox::setEditURL( const KURL& url )
+{
+ TQComboBox::setEditText( url.prettyURL() );
+}
+
+void KComboBox::insertURL( const KURL& url, int index )
+{
+ TQComboBox::insertItem( url.prettyURL(), index );
+}
+
+void KComboBox::insertURL( const TQPixmap& pixmap, const KURL& url, int index )
+{
+ TQComboBox::insertItem( pixmap, url.prettyURL(), index );
+}
+
+void KComboBox::changeURL( const KURL& url, int index )
+{
+ TQComboBox::changeItem( url.prettyURL(), index );
+}
+
+void KComboBox::changeURL( const TQPixmap& pixmap, const KURL& url, int index )
+{
+ TQComboBox::changeItem( pixmap, url.prettyURL(), index );
+}
+
+void KComboBox::setCompletedItems( const TQStringList& items )
+{
+ if ( d->klineEdit )
+ d->klineEdit->setCompletedItems( items );
+}
+
+KCompletionBox * KComboBox::completionBox( bool create )
+{
+ if ( d->klineEdit )
+ return d->klineEdit->completionBox( create );
+ return 0;
+}
+
+// TQWidget::create() turns off mouse-Tracking which would break auto-hiding
+void KComboBox::create( WId id, bool initializeWindow, bool destroyOldWindow )
+{
+ TQComboBox::create( id, initializeWindow, destroyOldWindow );
+ KCursor::setAutoHideCursor( lineEdit(), true, true );
+}
+
+void KComboBox::wheelEvent( TQWheelEvent *ev )
+{
+ // Not necessary anymore
+ TQComboBox::wheelEvent( ev );
+}
+
+void KComboBox::setLineEdit( TQLineEdit *edit )
+{
+ if ( !editable() && edit &&
+ !qstrcmp( edit->className(), TQLINEEDIT_OBJECT_NAME_STRING ) )
+ {
+ // uic generates code that creates a read-only KComboBox and then
+ // calls combo->setEditable( true ), which causes TQComboBox to set up
+ // a dumb TQLineEdit instead of our nice KLineEdit.
+ // As some KComboBox features rely on the KLineEdit, we reject
+ // this order here.
+ delete edit;
+ edit = new KLineEdit( this, "combo edit" );
+ }
+
+ TQComboBox::setLineEdit( edit );
+ d->klineEdit = tqt_dynamic_cast<KLineEdit*>( edit );
+ setDelegate( d->klineEdit );
+
+ // Connect the returnPressed signal for both Q[K]LineEdits'
+ if (edit)
+ connect( edit, TQT_SIGNAL( returnPressed() ), TQT_SIGNAL( returnPressed() ));
+
+ if ( d->klineEdit )
+ {
+ // someone calling KComboBox::setEditable( false ) destroys our
+ // lineedit without us noticing. And KCompletionBase::delegate would
+ // be a dangling pointer then, so prevent that. Note: only do this
+ // when it is a KLineEdit!
+ connect( edit, TQT_SIGNAL( destroyed() ), TQT_SLOT( lineEditDeleted() ));
+
+ connect( d->klineEdit, TQT_SIGNAL( returnPressed( const TQString& )),
+ TQT_SIGNAL( returnPressed( const TQString& ) ));
+
+ connect( d->klineEdit, TQT_SIGNAL( completion( const TQString& )),
+ TQT_SIGNAL( completion( const TQString& )) );
+
+ connect( d->klineEdit, TQT_SIGNAL( substringCompletion( const TQString& )),
+ TQT_SIGNAL( substringCompletion( const TQString& )) );
+
+ connect( d->klineEdit,
+ TQT_SIGNAL( textRotation( KCompletionBase::KeyBindingType )),
+ TQT_SIGNAL( textRotation( KCompletionBase::KeyBindingType )) );
+
+ connect( d->klineEdit,
+ TQT_SIGNAL( completionModeChanged( KGlobalSettings::Completion )),
+ TQT_SIGNAL( completionModeChanged( KGlobalSettings::Completion)));
+
+ connect( d->klineEdit,
+ TQT_SIGNAL( aboutToShowContextMenu( TQPopupMenu * )),
+ TQT_SIGNAL( aboutToShowContextMenu( TQPopupMenu * )) );
+
+ connect( d->klineEdit,
+ TQT_SIGNAL( completionBoxActivated( const TQString& )),
+ TQT_SIGNAL( activated( const TQString& )) );
+ }
+}
+
+void KComboBox::setCurrentItem( const TQString& item, bool insert, int index )
+{
+ int sel = -1;
+
+ const int itemCount = count();
+ for (int i = 0; i < itemCount; ++i)
+ {
+ if (text(i) == item)
+ {
+ sel = i;
+ break;
+ }
+ }
+
+ if (sel == -1 && insert)
+ {
+ insertItem(item, index);
+ if (index >= 0)
+ sel = index;
+ else
+ sel = count() - 1;
+ }
+ setCurrentItem(sel);
+}
+
+void KComboBox::lineEditDeleted()
+{
+ // yes, we need those ugly casts due to the multiple inheritance
+ // sender() is guaranteed to be a KLineEdit (see the connect() to the
+ // destroyed() signal
+ const KCompletionBase *base = static_cast<const KCompletionBase*>( static_cast<const KLineEdit*>( sender() ));
+
+ // is it our delegate, that is destroyed?
+ if ( base == delegate() )
+ setDelegate( 0L );
+}
+
+
+// *********************************************************************
+// *********************************************************************
+
+class KHistoryCombo::KHistoryComboPrivate
+{
+public:
+ KHistoryComboPrivate() : bHistoryEditorEnabled(false)
+ {
+ }
+ ~KHistoryComboPrivate()
+ {
+ }
+
+ bool bHistoryEditorEnabled;
+};
+
+// we are always read-write
+KHistoryCombo::KHistoryCombo( TQWidget *parent, const char *name )
+ : KComboBox( true, parent, name ), d(new KHistoryComboPrivate)
+{
+ init( true ); // using completion
+}
+
+// we are always read-write
+KHistoryCombo::KHistoryCombo( bool useCompletion,
+ TQWidget *parent, const char *name )
+ : KComboBox( true, parent, name ), d(new KHistoryComboPrivate)
+{
+ init( useCompletion );
+}
+
+void KHistoryCombo::init( bool useCompletion )
+{
+ // Set a default history size to something reasonable, Qt sets it to INT_MAX by default
+ setMaxCount( 50 );
+
+ if ( useCompletion )
+ completionObject()->setOrder( KCompletion::Weighted );
+
+ setInsertionPolicy( NoInsertion );
+ myIterateIndex = -1;
+ myRotated = false;
+ myPixProvider = 0L;
+
+ // obey HISTCONTROL setting
+ TQCString histControl = getenv("HISTCONTROL");
+ if ( histControl == "ignoredups" || histControl == "ignoreboth" )
+ setDuplicatesEnabled( false );
+
+ connect( this, TQT_SIGNAL(aboutToShowContextMenu(TQPopupMenu*)),
+ TQT_SLOT(addContextMenuItems(TQPopupMenu*)) );
+ connect( this, TQT_SIGNAL( activated(int) ), TQT_SLOT( slotReset() ));
+ connect( this, TQT_SIGNAL( returnPressed(const TQString&) ), TQT_SLOT(slotReset()));
+}
+
+KHistoryCombo::~KHistoryCombo()
+{
+ delete myPixProvider;
+}
+
+void KHistoryCombo::setHistoryItems( TQStringList items,
+ bool setCompletionList )
+{
+ KComboBox::clear();
+
+ // limit to maxCount()
+ const int itemCount = items.count();
+ const int toRemove = itemCount - maxCount();
+
+ if (toRemove >= itemCount) {
+ items.clear();
+ } else {
+ for (int i = 0; i < toRemove; ++i)
+ items.pop_front();
+ }
+
+ insertItems( items );
+
+ if ( setCompletionList && useCompletion() ) {
+ // we don't have any weighting information here ;(
+ KCompletion *comp = completionObject();
+ comp->setOrder( KCompletion::Insertion );
+ comp->setItems( items );
+ comp->setOrder( KCompletion::Weighted );
+ }
+
+ clearEdit();
+}
+
+TQStringList KHistoryCombo::historyItems() const
+{
+ TQStringList list;
+ const int itemCount = count();
+ for ( int i = 0; i < itemCount; ++i )
+ list.append( text( i ) );
+
+ return list;
+}
+
+void KHistoryCombo::clearHistory()
+{
+ const TQString temp = currentText();
+ KComboBox::clear();
+ if ( useCompletion() )
+ completionObject()->clear();
+ setEditText( temp );
+}
+
+void KHistoryCombo::addContextMenuItems( TQPopupMenu* menu )
+{
+ if ( menu )
+ {
+ menu->insertSeparator();
+ if (d->bHistoryEditorEnabled) {
+ int idedit = menu->insertItem( SmallIconSet("edit"), i18n("&Edit History..."), this, TQT_SLOT( slotEdit()) );
+ menu->setItemEnabled(idedit, count());
+ }
+ int id = menu->insertItem( SmallIconSet("history_clear"), i18n("Clear &History"), this, TQT_SLOT( slotClear()));
+ if (!count())
+ menu->setItemEnabled(id, false);
+ }
+}
+
+void KHistoryCombo::addToHistory( const TQString& item )
+{
+ if ( item.isEmpty() || (count() > 0 && item == text(0) )) {
+ return;
+ }
+
+ bool wasCurrent = false;
+ // remove all existing items before adding
+ if ( !duplicatesEnabled() ) {
+ int i = 0;
+ int itemCount = count();
+ while ( i < itemCount ) {
+ if ( text( i ) == item ) {
+ if ( !wasCurrent )
+ wasCurrent = ( i == currentItem() );
+ removeItem( i );
+ --itemCount;
+ } else {
+ ++i;
+ }
+ }
+ }
+
+ // now add the item
+ if ( myPixProvider )
+ insertItem( myPixProvider->pixmapFor(item, KIcon::SizeSmall), item, 0);
+ else
+ insertItem( item, 0 );
+
+ if ( wasCurrent )
+ setCurrentItem( 0 );
+
+ const bool useComp = useCompletion();
+
+ const int last = count() - 1; // last valid index
+ const int mc = maxCount();
+ const int stopAt = QMAX(mc, 0);
+
+ for (int rmIndex = last; rmIndex >= stopAt; --rmIndex) {
+ // remove the last item, as long as we are longer than maxCount()
+ // remove the removed item from the completionObject if it isn't
+ // anymore available at all in the combobox.
+ const TQString rmItem = text( rmIndex );
+ removeItem( rmIndex );
+ if ( useComp && !contains( rmItem ) )
+ completionObject()->removeItem( rmItem );
+ }
+
+ if ( useComp )
+ completionObject()->addItem( item );
+}
+
+bool KHistoryCombo::removeFromHistory( const TQString& item )
+{
+ if ( item.isEmpty() )
+ return false;
+
+ bool removed = false;
+ const TQString temp = currentText();
+ int i = 0;
+ int itemCount = count();
+ while ( i < itemCount ) {
+ if ( item == text( i ) ) {
+ removed = true;
+ removeItem( i );
+ --itemCount;
+ } else {
+ ++i;
+ }
+ }
+
+ if ( removed && useCompletion() )
+ completionObject()->removeItem( item );
+
+ setEditText( temp );
+ return removed;
+}
+
+void KHistoryCombo::rotateUp()
+{
+ // save the current text in the lineedit
+ if ( myIterateIndex == -1 )
+ myText = currentText();
+
+ ++myIterateIndex;
+
+ // skip duplicates/empty items
+ const int last = count() - 1; // last valid index
+ const TQString currText = currentText();
+
+ while ( myIterateIndex < last &&
+ (currText == text( myIterateIndex ) ||
+ text( myIterateIndex ).isEmpty()) )
+ ++myIterateIndex;
+
+ if ( myIterateIndex >= count() ) {
+ myRotated = true;
+ myIterateIndex = -1;
+
+ // if the typed text is the same as the first item, skip the first
+ if ( count() > 0 && myText == text(0) )
+ myIterateIndex = 0;
+
+ setEditText( myText );
+ }
+ else
+ setEditText( text( myIterateIndex ));
+}
+
+void KHistoryCombo::rotateDown()
+{
+ // save the current text in the lineedit
+ if ( myIterateIndex == -1 )
+ myText = currentText();
+
+ --myIterateIndex;
+
+ const TQString currText = currentText();
+ // skip duplicates/empty items
+ while ( myIterateIndex >= 0 &&
+ (currText == text( myIterateIndex ) ||
+ text( myIterateIndex ).isEmpty()) )
+ --myIterateIndex;
+
+
+ if ( myIterateIndex < 0 ) {
+ if ( myRotated && myIterateIndex == -2 ) {
+ myRotated = false;
+ myIterateIndex = count() - 1;
+ setEditText( text(myIterateIndex) );
+ }
+ else { // bottom of history
+ if ( myIterateIndex == -2 ) {
+ KNotifyClient::event( (int)winId(), KNotifyClient::notification,
+ i18n("No further item in the history."));
+ }
+
+ myIterateIndex = -1;
+ if ( currentText() != myText )
+ setEditText( myText );
+ }
+ }
+ else
+ setEditText( text( myIterateIndex ));
+
+}
+
+void KHistoryCombo::keyPressEvent( TQKeyEvent *e )
+{
+ KKey event_key( e );
+
+ // going up in the history, rotating when reaching TQListBox::count()
+ if ( KStdAccel::rotateUp().contains(event_key) )
+ rotateUp();
+
+ // going down in the history, no rotation possible. Last item will be
+ // the text that was in the lineedit before Up was called.
+ else if ( KStdAccel::rotateDown().contains(event_key) )
+ rotateDown();
+ else
+ KComboBox::keyPressEvent( e );
+}
+
+void KHistoryCombo::wheelEvent( TQWheelEvent *ev )
+{
+ // Pass to poppable listbox if it's up
+ TQListBox* const lb = listBox();
+ if ( lb && lb->isVisible() )
+ {
+ TQApplication::sendEvent( lb, ev );
+ return;
+ }
+ // Otherwise make it change the text without emitting activated
+ if ( ev->delta() > 0 ) {
+ rotateUp();
+ } else {
+ rotateDown();
+ }
+ ev->accept();
+}
+
+void KHistoryCombo::slotReset()
+{
+ myIterateIndex = -1;
+ myRotated = false;
+}
+
+
+void KHistoryCombo::setPixmapProvider( KPixmapProvider *prov )
+{
+ if ( myPixProvider == prov )
+ return;
+
+ delete myPixProvider;
+ myPixProvider = prov;
+
+ // re-insert all the items with/without pixmap
+ // I would prefer to use changeItem(), but that doesn't honor the pixmap
+ // when using an editable combobox (what we do)
+ if ( count() > 0 ) {
+ TQStringList items( historyItems() );
+ clear();
+ insertItems( items );
+ }
+}
+
+void KHistoryCombo::insertItems( const TQStringList& items )
+{
+ TQStringList::ConstIterator it = items.constBegin();
+ const TQStringList::ConstIterator itEnd = items.constEnd();
+
+ while ( it != itEnd ) {
+ const TQString item = *it;
+ if ( !item.isEmpty() ) { // only insert non-empty items
+ if ( myPixProvider )
+ insertItem( myPixProvider->pixmapFor(item, KIcon::SizeSmall),
+ item );
+ else
+ insertItem( item );
+ }
+ ++it;
+ }
+}
+
+void KHistoryCombo::slotClear()
+{
+ clearHistory();
+ emit cleared();
+}
+
+void KHistoryCombo::slotEdit()
+{
+ KHistoryComboEditor dlg( historyItems(), this );
+ connect( &dlg, TQT_SIGNAL( removeFromHistory(const TQString&) ), TQT_SLOT( slotRemoveFromHistory(const TQString&)) );
+ dlg.exec();
+}
+
+void KHistoryCombo::slotRemoveFromHistory(const TQString &entry)
+{
+ removeFromHistory(entry);
+ emit removed(entry);
+}
+
+void KHistoryCombo::setHistoryEditorEnabled( bool enable )
+{
+ d->bHistoryEditorEnabled = enable;
+}
+
+bool KHistoryCombo::isHistoryEditorEnabled() const
+{
+ return d->bHistoryEditorEnabled;
+}
+
+void KComboBox::virtual_hook( int id, void* data )
+{ KCompletionBase::virtual_hook( id, data ); }
+
+void KHistoryCombo::virtual_hook( int id, void* data )
+{ KComboBox::virtual_hook( id, data ); }
+
+void KHistoryComboEditor::virtual_hook( int id, void* data )
+{ KDialogBase::virtual_hook( id, data ); }
+
+KHistoryComboEditor::KHistoryComboEditor( const TQStringList& entries, TQWidget *parent )
+: KDialogBase( parent, "khistorycomboeditor", true, i18n( "History Editor" ),
+ KDialogBase::Close | KDialogBase::User1, KDialogBase::User1, true,
+ KGuiItem( i18n( "&Delete Entry" ), "editdelete") ), d(0)
+{
+ TQVBox* box = new TQVBox( this );
+ box->setSpacing( KDialog::spacingHint() );
+ setMainWidget( box );
+
+ new TQLabel( i18n( "This dialog allows you to delete unwanted history items." ), box );
+
+ // Add searchline
+ TQHBox* searchbox = new TQHBox( box );
+ searchbox->setSpacing( KDialog::spacingHint() );
+
+ TQToolButton *clearSearch = new TQToolButton(searchbox);
+ clearSearch->setTextLabel(i18n("Clear Search"), true);
+ clearSearch->setIconSet(SmallIconSet(TQApplication::reverseLayout() ? "clear_left" : "locationbar_erase"));
+ TQLabel* slbl = new TQLabel(i18n("&Search:"), searchbox);
+ KListViewSearchLine* listViewSearch = new KListViewSearchLine(searchbox);
+ slbl->setBuddy(listViewSearch);
+ connect(clearSearch, TQT_SIGNAL(pressed()), listViewSearch, TQT_SLOT(clear()));
+
+ // Add ListView
+ m_pListView = new KListView( box );
+ listViewSearch->setListView(m_pListView);
+ m_pListView->setAllColumnsShowFocus(true);
+ m_pListView->header()->hide();
+ m_pListView->addColumn("");
+ m_pListView->setRenameable( 0 );
+
+ box->setStretchFactor( m_pListView, 1 );
+
+ TQStringList newlist = entries;
+ for ( TQStringList::Iterator it = newlist.begin(); it != newlist.end(); ++it ) {
+ new TQListViewItem( m_pListView, *it );
+ }
+
+ m_pListView->setMinimumSize( m_pListView->tqsizeHint() );
+
+ connect( m_pListView, TQT_SIGNAL( selectionChanged( TQListViewItem * ) ),
+ this, TQT_SLOT( slotSelectionChanged( TQListViewItem * ) ) );
+
+ enableButton( KDialogBase::User1, false );
+
+ resize( tqsizeHint() );
+}
+
+KHistoryComboEditor::~KHistoryComboEditor()
+{
+}
+
+void KHistoryComboEditor::slotUser1() // Delete button
+{
+ TQListViewItem *item = m_pListView->selectedItem();
+
+ if ( item ) {
+ emit removeFromHistory( item->text(0) );
+ m_pListView->takeItem( item );
+ enableButton( KDialogBase::User1, false );
+ }
+}
+
+void KHistoryComboEditor::slotSelectionChanged( TQListViewItem * item )
+{
+ enableButton( KDialogBase::User1, item );
+}
+
+#include "kcombobox.moc"