workspace/krunner/interface.cpp

   1 /*
   2  *   Copyright (C) 2006 Aaron Seigo <aseigo@kde.org>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU Library General Public License version 2 as
   6  *   published by the Free Software Foundation
   7  *
   8  *   This program is distributed in the hope that it will be useful,
   9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *   GNU General Public License for more details
  12  *
  13  *   You should have received a copy of the GNU Library General Public
  14  *   License along with this program; if not, write to the
  15  *   Free Software Foundation, Inc.,
  16  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include "interface.h"
  20
  21 #include <QAction>
  22 #include <QApplication>
  23 #include <QDesktopWidget>
  24 #include <QLabel>
  25 #include <QListWidget>
  26 #include <QVBoxLayout>
  27 #include <QHBoxLayout>
  28 #include <QShortcut>
  29 #include <QTimer>
  30 #include <QHideEvent>
  31
  32 #include <KActionCollection>
  33 #include <KHistoryComboBox>
  34 #include <KCompletionBox>
  35 #include <KDebug>
  36 #include <KDialog>
  37 #include <KLineEdit>
  38 #include <KLocale>
  39 #include <KGlobalSettings>
  40 #include <KPushButton>
  41 #include <KStandardGuiItem>
  42 #include <KTitleWidget>
  43 #include <KWindowSystem>
  44
  45 #include <Solid/Device>
  46 #include <Solid/DeviceInterface>
  47
  48 // #include <threadweaver/DebuggingAids.h>
  49 // #include <ThreadWeaver/Thread>
  50 #include <ThreadWeaver/Job>
  51 #include <ThreadWeaver/QueuePolicy>
  52 #include <ThreadWeaver/Weaver>
  53 #include <QMutex>
  54
  55 #include <plasma/abstractrunner.h>
  56
  57 #include "collapsiblewidget.h"
  58 #include "interfaceadaptor.h"
  59 #include "krunnersettings.h"
  60
  61 using ThreadWeaver::Weaver;
  62 using ThreadWeaver::Job;
  63
  64 // A little hack of a class to let us easily activate a match
  65
  66 class SearchMatch : public QListWidgetItem
  67 {
  68     public:
  69         SearchMatch(const Plasma::SearchMatch* action, QListWidget* parent)
  70             : QListWidgetItem( parent ),
  71               m_default(false),
  72               m_action(0)
  73         {
  74             setAction(action);
  75         }
  76
  77         void activate(const Plasma::SearchContext *context)
  78         {
  79             m_action->exec(context);
  80         }
  81
  82         bool actionEnabled()
  83         {
  84             return m_action->isEnabled();
  85         }
  86
  87         bool hasMatchOptions()
  88         {
  89             return m_action->runner()->hasMatchOptions();
  90         }
  91
  92         void setAction(const Plasma::SearchMatch* action)
  93         {
  94             m_action = action;
  95             setIcon(m_action->icon());
  96             setText(i18n("%1 (%2)",
  97                     m_action->text(),
  98                     m_action->runner()->objectName()));
  99
 100             // in case our new action is now enabled and the old one wasn't, or
 101             // vice versa
 102             setDefault(m_default);
 103         }
 104
 105         QString toString()
 106         {
 107             return m_action->data().toString();
 108         }
 109
 110         Plasma::SearchMatch::Type actionType()
 111         {
 112             return m_action->type();
 113         }
 114
 115         /*Plasma::SearchMatch* action()
 116         {
 117             return m_action;
 118         }*/
 119
 120         void createMatchOptions(QWidget* parent)
 121         {
 122             m_action->runner()->createMatchOptions(parent);
 123         }
 124
 125         void setDefault( bool def ) {
 126             if ( m_default == def ) {
 127                 return;
 128             }
 129
 130             m_default = def;
 131
 132             if ( m_default ) {
 133                 if ( m_action->isEnabled() ) {
 134                     setText( text().prepend( i18n("Default: ") ) );
 135                 }
 136             } else {
 137                 setText( text().mid( 9 ) );
 138             }
 139         }
 140
 141         bool operator<(const QListWidgetItem & other) const
 142         {
 143             // Rules:
 144             //      0. Default wins. Always.
 145             //      1. Exact trumps informational
 146             //      2. Informational trumps possible
 147             //      3. Higher relevance wins
 148
 149             const SearchMatch *otherMatch = dynamic_cast<const SearchMatch*>(&other);
 150
 151             if (!otherMatch) {
 152                 return QListWidgetItem::operator<(other);
 153             }
 154
 155             if (otherMatch->m_default) {
 156                 return true;
 157             }
 158
 159             Plasma::SearchMatch::Type myType = m_action->type();
 160             Plasma::SearchMatch::Type otherType = otherMatch->m_action->type();
 161
 162             if (myType != otherType) {
 163                 return myType < otherType;
 164             }
 165
 166             return m_action->relevance() < otherMatch->m_action->relevance();
 167         }
 168
 169     private:
 170         bool m_default;
 171         const Plasma::SearchMatch* m_action;
 172 };
 173
 174 // Restricts simultaneous jobs of the same type
 175 // Similar to ResourceRestrictionPolicy but check the object type first
 176 class RunnerRestrictionPolicy : public ThreadWeaver::QueuePolicy
 177 {
 178 public:
 179     ~RunnerRestrictionPolicy();
 180
 181     static RunnerRestrictionPolicy& instance();
 182
 183     void setCap(int cap)
 184     {
 185         m_cap = cap;
 186     }
 187     int cap() const
 188     {
 189         return m_cap;
 190     }
 191
 192     bool canRun(Job* job);
 193     void free(Job* job);
 194     void release(Job* job);
 195     void destructed(Job* job);
 196 private:
 197     RunnerRestrictionPolicy();
 198
 199 //     QHash<QString, int> m_runCounts;
 200     int m_count;
 201     int m_cap;
 202     QMutex m_mutex;
 203 };
 204
 205 RunnerRestrictionPolicy::RunnerRestrictionPolicy()
 206     : QueuePolicy(),
 207       m_cap(2)
 208 {
 209 }
 210
 211 RunnerRestrictionPolicy::~RunnerRestrictionPolicy()
 212 {
 213 }
 214
 215 RunnerRestrictionPolicy& RunnerRestrictionPolicy::instance()
 216 {
 217     static RunnerRestrictionPolicy policy;
 218     return policy;
 219 }
 220
 221 bool RunnerRestrictionPolicy::canRun(Job* job)
 222 {
 223     Q_UNUSED(job)
 224     QMutexLocker l(&m_mutex);
 225 //     QString type = job->objectName();
 226     if (m_count/*m_runCounts.value(type)*/ > m_cap) {
 227 //         kDebug() << "Denying job " << type << " because of " << m_count/*m_runCounts[type]*/ << " current jobs" << endl;
 228         return false;
 229     } else {
 230 //         m_runCounts[type]++;
 231         ++m_count;
 232         return true;
 233     }
 234 }
 235
 236 void RunnerRestrictionPolicy::free(Job* job)
 237 {
 238     Q_UNUSED(job)
 239     QMutexLocker l(&m_mutex);
 240 //     QString type = job->objectName();
 241     --m_count;
 242 //     if (m_runCounts.value(type)) {
 243 //         m_runCounts[type]--;
 244 //     }
 245 }
 246
 247 void RunnerRestrictionPolicy::release(Job* job)
 248 {
 249     free(job);
 250 }
 251
 252 void RunnerRestrictionPolicy::destructed(Job* job)
 253 {
 254     Q_UNUSED(job)
 255 }
 256
 257 // Class to run queries in different threads
 258 class FindMatchesJob : public Job
 259 {
 260 public:
 261     FindMatchesJob(const QString& term, Plasma::AbstractRunner* runner, Plasma::SearchContext* context, QObject* parent = 0);
 262
 263     int priority() const;
 264
 265 protected:
 266     void run();
 267 private:
 268     QString m_term;
 269     Plasma::SearchContext* m_context;
 270     Plasma::AbstractRunner* m_runner;
 271 };
 272
 273 FindMatchesJob::FindMatchesJob( const QString& term, Plasma::AbstractRunner* runner, Plasma::SearchContext* context, QObject* parent )
 274     : ThreadWeaver::Job(parent),
 275       m_term(term),
 276       m_context(context),
 277       m_runner(runner)
 278 {
 279 //     setObjectName( runner->objectName() );
 280     if (runner->speed() == Plasma::AbstractRunner::SlowSpeed) {
 281         assignQueuePolicy(&RunnerRestrictionPolicy::instance());
 282     }
 283 }
 284
 285 void FindMatchesJob::run()
 286 {
 287 //     kDebug() << "Running match for " << m_runner->objectName() << " in Thread " << thread()->id() << endl;
 288     m_runner->performMatch(*m_context);
 289 }
 290
 291 int FindMatchesJob::priority() const
 292 {
 293     return m_runner->priority();
 294 }
 295
 296 Interface::Interface(QWidget* parent)
 297     : KRunnerDialog( parent ),
 298       m_expander(0),
 299       m_optionsWidget(0),
 300       m_defaultMatch(0),
 301       m_execQueued(false)
 302 {
 303     setWindowTitle( i18n("Run Command") );
 304     setWindowIcon(KIcon("system-run"));
 305
 306     m_matchTimer.setSingleShot(true);
 307     connect(&m_matchTimer, SIGNAL(timeout()), this, SLOT(match()));
 308
 309     m_updateTimer.setSingleShot(true);
 310     connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateMatches()));
 311
 312     const int numProcs = qMax(Solid::Device::listFromType(Solid::DeviceInterface::Processor).count(), 1);
 313     const int numThreads = qMin(KRunnerSettings::maxThreads(), 2 + ((numProcs - 1) * 2));
 314     //kDebug() << "setting up" << numThreads << "threads for" << numProcs << "processors";
 315     Weaver::instance()->setMaximumNumberOfThreads(numThreads);
 316
 317     QWidget* w = mainWidget();
 318     m_layout = new QVBoxLayout(w);
 319     m_layout->setMargin(0);
 320
 321     m_header = new KTitleWidget(w);
 322     m_header->setBackgroundRole( QPalette::Base );
 323     m_layout->addWidget( m_header );
 324
 325     m_searchTerm = new KHistoryComboBox(false,w);
 326     m_searchTerm->setDuplicatesEnabled(false);
 327     KLineEdit *lineEdit = new KLineEdit(m_searchTerm);
 328     lineEdit->setCompletionObject(m_context.completionObject());
 329     lineEdit->setClearButtonShown(true);
 330     m_searchTerm->setLineEdit(lineEdit);
 331     m_header->setBuddy(m_searchTerm);
 332     m_layout->addWidget(m_searchTerm);
 333     connect(m_searchTerm, SIGNAL(editTextChanged(QString)),
 334             this, SLOT(queueMatch()));
 335     connect(m_searchTerm, SIGNAL(returnPressed()),
 336             this, SLOT(exec()));
 337
 338     QStringList executions = KRunnerSettings::pastQueries();
 339     //Handle updates to the completion object as well
 340     m_searchTerm->setHistoryItems(executions, true);
 341
 342     //TODO: temporary feedback, change later with the "icon parade" :)
 343     m_matchList = new QListWidget(w);
 344     //m_matchList->setSortingEnabled(true);
 345
 346     connect( m_matchList, SIGNAL(itemActivated(QListWidgetItem*)),
 347              SLOT(matchActivated(QListWidgetItem*)) );
 348     connect( m_matchList, SIGNAL(itemClicked(QListWidgetItem*)),
 349              SLOT(setDefaultItem(QListWidgetItem*)) );
 350     m_layout->addWidget(m_matchList);
 351
 352     // buttons at the bottom
 353     QHBoxLayout* bottomLayout = new QHBoxLayout(w);
 354     m_optionsButton = new KPushButton(KStandardGuiItem::configure(), this);
 355     m_optionsButton->setText( i18n( "Show Options" ) );
 356     m_optionsButton->setEnabled( false );
 357     m_optionsButton->setCheckable( true );
 358     connect( m_optionsButton, SIGNAL(toggled(bool)), SLOT(showOptions(bool)) );
 359     bottomLayout->addWidget( m_optionsButton );
 360
 361     KPushButton *activityButton = new KPushButton(w);
 362     activityButton->setText(i18n("Show System Activity"));
 363     activityButton->setIcon(KIcon("utilities-system-monitor"));
 364     connect(activityButton, SIGNAL(clicked()), qApp, SLOT(showTaskManager()));
 365     connect(activityButton, SIGNAL(clicked()), this, SLOT(close()));
 366     bottomLayout->addWidget(activityButton);
 367
 368     bottomLayout->addStretch();
 369
 370     QString runButtonWhatsThis = i18n( "Click to execute the selected item above" );
 371     m_runButton = new KPushButton(KGuiItem(i18n( "Launch" ), "system-run",
 372                                            QString(), runButtonWhatsThis),
 373                                   w);
 374     m_runButton->setEnabled( false );
 375     m_runButton->setDefault(true);
 376     connect( m_runButton, SIGNAL( clicked(bool) ), SLOT(exec()) );
 377     bottomLayout->addWidget( m_runButton );
 378
 379     m_cancelButton = new KPushButton(KStandardGuiItem::cancel(), w);
 380     connect( m_cancelButton, SIGNAL(clicked(bool)), SLOT(close()) );
 381     bottomLayout->addWidget( m_cancelButton );
 382
 383     m_layout->addLayout (bottomLayout );
 384
 385     new InterfaceAdaptor( this );
 386     QDBusConnection::sessionBus().registerObject( "/Interface", this );
 387
 388     new QShortcut( QKeySequence( Qt::Key_Escape ), this, SLOT(close()) );
 389
 390     //FIXME: what size should we be?
 391     resize(400, 250);
 392
 393     //setWidgetPalettes();
 394     //connect(KGlobalSettings::self(), SIGNAL(kdisplayPaletteChanged()),
 395     //        SLOT(setWidgetPalettes()));
 396
 397     //TODO: how should we order runners, particularly ones loaded from plugins?
 398     QStringList whitelist = KRunnerSettings::runners();
 399     m_runners += Plasma::AbstractRunner::load(this, whitelist);
 400
 401     connect(&m_context, SIGNAL(matchesChanged()), this, SLOT(queueUpdates()));
 402
 403     resetInterface();
 404
 405 //     ThreadWeaver::setDebugLevel(true, 4);
 406 }
 407
 408 Interface::~Interface()
 409 {
 410     KRunnerSettings::setPastQueries(m_searchTerm->historyItems());
 411     m_context.clearMatches();
 412 }
 413
 414 void Interface::clearHistory()
 415 {
 416     m_searchTerm->clearHistory();
 417     KRunnerSettings::setPastQueries(m_searchTerm->historyItems());
 418 }
 419
 420 void Interface::display(const QString& term)
 421 {
 422     m_searchTerm->setFocus();
 423
 424     if (!term.isEmpty()) {
 425         m_searchTerm->setItemText(0, term);
 426     }
 427
 428     if (!isVisible()) {
 429         queueMatch();
 430     }
 431
 432     KWindowSystem::setOnDesktop(winId(), KWindowSystem::currentDesktop());
 433
 434     int screen = 0;
 435     if (QApplication::desktop()->numScreens() > 1) {
 436         screen = QApplication::desktop()->screenNumber(QCursor::pos());
 437     }
 438
 439     KDialog::centerOnScreen(this, screen);
 440     show();
 441     KWindowSystem::forceActiveWindow(winId());
 442 }
 443
 444 void Interface::switchUser()
 445 {
 446     Plasma::AbstractRunner *sessionrunner = 0;
 447     foreach (Plasma::AbstractRunner* runner, m_runners) {
 448         if (qstrcmp(runner->metaObject()->className(), "SessionRunner") == 0) {
 449             sessionrunner = runner;
 450             break;
 451         }
 452     }
 453
 454     if (!sessionrunner) {
 455         kDebug() << "Could not find the Sessionrunner; not showing any sessions!";
 456         return;
 457     }
 458     //TODO: ugh, magic strings. See sessions/sessionrunner.cpp
 459     display("SESSIONS");
 460     m_header->setText(i18n("Switch users"));
 461     m_header->setPixmap("system-switch-user");
 462     m_defaultMatch = 0;
 463     m_context.resetSearchTerm("SESSIONS");
 464     sessionrunner->match(&m_context);
 465
 466     foreach (const Plasma::SearchMatch *action, m_context.matches()) {
 467         bool makeDefault = !m_defaultMatch && action->type() != Plasma::SearchMatch::InformationalMatch;
 468
 469         SearchMatch *match = new SearchMatch(action, m_matchList);
 470
 471         if (makeDefault) {
 472             m_defaultMatch = match;
 473             m_defaultMatch->setDefault(true);
 474             m_runButton->setEnabled(true);
 475             m_optionsButton->setEnabled(sessionrunner->hasMatchOptions());
 476         }
 477     }
 478
 479     if (!m_defaultMatch) {
 480         m_matchList->addItem(i18n("No desktop sessions available"));
 481     } else {
 482         m_matchList->sortItems(Qt::DescendingOrder);
 483     }
 484 }
 485
 486 void Interface::setWidgetPalettes()
 487 {
 488     // a nice palette to use with the widgets
 489     QPalette widgetPalette = palette();
 490     QColor headerBgColor = widgetPalette.color( QPalette::Active,
 491                                                 QPalette::Base );
 492     headerBgColor.setAlpha( 200 );
 493     widgetPalette.setColor( QPalette::Base, headerBgColor );
 494
 495     m_header->setPalette( widgetPalette );
 496     m_searchTerm->setPalette( widgetPalette );
 497     m_matchList->setPalette( widgetPalette );
 498 }
 499
 500 void Interface::resetInterface()
 501 {
 502     m_header->setText(i18n("Enter the name of an application, location or search term below."));
 503     m_header->setPixmap("system-search");
 504     m_defaultMatch = 0;
 505     m_context.resetSearchTerm(QString());
 506     m_searchTerm->setCurrentItem(QString(), true, 0);
 507     m_matchList->clear();
 508     m_runButton->setEnabled( false );
 509     m_optionsButton->setEnabled( false );
 510     showOptions( false );
 511     m_matchTimer.stop();
 512 }
 513
 514 void Interface::closeEvent(QCloseEvent* e)
 515 {
 516     resetInterface();
 517     e->accept();
 518 }
 519
 520 void Interface::matchActivated(QListWidgetItem* item)
 521 {
 522     SearchMatch* match = dynamic_cast<SearchMatch*>(item);
 523
 524     if (!match) {
 525         return;
 526     }
 527
 528     if (!match->actionEnabled()) {
 529         return;
 530     }
 531
 532     QString searchTerm = m_searchTerm->currentText();
 533     m_searchTerm->addToHistory(searchTerm);
 534
 535     if (match->actionType() == Plasma::SearchMatch::InformationalMatch) {
 536         //kDebug() << "informational match activated" << match->toString();
 537         m_searchTerm->setItemText(m_searchTerm->currentIndex(), match->toString());
 538     } else {
 539         //kDebug() << "match activated! " << match->text();
 540         QString term = m_searchTerm->currentText().trimmed();
 541         m_context.setSearchTerm(term);
 542
 543         match->activate(&m_context);
 544         close();
 545     }
 546 }
 547
 548 void Interface::queueMatch()
 549 {
 550     if (m_matchTimer.isActive()) {
 551         return;
 552     }
 553     Weaver::instance()->dequeue();
 554     m_matchTimer.start(200);
 555 }
 556
 557 void Interface::queueUpdates()
 558 {
 559     if (m_updateTimer.isActive()) {
 560         return;
 561     }
 562     //Wait 100ms between updating matches
 563     m_updateTimer.start(100);
 564 }
 565
 566 void Interface::match()
 567 {
 568     // If ThreadWeaver is idle, it is safe to clear previous jobs
 569     if ( Weaver::instance()->isIdle() ) {
 570         qDeleteAll( m_searchJobs );
 571         m_searchJobs.clear();
 572     }
 573     m_defaultMatch = 0;
 574
 575     QString term = m_searchTerm->currentText().trimmed();
 576
 577     if (term.isEmpty()) {
 578         resetInterface();
 579         m_execQueued = false;
 580         return;
 581     }
 582     m_context.resetSearchTerm(term);
 583     m_context.addStringCompletions(m_searchTerm->historyItems());
 584
 585     foreach (Plasma::AbstractRunner* runner, m_runners) {
 586         Job *job = new FindMatchesJob(term, runner, &m_context, this);
 587         Weaver::instance()->enqueue( job );
 588         m_searchJobs.append( job );
 589     }
 590 }
 591
 592 void Interface::updateMatches()
 593 {
 594     m_matchList->clear();
 595     m_defaultMatch = 0;
 596
 597     foreach (const Plasma::SearchMatch *action, m_context.matches()) {
 598         SearchMatch *match = new SearchMatch(action, m_matchList);
 599
 600         if (action->isEnabled() && action->relevance() > 0 &&
 601             (!m_defaultMatch || *m_defaultMatch < *match) &&
 602             (action->type() != Plasma::SearchMatch::InformationalMatch ||
 603              !action->data().toString().isEmpty())) {
 604             if (m_defaultMatch) {
 605                 m_defaultMatch->setDefault(false);
 606             }
 607
 608             match->setDefault(true);
 609             m_defaultMatch = match;
 610             m_optionsButton->setEnabled(action->runner()->hasMatchOptions());
 611             m_runButton->setEnabled(true);
 612         }
 613     }
 614
 615     m_matchList->sortItems(Qt::DescendingOrder);
 616     m_execQueued = false;
 617
 618     if (!m_defaultMatch) {
 619         showOptions(false);
 620         m_runButton->setEnabled(false);
 621     } else if (m_execQueued) {
 622         exec();
 623     }
 624 }
 625
 626 void Interface::exec()
 627 {
 628     if (!m_execQueued && m_searchTerm->completionBox() && m_searchTerm->completionBox()->isVisible()) {
 629         queueMatch();
 630         return;
 631     }
 632
 633     kDebug() << "match list has" << m_matchList->count() << "items";
 634
 635     QListWidgetItem* currentMatch = m_matchList->currentItem();
 636     if (!currentMatch) {
 637         if (m_defaultMatch) {
 638             currentMatch = m_defaultMatch;
 639         } else if (m_matchList->count() < 2) {
 640             //TODO: the < 2 is a bit of a hack; we *always* get a search option returned,
 641             //      so if we only have 1 item and it's not selected, guess what it is? ;)
 642             //      we might be able to do better here.
 643             m_execQueued = true;
 644             match();
 645             return;
 646         }
 647     }
 648     matchActivated(currentMatch);
 649 }
 650
 651 void Interface::showOptions(bool show)
 652 {
 653     //TODO: in the case where we are no longer showing options
 654     //      should we have the runner delete it's options?
 655     if (show) {
 656         if (!m_defaultMatch || !m_defaultMatch->hasMatchOptions()) {
 657             // in this case, there is nothing to show
 658             return;
 659         }
 660
 661         if (!m_expander) {
 662             //kDebug() << "creating m_expander";
 663             m_expander = new CollapsibleWidget( this );
 664             m_expander->show();
 665             connect( m_expander, SIGNAL( collapseCompleted() ),
 666                      m_expander, SLOT( close() ) );
 667             m_layout->insertWidget( 3, m_expander );
 668         }
 669
 670         //kDebug() << "set inner widget to " << m_defaultMatch->runner()->options();
 671         delete m_optionsWidget;
 672         m_optionsWidget = new QWidget(this);
 673         m_defaultMatch->createMatchOptions(m_optionsWidget);
 674         m_optionsButton->setText( i18n( "Hide Options" ) );
 675     } else {
 676         delete m_optionsWidget;
 677         m_optionsWidget = 0;
 678         m_optionsButton->setText( i18n( "Show Options" ) );
 679         resize( 400, 250 );
 680     }
 681
 682     if ( m_expander ) {
 683         //TODO: we need to insert an element into the krunner dialog
 684         //      that is big enough for the options. this will prevent
 685         //      other items in the dialog from moving around and look
 686         //      more "natural"; it should appear as if a "drawer" is
 687         //      being pulled open, e.g. an expander.
 688         m_expander->setInnerWidget(m_optionsWidget);
 689         m_expander->setVisible(show);
 690         m_expander->setExpanded(show);
 691     }
 692
 693     m_optionsButton->setChecked(show);
 694 }
 695
 696 void Interface::setDefaultItem( QListWidgetItem* item )
 697 {
 698     bool hasOptions = false;
 699
 700     if (item) {
 701         if (m_defaultMatch) {
 702             m_defaultMatch->setDefault(false);
 703         }
 704
 705         m_defaultMatch = dynamic_cast<SearchMatch*>(item);
 706         if (!m_defaultMatch) {
 707             return;
 708         }
 709         hasOptions = m_defaultMatch && m_defaultMatch->hasMatchOptions();
 710     }
 711
 712     m_optionsButton->setEnabled(hasOptions);
 713
 714     if (hasOptions) {
 715         if (m_expander && m_expander->isExpanded()) {
 716             m_optionsButton->setText(i18n("Hide Options"));
 717         } else {
 718             m_optionsButton->setText(i18n("Show Options"));
 719         }
 720     } else {
 721         m_optionsButton->setText(i18n("Show Options"));
 722         m_optionsButton->setChecked(false);
 723         if (m_expander) {
 724             m_expander->hide();
 725         }
 726     }
 727 }
 728
 729 #include "interface.moc"