00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #include <qclipboard.h>
00029 #include <qtimer.h>
00030 #include <qtooltip.h>
00031 #include <kcursor.h>
00032 #include <klocale.h>
00033 #include <kstdaccel.h>
00034 #include <kpopupmenu.h>
00035 #include <kdebug.h>
00036 #include <kcompletionbox.h>
00037 #include <kurl.h>
00038 #include <kurldrag.h>
00039 #include <kiconloader.h>
00040 #include <kapplication.h>
00041
00042 #include "klineedit.h"
00043 #include "klineedit.moc"
00044
00045
00046 class KLineEdit::KLineEditPrivate
00047 {
00048 public:
00049 KLineEditPrivate()
00050 {
00051 completionBox = 0L;
00052 handleURLDrops = true;
00053 grabReturnKeyEvents = false;
00054 }
00055 ~KLineEditPrivate()
00056 {
00057
00058
00059 }
00060
00061 int squeezedEnd;
00062 int squeezedStart;
00063 bool handleURLDrops;
00064 bool grabReturnKeyEvents;
00065 BackgroundMode bgMode;
00066 QString squeezedText;
00067 KCompletionBox *completionBox;
00068 };
00069
00070
00071 KLineEdit::KLineEdit( const QString &string, QWidget *parent, const char *name )
00072 :QLineEdit( string, parent, name )
00073 {
00074 init();
00075 }
00076
00077 KLineEdit::KLineEdit( QWidget *parent, const char *name )
00078 :QLineEdit( parent, name )
00079 {
00080 init();
00081 }
00082
00083 KLineEdit::~KLineEdit ()
00084 {
00085 delete d;
00086 }
00087
00088 void KLineEdit::init()
00089 {
00090 d = new KLineEditPrivate;
00091 possibleTripleClick = false;
00092 d->bgMode = backgroundMode ();
00093
00094
00095 setContextMenuEnabled( true );
00096 KCursor::setAutoHideCursor( this, true, true );
00097 installEventFilter( this );
00098 }
00099
00100 void KLineEdit::setCompletionMode( KGlobalSettings::Completion mode )
00101 {
00102 KGlobalSettings::Completion oldMode = completionMode();
00103 if ( oldMode != mode && oldMode == KGlobalSettings::CompletionPopup &&
00104 d->completionBox && d->completionBox->isVisible() )
00105 d->completionBox->hide();
00106
00107
00108
00109 if ( echoMode() != QLineEdit::Normal )
00110 mode = KGlobalSettings::CompletionNone;
00111
00112 if ( kapp && !kapp->authorize("lineedit_text_completion") )
00113 mode = KGlobalSettings::CompletionNone;
00114
00115 KCompletionBase::setCompletionMode( mode );
00116 }
00117
00118 void KLineEdit::setCompletedText( const QString& t, bool marked )
00119 {
00120 QString txt = text();
00121 if ( t != txt )
00122 {
00123 int curpos = marked ? txt.length() : t.length();
00124 validateAndSet( t, curpos, curpos, t.length() );
00125 }
00126 }
00127
00128 void KLineEdit::setCompletedText( const QString& text )
00129 {
00130 KGlobalSettings::Completion mode = completionMode();
00131 bool marked = ( mode == KGlobalSettings::CompletionAuto ||
00132 mode == KGlobalSettings::CompletionMan ||
00133 mode == KGlobalSettings::CompletionPopup );
00134 setCompletedText( text, marked );
00135 }
00136
00137 void KLineEdit::rotateText( KCompletionBase::KeyBindingType type )
00138 {
00139 KCompletion* comp = compObj();
00140 if ( comp &&
00141 (type == KCompletionBase::PrevCompletionMatch ||
00142 type == KCompletionBase::NextCompletionMatch ) )
00143 {
00144 QString input = (type == KCompletionBase::PrevCompletionMatch) ? comp->previousMatch() : comp->nextMatch();
00145
00146 if ( input.isNull() || input == displayText() )
00147 return;
00148 setCompletedText( input, hasSelectedText() );
00149 }
00150 }
00151
00152 void KLineEdit::makeCompletion( const QString& text )
00153 {
00154 KCompletion *comp = compObj();
00155 if ( !comp )
00156 return;
00157
00158 QString match = comp->makeCompletion( text );
00159 KGlobalSettings::Completion mode = completionMode();
00160 if ( mode == KGlobalSettings::CompletionPopup )
00161 {
00162 if ( match.isNull() )
00163 {
00164 if ( d->completionBox ) {
00165 d->completionBox->hide();
00166 d->completionBox->clear();
00167 }
00168 }
00169 else
00170 setCompletedItems( comp->allMatches() );
00171 }
00172 else
00173 {
00174
00175
00176 if ( match.isNull() || match == text )
00177 return;
00178
00179 setCompletedText( match );
00180 }
00181 }
00182
00183 void KLineEdit::setReadOnly(bool readOnly)
00184 {
00185
00186 if (readOnly == isReadOnly ())
00187 return;
00188
00189 QLineEdit::setReadOnly (readOnly);
00190
00191 if (readOnly)
00192 {
00193 d->bgMode = backgroundMode ();
00194 setBackgroundMode (Qt::PaletteBackground);
00195 }
00196 else
00197 {
00198 if (!d->squeezedText.isEmpty())
00199 {
00200 setText(d->squeezedText);
00201 d->squeezedText = QString::null;
00202 }
00203 setBackgroundMode (d->bgMode);
00204 }
00205 }
00206
00207 void KLineEdit::setSqueezedText( const QString &text)
00208 {
00209 if (isReadOnly())
00210 {
00211 d->squeezedText = text;
00212 d->squeezedStart = 0;
00213 d->squeezedEnd = 0;
00214 if (isVisible())
00215 {
00216 QResizeEvent ev(size(), size());
00217 resizeEvent(&ev);
00218 }
00219 }
00220 else
00221 {
00222 setText(text);
00223 }
00224 }
00225
00226 void KLineEdit::copy() const
00227 {
00228 if (!d->squeezedText.isEmpty() && d->squeezedStart)
00229 {
00230 int start, end;
00231 KLineEdit *that = const_cast<KLineEdit *>(this);
00232 if (!that->getSelection(&start, &end))
00233 return;
00234 if (start >= d->squeezedStart+3)
00235 start = start - 3 - d->squeezedStart + d->squeezedEnd;
00236 else if (start > d->squeezedStart)
00237 start = d->squeezedStart;
00238 if (end >= d->squeezedStart+3)
00239 end = end - 3 - d->squeezedStart + d->squeezedEnd;
00240 else if (end > d->squeezedStart)
00241 end = d->squeezedEnd;
00242 if (start == end)
00243 return;
00244 QString t = d->squeezedText;
00245 t = t.mid(start, end - start);
00246 disconnect( QApplication::clipboard(), SIGNAL(selectionChanged()), this, 0);
00247 QApplication::clipboard()->setText( t );
00248 connect( QApplication::clipboard(), SIGNAL(selectionChanged()),
00249 this, SLOT(clipboardChanged()) );
00250 }
00251 else
00252 {
00253 QLineEdit::copy();
00254 }
00255 }
00256
00257 void KLineEdit::resizeEvent( QResizeEvent * ev )
00258 {
00259 if (!d->squeezedText.isEmpty())
00260 {
00261 d->squeezedStart = 0;
00262 d->squeezedEnd = 0;
00263 QString fullText = d->squeezedText;
00264 QFontMetrics fm(fontMetrics());
00265 int labelWidth = size().width() - 2*frameWidth() - 2;
00266 int textWidth = fm.width(fullText);
00267 if (textWidth > labelWidth) {
00268
00269 QString squeezedText = "...";
00270 int squeezedWidth = fm.width(squeezedText);
00271
00272
00273 int letters = fullText.length() * (labelWidth - squeezedWidth) / textWidth / 2;
00274 squeezedText = fullText.left(letters) + "..." + fullText.right(letters);
00275 squeezedWidth = fm.width(squeezedText);
00276
00277 if (squeezedWidth < labelWidth) {
00278
00279
00280 do {
00281 letters++;
00282 squeezedText = fullText.left(letters) + "..." + fullText.right(letters);
00283 squeezedWidth = fm.width(squeezedText);
00284 } while (squeezedWidth < labelWidth);
00285 letters--;
00286 squeezedText = fullText.left(letters) + "..." + fullText.right(letters);
00287 } else if (squeezedWidth > labelWidth) {
00288
00289
00290 do {
00291 letters--;
00292 squeezedText = fullText.left(letters) + "..." + fullText.right(letters);
00293 squeezedWidth = fm.width(squeezedText);
00294 } while (squeezedWidth > labelWidth);
00295 }
00296
00297 if (letters < 5) {
00298
00299 setText(fullText);
00300 } else {
00301 setText(squeezedText);
00302 d->squeezedStart = letters;
00303 d->squeezedEnd = fullText.length() - letters;
00304 }
00305
00306 QToolTip::remove( this );
00307 QToolTip::add( this, fullText );
00308
00309 } else {
00310 setText(fullText);
00311
00312 QToolTip::remove( this );
00313 QToolTip::hide();
00314 }
00315 setCursorPosition(0);
00316 }
00317 QLineEdit::resizeEvent(ev);
00318 }
00319
00320 void KLineEdit::keyPressEvent( QKeyEvent *e )
00321 {
00322
00323
00324 KKey key( e );
00325
00326 if ( echoMode() == QLineEdit::Normal &&
00327 completionMode() != KGlobalSettings::CompletionNone )
00328 {
00329 KeyBindingMap keys = getKeyBindings();
00330 KGlobalSettings::Completion mode = completionMode();
00331 bool noModifier = (e->state() == NoButton || e->state()== ShiftButton);
00332
00333 if ( (mode == KGlobalSettings::CompletionAuto ||
00334 mode == KGlobalSettings::CompletionMan) && noModifier )
00335 {
00336 QString keycode = e->text();
00337 if ( !keycode.isEmpty() && keycode.unicode()->isPrint() )
00338 {
00339 QLineEdit::keyPressEvent ( e );
00340 QString txt = text();
00341 int len = txt.length();
00342 if ( !hasSelectedText() && len && cursorPosition() == len )
00343 {
00344 if ( emitSignals() )
00345 emit completion( txt );
00346 if ( handleSignals() )
00347 makeCompletion( txt );
00348 e->accept();
00349 }
00350 return;
00351 }
00352 }
00353
00354 else if ( mode == KGlobalSettings::CompletionPopup && noModifier &&
00355 !e->text().isEmpty() )
00356 {
00357 QString old_txt = text();
00358 QLineEdit::keyPressEvent ( e );
00359 QString txt = text();
00360 int len = txt.length();
00361 QString keycode = e->text();
00362
00363
00364 if ( txt != old_txt && len && cursorPosition() == len &&
00365 ( (!keycode.isEmpty() && keycode.unicode()->isPrint()) ||
00366 e->key() == Key_Backspace ) )
00367 {
00368 if ( emitSignals() )
00369 emit completion( txt );
00370 if ( handleSignals() )
00371 makeCompletion( txt );
00372 e->accept();
00373 }
00374 else if (!len && d->completionBox && d->completionBox->isVisible())
00375 d->completionBox->hide();
00376
00377 return;
00378 }
00379
00380 else if ( mode == KGlobalSettings::CompletionShell )
00381 {
00382
00383 KShortcut cut;
00384 if ( keys[TextCompletion].isNull() )
00385 cut = KStdAccel::shortcut(KStdAccel::TextCompletion);
00386 else
00387 cut = keys[TextCompletion];
00388
00389 if ( cut.contains( key ) )
00390 {
00391
00392
00393 QString txt = text();
00394 int len = txt.length();
00395 if ( cursorPosition() == len && len != 0 )
00396 {
00397 if ( emitSignals() )
00398 emit completion( txt );
00399 if ( handleSignals() )
00400 makeCompletion( txt );
00401 return;
00402 }
00403 }
00404 else if ( d->completionBox )
00405 d->completionBox->hide();
00406 }
00407
00408
00409 if ( mode != KGlobalSettings::CompletionNone )
00410 {
00411
00412 KShortcut cut;
00413 if ( keys[PrevCompletionMatch].isNull() )
00414 cut = KStdAccel::shortcut(KStdAccel::PrevCompletion);
00415 else
00416 cut = keys[PrevCompletionMatch];
00417
00418 if ( cut.contains( key ) )
00419 {
00420 if ( emitSignals() )
00421 emit textRotation( KCompletionBase::PrevCompletionMatch );
00422 if ( handleSignals() )
00423 rotateText( KCompletionBase::PrevCompletionMatch );
00424 return;
00425 }
00426
00427
00428 if ( keys[NextCompletionMatch].isNull() )
00429 cut = KStdAccel::key(KStdAccel::NextCompletion);
00430 else
00431 cut = keys[NextCompletionMatch];
00432
00433 if ( cut.contains( key ) )
00434 {
00435 if ( emitSignals() )
00436 emit textRotation( KCompletionBase::NextCompletionMatch );
00437 if ( handleSignals() )
00438 rotateText( KCompletionBase::NextCompletionMatch );
00439 return;
00440 }
00441 }
00442
00443
00444 if ( compObj() )
00445 {
00446 KShortcut cut;
00447 if ( keys[SubstringCompletion].isNull() )
00448 cut = KStdAccel::shortcut(KStdAccel::SubstringCompletion);
00449 else
00450 cut = keys[SubstringCompletion];
00451
00452 if ( cut.contains( key ) )
00453 {
00454 if ( emitSignals() )
00455 emit substringCompletion( text() );
00456 if ( handleSignals() )
00457 {
00458 setCompletedItems( compObj()->substringCompletion(text()));
00459 e->accept();
00460 }
00461 return;
00462 }
00463 }
00464 }
00465
00466 if ( KStdAccel::copy().contains( key ) )
00467 {
00468 copy();
00469 return;
00470 }
00471 else if ( KStdAccel::paste().contains( key ) )
00472 {
00473 paste();
00474 return;
00475 }
00476
00477
00478 else if ( e->key() == Key_Insert &&
00479 (e->state() == (ShiftButton | ControlButton)) )
00480 {
00481 #if QT_VERSION >= 0x030100
00482 QString text = QApplication::clipboard()->text( QClipboard::Selection);
00483 #else
00484 QClipboard *clip = QApplication::clipboard();
00485 bool oldMode = clip->selectionModeEnabled();
00486 clip->setSelectionMode( true );
00487 QString text = QApplication::clipboard()->text();
00488 clip->setSelectionMode( oldMode );
00489 #endif
00490
00491 insert( text );
00492 deselect();
00493 return;
00494 }
00495
00496 else if ( KStdAccel::cut().contains( key ) )
00497 {
00498 cut();
00499 return;
00500 }
00501 else if ( KStdAccel::undo().contains( key ) )
00502 {
00503 undo();
00504 return;
00505 }
00506 else if ( KStdAccel::redo().contains( key ) )
00507 {
00508 redo();
00509 return;
00510 }
00511 else if ( KStdAccel::deleteWordBack().contains( key ) )
00512 {
00513 cursorWordBackward(TRUE);
00514 if ( hasSelectedText() )
00515 del();
00516
00517 e->accept();
00518 return;
00519 }
00520 else if ( KStdAccel::deleteWordForward().contains( key ) )
00521 {
00522
00523 cursorWordForward(TRUE);
00524 if ( hasSelectedText() )
00525 del();
00526
00527 e->accept();
00528 return;
00529 }
00530
00531
00532 QLineEdit::keyPressEvent ( e );
00533 }
00534
00535 void KLineEdit::mouseDoubleClickEvent( QMouseEvent* e )
00536 {
00537 if ( e->button() == Qt::LeftButton )
00538 {
00539 possibleTripleClick=true;
00540 QTimer::singleShot( QApplication::doubleClickInterval(),this,
00541 SLOT(tripleClickTimeout()) );
00542 }
00543 QLineEdit::mouseDoubleClickEvent( e );
00544 }
00545
00546 void KLineEdit::mousePressEvent( QMouseEvent* e )
00547 {
00548 if ( possibleTripleClick && e->button() == Qt::LeftButton )
00549 {
00550 selectAll();
00551 return;
00552 }
00553 QLineEdit::mousePressEvent( e );
00554 }
00555
00556 void KLineEdit::tripleClickTimeout()
00557 {
00558 possibleTripleClick=false;
00559 }
00560
00561 QPopupMenu *KLineEdit::createPopupMenu()
00562 {
00563
00564 if ( !m_bEnableMenu )
00565 return 0;
00566
00567 QPopupMenu *popup = QLineEdit::createPopupMenu();
00568
00569
00570
00571
00572 if ( compObj() && !isReadOnly() && kapp->authorize("lineedit_text_completion"))
00573 {
00574 QPopupMenu *subMenu = new QPopupMenu( popup );
00575 connect( subMenu, SIGNAL( activated( int ) ),
00576 this, SLOT( completionMenuActivated( int ) ) );
00577
00578 popup->insertSeparator();
00579 popup->insertItem( SmallIconSet("completion"), i18n("Text Completion"),
00580 subMenu );
00581
00582 subMenu->insertItem( i18n("None"), NoCompletion );
00583 subMenu->insertItem( i18n("Manual"), ShellCompletion );
00584 subMenu->insertItem( i18n("Automatic"), AutoCompletion );
00585 subMenu->insertItem( i18n("Dropdown List"), PopupCompletion );
00586 subMenu->insertItem( i18n("Short Automatic"), SemiAutoCompletion );
00587
00588 subMenu->setAccel( KStdAccel::completion(), ShellCompletion );
00589
00590 KGlobalSettings::Completion mode = completionMode();
00591 subMenu->setItemChecked( NoCompletion,
00592 mode == KGlobalSettings::CompletionNone );
00593 subMenu->setItemChecked( ShellCompletion,
00594 mode == KGlobalSettings::CompletionShell );
00595 subMenu->setItemChecked( PopupCompletion,
00596 mode == KGlobalSettings::CompletionPopup );
00597 subMenu->setItemChecked( AutoCompletion,
00598 mode == KGlobalSettings::CompletionAuto );
00599 subMenu->setItemChecked( SemiAutoCompletion,
00600 mode == KGlobalSettings::CompletionMan );
00601 if ( mode != KGlobalSettings::completionMode() )
00602 {
00603 subMenu->insertSeparator();
00604 subMenu->insertItem( i18n("Default"), Default );
00605 }
00606 }
00607
00608
00609
00610
00611 emit aboutToShowContextMenu( popup );
00612
00613 return popup;
00614 }
00615
00616 void KLineEdit::completionMenuActivated( int id )
00617 {
00618 KGlobalSettings::Completion oldMode = completionMode();
00619
00620 switch ( id )
00621 {
00622 case Default:
00623 setCompletionMode( KGlobalSettings::completionMode() );
00624 break;
00625 case NoCompletion:
00626 setCompletionMode( KGlobalSettings::CompletionNone );
00627 break;
00628 case AutoCompletion:
00629 setCompletionMode( KGlobalSettings::CompletionAuto );
00630 break;
00631 case SemiAutoCompletion:
00632 setCompletionMode( KGlobalSettings::CompletionMan );
00633 break;
00634 case ShellCompletion:
00635 setCompletionMode( KGlobalSettings::CompletionShell );
00636 break;
00637 case PopupCompletion:
00638 setCompletionMode( KGlobalSettings::CompletionPopup );
00639 break;
00640 default:
00641 return;
00642 }
00643
00644 if ( oldMode != completionMode() )
00645 {
00646 if ( oldMode == KGlobalSettings::CompletionPopup &&
00647 d->completionBox && d->completionBox->isVisible() )
00648 d->completionBox->hide();
00649 emit completionModeChanged( completionMode() );
00650 }
00651 }
00652
00653 void KLineEdit::dropEvent(QDropEvent *e)
00654 {
00655 KURL::List urlList;
00656 if( d->handleURLDrops && KURLDrag::decode( e, urlList ) )
00657 {
00658 QString dropText = text();
00659 KURL::List::ConstIterator it;
00660 for( it = urlList.begin() ; it != urlList.end() ; ++it )
00661 {
00662 if(!dropText.isEmpty())
00663 dropText+=' ';
00664
00665 dropText += (*it).prettyURL();
00666 }
00667
00668 validateAndSet( dropText, dropText.length(), 0, 0);
00669
00670 e->accept();
00671 }
00672 else
00673 QLineEdit::dropEvent(e);
00674 }
00675
00676 bool KLineEdit::eventFilter( QObject* o, QEvent* ev )
00677 {
00678 if( o == this )
00679 {
00680 KCursor::autoHideEventFilter( this, ev );
00681 if ( ev->type() == QEvent::AccelOverride )
00682 {
00683 QKeyEvent *e = static_cast<QKeyEvent *>( ev );
00684 if (overrideAccel (e))
00685 {
00686 e->accept();
00687 return true;
00688 }
00689 }
00690 else if( ev->type() == QEvent::KeyPress )
00691 {
00692 QKeyEvent *e = static_cast<QKeyEvent *>( ev );
00693
00694 if( e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter )
00695 {
00696 bool trap = d->completionBox && d->completionBox->isVisible();
00697 bool stopEvent = trap || (d->grabReturnKeyEvents &&
00698 (e->state() == NoButton));
00699
00700
00701 if ( stopEvent )
00702 emit QLineEdit::returnPressed();
00703
00704 emit returnPressed( displayText() );
00705
00706 if ( trap )
00707 d->completionBox->hide();
00708
00709
00710 return stopEvent;
00711 }
00712 }
00713 }
00714 return QLineEdit::eventFilter( o, ev );
00715 }
00716
00717
00718 void KLineEdit::setURLDropsEnabled(bool enable)
00719 {
00720 d->handleURLDrops=enable;
00721 }
00722
00723 bool KLineEdit::isURLDropsEnabled() const
00724 {
00725 return d->handleURLDrops;
00726 }
00727
00728 void KLineEdit::setTrapReturnKey( bool grab )
00729 {
00730 d->grabReturnKeyEvents = grab;
00731 }
00732
00733 bool KLineEdit::trapReturnKey() const
00734 {
00735 return d->grabReturnKeyEvents;
00736 }
00737
00738 void KLineEdit::setURL( const KURL& url )
00739 {
00740 QLineEdit::setText( url.prettyURL() );
00741 }
00742
00743 void KLineEdit::makeCompletionBox()
00744 {
00745 if ( d->completionBox )
00746 return;
00747
00748 d->completionBox = new KCompletionBox( this, "completion box" );
00749 if ( handleSignals() )
00750 {
00751 connect( d->completionBox, SIGNAL(highlighted( const QString& )),
00752 SLOT(setTextWorkaround( const QString& )) );
00753 connect( d->completionBox, SIGNAL(userCancelled( const QString& )),
00754 SLOT(setText( const QString& )) );
00755 connect( d->completionBox, SIGNAL( activated( const QString& )),
00756 SIGNAL(completionBoxActivated( const QString& )) );
00757 }
00758 }
00759
00760 bool KLineEdit::overrideAccel (const QKeyEvent* e)
00761 {
00762 KShortcut scKey;
00763
00764 KKey key( e );
00765 KeyBindingMap keys = getKeyBindings();
00766
00767 if (keys[TextCompletion].isNull())
00768 scKey = KStdAccel::shortcut(KStdAccel::TextCompletion);
00769 else
00770 scKey = keys[TextCompletion];
00771
00772 if (scKey.contains( key ))
00773 return true;
00774
00775 if (keys[NextCompletionMatch].isNull())
00776 scKey = KStdAccel::shortcut(KStdAccel::NextCompletion);
00777 else
00778 scKey = keys[NextCompletionMatch];
00779
00780 if (scKey.contains( key ))
00781 return true;
00782
00783 if (keys[PrevCompletionMatch].isNull())
00784 scKey = KStdAccel::shortcut(KStdAccel::PrevCompletion);
00785 else
00786 scKey = keys[PrevCompletionMatch];
00787
00788 if (scKey.contains( key ))
00789 return true;
00790
00791
00792 if ( KStdAccel::copy().contains( key ) )
00793 return true;
00794 else if ( KStdAccel::paste().contains( key ) )
00795 return true;
00796 else if ( KStdAccel::cut().contains( key ) )
00797 return true;
00798 else if ( KStdAccel::undo().contains( key ) )
00799 return true;
00800 else if ( KStdAccel::redo().contains( key ) )
00801 return true;
00802 else if (KStdAccel::deleteWordBack().contains( key ))
00803 return true;
00804 else if (KStdAccel::deleteWordForward().contains( key ))
00805 return true;
00806
00807 if (d->completionBox && d->completionBox->isVisible ())
00808 if (e->key () == Key_Backtab)
00809 return true;
00810
00811 return false;
00812 }
00813
00814 void KLineEdit::setCompletedItems( const QStringList& items )
00815 {
00816 QString txt = text();
00817 if ( !items.isEmpty() &&
00818 !(items.count() == 1 && txt == items.first()) )
00819 {
00820 if ( !d->completionBox )
00821 makeCompletionBox();
00822
00823 if ( !txt.isEmpty() )
00824 d->completionBox->setCancelledText( txt );
00825 d->completionBox->setItems( items );
00826 d->completionBox->popup();
00827 }
00828 else
00829 {
00830 if ( d->completionBox && d->completionBox->isVisible() )
00831 d->completionBox->hide();
00832 }
00833 }
00834
00835 KCompletionBox * KLineEdit::completionBox( bool create )
00836 {
00837 if ( create )
00838 makeCompletionBox();
00839
00840 return d->completionBox;
00841 }
00842
00843 void KLineEdit::setCompletionObject( KCompletion* comp, bool hsig )
00844 {
00845 KCompletion *oldComp = compObj();
00846 if ( oldComp && handleSignals() )
00847 disconnect( oldComp, SIGNAL( matches( const QStringList& )),
00848 this, SLOT( setCompletedItems( const QStringList& )));
00849
00850 if ( comp && hsig )
00851 connect( comp, SIGNAL( matches( const QStringList& )),
00852 this, SLOT( setCompletedItems( const QStringList& )));
00853
00854 KCompletionBase::setCompletionObject( comp, hsig );
00855 }
00856
00857
00858 void KLineEdit::create( WId id, bool initializeWindow, bool destroyOldWindow )
00859 {
00860 QLineEdit::create( id, initializeWindow, destroyOldWindow );
00861 KCursor::setAutoHideCursor( this, true, true );
00862 }
00863
00864 void KLineEdit::clear()
00865 {
00866 setText( QString::null );
00867 }
00868
00869 void KLineEdit::setTextWorkaround( const QString& text )
00870 {
00871 setText( text );
00872 end( false );
00873 }
00874
00875 void KLineEdit::virtual_hook( int id, void* data )
00876 { KCompletionBase::virtual_hook( id, data ); }