Rename a number of libraries and executables to avoid conflicts with KDE4

1 files changed, 1191 insertions, 0 deletions

diff --git a/tdeio/tdefile/knotifydialog.cpp b/tdeio/tdefile/knotifydialog.cpp
new file mode 100644
index 000000000..a9639ae3d
--- /dev/null
+++ b/tdeio/tdefile/knotifydialog.cpp
@@ -0,0 +1,1191 @@
+/*
+  Copyright (C) 2000,2002 Carsten Pfeiffer <pfeiffer@kde.org>
+  Copyright (C) 2002 Neil Stevens <neil@qualityassistant.com>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License version 2 as published by the Free Software Foundation;
+
+  This program 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
+  General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public License
+  along with this library,  If not, write to the Free Software Foundation,
+  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include <dcopclient.h>
+
+#include <kaboutdata.h>
+#include <kapplication.h>
+#include <kaudioplayer.h>
+#include <kcombobox.h>
+#include <tdeconfig.h>
+#include <kcursor.h>
+#include <kdebug.h>
+#include <tdefiledialog.h>
+#include <kiconloader.h>
+#include <kicontheme.h>
+#include <klineedit.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <knotifyclient.h>
+#include <knotifydialog.h>
+#include <kstandarddirs.h>
+#include <kurlrequester.h>
+#include <tdeio/netaccess.h>
+
+#include <tqcheckbox.h>
+#include <tqgroupbox.h>
+#include <tqheader.h>
+#include <tqlabel.h>
+#include <tqlistview.h>
+#include <tqlayout.h>
+#include <tqptrlist.h>
+#include <tqpushbutton.h>
+#include <tqstring.h>
+#include <tqtooltip.h>
+#include <tqtimer.h>
+#include <tqvbox.h>
+#include <tqwhatsthis.h>
+
+using namespace KNotify;
+
+enum
+{
+    COL_EXECUTE = 0,
+    COL_STDERR  = 1,
+    COL_MESSAGE = 2,
+    COL_LOGFILE = 3,
+    COL_SOUND   = 4,
+    COL_TASKBAR = 5,
+    COL_EVENT   = 6
+};
+
+//
+// I don't feel like subclassing KComboBox and find ways to insert that into
+// the .ui file...
+//
+namespace KNotify
+{
+    class SelectionCombo
+    {
+    public:
+        //
+        // Mind the order in fill() and type()
+        //
+        static void fill( KComboBox *combo )
+        {
+            combo->insertItem( i18n("Sounds") );
+            combo->insertItem( i18n("Logging") );
+            combo->insertItem( i18n("Program Execution") );
+            combo->insertItem( i18n("Message Windows") );
+            combo->insertItem( i18n("Passive Windows") );
+            combo->insertItem( i18n("Standard Error Output") );
+            combo->insertItem( i18n("Taskbar") );
+        }
+
+        static int type( KComboBox *combo )
+        {
+            switch( combo->currentItem() )
+            {
+                case 0:
+                    return KNotifyClient::Sound;
+                case 1:
+                    return KNotifyClient::Logfile;
+                case 2:
+                    return KNotifyClient::Execute;
+                case 3:
+                    return KNotifyClient::Messagebox;
+                case 4:
+                    return KNotifyClient::PassivePopup;
+                case 5:
+                    return KNotifyClient::Stderr;
+                case 6:
+                    return KNotifyClient::Taskbar;
+            }
+
+            return KNotifyClient::None;
+        }
+    };
+
+    // Needed for displaying tooltips in the listview's QHeader
+    class KNotifyToolTip : public TQToolTip
+    {
+    public:
+        KNotifyToolTip( TQHeader *header )
+            : TQToolTip( header )
+        {
+            m_tips[COL_EXECUTE] = i18n("Execute a program");
+            m_tips[COL_STDERR]  = i18n("Print to Standard error output");
+            m_tips[COL_MESSAGE] = i18n("Display a messagebox");
+            m_tips[COL_LOGFILE] = i18n("Log to a file");
+            m_tips[COL_SOUND]   = i18n("Play a sound");
+            m_tips[COL_TASKBAR] = i18n("Flash the taskbar entry");
+        }
+        virtual ~KNotifyToolTip() {}
+
+    protected:
+        virtual void maybeTip ( const TQPoint& p )
+        {
+            TQHeader *header = static_cast<TQHeader*>( parentWidget() );
+            int section = 0;
+
+            if ( header->orientation() == Qt::Horizontal )
+                section= header->sectionAt( p.x() );
+            else
+                section= header->sectionAt( p.y() );
+
+            if ( ( section < 0 ) || ( static_cast<uint>( section ) >= (sizeof(m_tips) / sizeof(TQString)) ) )
+                return;
+
+            tip( header->sectionRect( section ), m_tips[section] );
+        }
+
+    private:
+        TQString m_tips[6];
+    };
+
+}
+
+
+int KNotifyDialog::configure( TQWidget *parent, const char *name,
+                              const TDEAboutData *aboutData )
+{
+    KNotifyDialog dialog( parent, name, true, aboutData );
+    return dialog.exec();
+}
+
+KNotifyDialog::KNotifyDialog( TQWidget *parent, const char *name, bool modal,
+                              const TDEAboutData *aboutData )
+    : KDialogBase(parent, name, modal, i18n("Notification Settings"),
+                  Ok | Apply | Cancel | Default, Ok, true )
+{
+    TQVBox *box = makeVBoxMainWidget();
+
+    m_notifyWidget = new KNotifyWidget( box, "knotify widget" );
+
+    if ( aboutData )
+        addApplicationEvents( aboutData->appName() );
+
+    connect( this, TQT_SIGNAL( okClicked() ), m_notifyWidget, TQT_SLOT( save() ));
+    connect( this, TQT_SIGNAL( applyClicked() ), m_notifyWidget, TQT_SLOT( save() ));
+}
+
+KNotifyDialog::~KNotifyDialog()
+{
+}
+
+void KNotifyDialog::addApplicationEvents( const char *appName )
+{
+    addApplicationEvents( TQString::fromUtf8( appName ) +
+                          TQString::fromLatin1( "/eventsrc" ) );
+}
+
+void KNotifyDialog::addApplicationEvents( const TQString& path )
+{
+    Application *app = m_notifyWidget->addApplicationEvents( path );
+    if ( app )
+    {
+        m_notifyWidget->addVisibleApp( app );
+        m_notifyWidget->sort();
+    }
+}
+
+void KNotifyDialog::clearApplicationEvents()
+{
+    m_notifyWidget->clear();
+}
+
+void KNotifyDialog::slotDefault()
+{
+    m_notifyWidget->resetDefaults( true ); // ask user
+}
+
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+
+class KNotifyWidget::Private
+{
+public:
+    TQPixmap pixmaps[6];
+    KNotifyToolTip *toolTip;
+};
+
+// simple access to all knotify-handled applications
+KNotifyWidget::KNotifyWidget( TQWidget *parent, const char *name,
+                              bool handleAllApps )
+    : KNotifyWidgetBase( parent, name ? name : "KNotifyWidget" )
+{
+    d = new Private;
+
+    m_allApps.setAutoDelete( true );
+
+    if ( !handleAllApps )
+    {
+        m_affectAllApps->hide();
+        m_playerButton->hide();
+    }
+
+    SelectionCombo::fill( m_comboEnable );
+    SelectionCombo::fill( m_comboDisable );
+
+    m_listview->setFullWidth( true );
+    m_listview->setAllColumnsShowFocus( true );
+
+    TQPixmap pexec = SmallIcon("exec");
+    TQPixmap pstderr = SmallIcon("terminal");
+    TQPixmap pmessage = SmallIcon("info");
+    TQPixmap plogfile = SmallIcon("log");
+    TQPixmap psound = SmallIcon("sound");
+    TQPixmap ptaskbar = SmallIcon("kicker");
+
+    d->pixmaps[COL_EXECUTE] = pexec;
+    d->pixmaps[COL_STDERR]  = pstderr;
+    d->pixmaps[COL_MESSAGE] = pmessage;
+    d->pixmaps[COL_LOGFILE] = plogfile;
+    d->pixmaps[COL_SOUND]   = psound;
+    d->pixmaps[COL_TASKBAR] = ptaskbar;
+
+    int w = KIcon::SizeSmall + 6;
+
+    TQHeader *header = m_listview->header();
+    header->setLabel( COL_EXECUTE, pexec,    TQString::null, w );
+    header->setLabel( COL_STDERR,  pstderr,  TQString::null, w );
+    header->setLabel( COL_MESSAGE, pmessage, TQString::null, w );
+    header->setLabel( COL_LOGFILE, plogfile, TQString::null, w );
+    header->setLabel( COL_SOUND,   psound,   TQString::null, w );
+    header->setLabel( COL_TASKBAR, ptaskbar, TQString::null, w );
+
+    d->toolTip = new KNotifyToolTip( header );
+
+    m_playButton->setIconSet( SmallIconSet( "player_play" ) );
+    connect( m_playButton, TQT_SIGNAL( clicked() ), TQT_SLOT( playSound() ));
+
+    connect( m_listview, TQT_SIGNAL( currentChanged( TQListViewItem * ) ),
+             TQT_SLOT( slotEventChanged( TQListViewItem * ) ));
+    connect( m_listview, TQT_SIGNAL(clicked( TQListViewItem *, const TQPoint&, int)),
+             TQT_SLOT( slotItemClicked( TQListViewItem *, const TQPoint&, int )));
+
+    connect( m_playSound, TQT_SIGNAL( toggled( bool )),
+             TQT_SLOT( soundToggled( bool )) );
+    connect( m_logToFile, TQT_SIGNAL( toggled( bool )),
+             TQT_SLOT( loggingToggled( bool )) );
+    connect( m_execute, TQT_SIGNAL( toggled( bool )),
+             TQT_SLOT( executeToggled( bool )) );
+    connect( m_messageBox, TQT_SIGNAL( toggled( bool )),
+             TQT_SLOT( messageBoxChanged() ) );
+    connect( m_passivePopup, TQT_SIGNAL( toggled( bool )),
+             TQT_SLOT( messageBoxChanged() ) );
+    connect( m_stderr, TQT_SIGNAL( toggled( bool )),
+             TQT_SLOT( stderrToggled( bool ) ) );
+    connect( m_taskbar, TQT_SIGNAL( toggled( bool )),
+             TQT_SLOT( taskbarToggled( bool ) ) );
+
+    connect( m_soundPath, TQT_SIGNAL( textChanged( const TQString& )),
+             TQT_SLOT( soundFileChanged( const TQString& )));
+    connect( m_logfilePath, TQT_SIGNAL( textChanged( const TQString& )),
+             TQT_SLOT( logfileChanged( const TQString& ) ));
+    connect( m_executePath, TQT_SIGNAL( textChanged( const TQString& )),
+             TQT_SLOT( commandlineChanged( const TQString& ) ));
+
+    connect( m_soundPath, TQT_SIGNAL( openFileDialog( KURLRequester * )),
+             TQT_SLOT( openSoundDialog( KURLRequester * )));
+    connect( m_logfilePath, TQT_SIGNAL( openFileDialog( KURLRequester * )),
+             TQT_SLOT( openLogDialog( KURLRequester * )));
+    connect( m_executePath, TQT_SIGNAL( openFileDialog( KURLRequester * )),
+             TQT_SLOT( openExecDialog( KURLRequester * )));
+
+    connect( m_extension, TQT_SIGNAL( clicked() ),
+             TQT_SLOT( toggleAdvanced()) );
+
+    connect( m_buttonEnable, TQT_SIGNAL( clicked() ), TQT_SLOT( enableAll() ));
+    connect( m_buttonDisable, TQT_SIGNAL( clicked() ), TQT_SLOT( enableAll() ));
+
+    TQString whatsThis = i18n("<qt>You may use the following macros<br>"
+        "in the commandline:<br>"
+        "<b>%e</b>: for the event name,<br>"
+        "<b>%a</b>: for the name of the application that sent the event,<br>"
+        "<b>%s</b>: for the notification message,<br>"
+        "<b>%w</b>: for the numeric window ID where the event originated,<br>"
+        "<b>%i</b>: for the numeric event ID.");
+    TQWhatsThis::add( m_execute, whatsThis );
+    TQWhatsThis::add( m_executePath, whatsThis );
+    
+    showAdvanced( false );
+
+    slotEventChanged( 0L ); // disable widgets by default
+}
+
+KNotifyWidget::~KNotifyWidget()
+{
+    delete d->toolTip;
+    delete d;
+}
+
+void KNotifyWidget::toggleAdvanced()
+{
+    showAdvanced( m_logToFile->isHidden() );
+}
+
+void KNotifyWidget::showAdvanced( bool show )
+{
+    if ( show )
+    {
+        m_extension->setText( i18n("Advanced <<") );
+        TQToolTip::add( m_extension, i18n("Hide advanced options") );
+
+        m_logToFile->show();
+        m_logfilePath->show();
+        m_execute->show();
+        m_executePath->show();
+        m_messageBox->show();
+        m_passivePopup->show();
+        m_stderr->show();
+        m_taskbar->show();
+
+	m_passivePopup->setEnabled( m_messageBox->isChecked() );
+        m_actionsBoxLayout->setSpacing( KDialog::spacingHint() );
+    }
+    else
+    {
+        m_extension->setText( i18n("Advanced >>") );
+        TQToolTip::add( m_extension, i18n("Show advanced options") );
+
+        m_logToFile->hide();
+        m_logfilePath->hide();
+        m_execute->hide();
+        m_executePath->hide();
+        m_messageBox->hide();
+        m_passivePopup->hide();
+        m_stderr->hide();
+        m_taskbar->hide();
+
+        m_actionsBoxLayout->setSpacing( 0 );
+    }
+}
+
+Application * KNotifyWidget::addApplicationEvents( const TQString& path )
+{
+    kdDebug() << "**** knotify: adding path: " << path << endl;
+    TQString relativePath = path;
+
+    if ( path.at(0) == '/' && KStandardDirs::exists( path ) )
+        relativePath = makeRelative( path );
+
+    if ( !relativePath.isEmpty() )
+    {
+        Application *app = new Application( relativePath );
+        m_allApps.append( app );
+        return app;
+    }
+
+    return 0L;
+}
+
+void KNotifyWidget::clear()
+{
+    clearVisible();
+    m_allApps.clear();
+}
+
+void KNotifyWidget::clearVisible()
+{
+    m_visibleApps.clear();
+    m_listview->clear();
+    slotEventChanged( 0L ); // disable widgets
+}
+
+void KNotifyWidget::showEvent( TQShowEvent *e )
+{
+    selectItem( m_listview->firstChild() );
+    KNotifyWidgetBase::showEvent( e );
+}
+
+void KNotifyWidget::slotEventChanged( TQListViewItem *item )
+{
+    bool on = (item != 0L);
+
+    m_actionsBox->setEnabled( on );
+    m_controlsBox->setEnabled( on );
+
+    if ( !on )
+        return;
+
+    ListViewItem *lit = static_cast<ListViewItem*>( item );
+    updateWidgets( lit );
+}
+
+void KNotifyWidget::updateWidgets( ListViewItem *item )
+{
+    bool enable;
+    bool checked;
+
+    blockSignals( true ); // don't emit changed() signals
+
+    const Event& event = item->event();
+
+    // sound settings
+    m_playButton->setEnabled( !event.soundfile.isEmpty() );
+    m_soundPath->setURL( event.soundfile );
+    enable = (event.dontShow & KNotifyClient::Sound) == 0;
+    checked = enable && !event.soundfile.isEmpty() &&
+              (event.presentation & KNotifyClient::Sound);
+    m_playSound->setEnabled( enable );
+    m_playSound->setChecked( checked );
+    m_soundPath->setEnabled( checked );
+
+
+    // logfile settings
+    m_logfilePath->setURL( event.logfile );
+    enable = (event.dontShow & KNotifyClient::Logfile) == 0;
+    checked = enable && !event.logfile.isEmpty()  &&
+              (event.presentation & KNotifyClient::Logfile);
+    m_logToFile->setEnabled( enable );
+    m_logToFile->setChecked( checked );
+    m_logfilePath->setEnabled( checked );
+
+
+    // execute program settings
+    m_executePath->setURL( event.commandline );
+    enable = (event.dontShow & KNotifyClient::Execute) == 0;
+    checked = enable && !event.commandline.isEmpty() &&
+              (event.presentation & KNotifyClient::Execute);
+    m_execute->setEnabled( enable );
+    m_execute->setChecked( checked );
+    m_executePath->setEnabled( checked );
+
+
+    // other settings
+    m_messageBox->setChecked(event.presentation & (KNotifyClient::Messagebox | KNotifyClient::PassivePopup));
+    enable = (event.dontShow & KNotifyClient::Messagebox) == 0;
+    m_messageBox->setEnabled( enable );
+
+    m_passivePopup->setChecked(event.presentation & KNotifyClient::PassivePopup);
+    enable = (event.dontShow & KNotifyClient::PassivePopup) == 0;
+    m_passivePopup->setEnabled( enable );
+
+    m_stderr->setChecked( event.presentation & KNotifyClient::Stderr );
+    enable = (event.dontShow & KNotifyClient::Stderr) == 0;
+    m_stderr->setEnabled( enable );
+
+    m_taskbar->setChecked(event.presentation & KNotifyClient::Taskbar);
+    enable = (event.dontShow & KNotifyClient::Taskbar) == 0;
+    m_taskbar->setEnabled( enable );
+
+    updatePixmaps( item );
+
+    blockSignals( false );
+}
+
+void KNotifyWidget::updatePixmaps( ListViewItem *item )
+{
+    TQPixmap emptyPix;
+    Event &event = item->event();
+
+    bool doIt = (event.presentation & KNotifyClient::Execute) &&
+                !event.commandline.isEmpty();
+    item->setPixmap( COL_EXECUTE, doIt ? d->pixmaps[COL_EXECUTE] : emptyPix );
+
+    doIt = (event.presentation & KNotifyClient::Sound) &&
+           !event.soundfile.isEmpty();
+    item->setPixmap( COL_SOUND, doIt ? d->pixmaps[COL_SOUND] : emptyPix );
+
+    doIt = (event.presentation & KNotifyClient::Logfile) &&
+           !event.logfile.isEmpty();
+    item->setPixmap( COL_LOGFILE, doIt ? d->pixmaps[COL_LOGFILE] : emptyPix );
+
+    item->setPixmap( COL_MESSAGE,
+                     (event.presentation &
+                      (KNotifyClient::Messagebox | KNotifyClient::PassivePopup)) ?
+                     d->pixmaps[COL_MESSAGE] : emptyPix );
+
+    item->setPixmap( COL_STDERR,
+                     (event.presentation & KNotifyClient::Stderr) ?
+                     d->pixmaps[COL_STDERR] : emptyPix );
+    item->setPixmap( COL_TASKBAR,
+                     (event.presentation & KNotifyClient::Taskbar) ?
+                     d->pixmaps[COL_TASKBAR] : emptyPix );
+}
+
+void KNotifyWidget::addVisibleApp( Application *app )
+{
+    if ( !app || (m_visibleApps.findRef( app ) != -1) )
+        return;
+
+    m_visibleApps.append( app );
+    addToView( app->eventList() );
+
+    TQListViewItem *item = m_listview->selectedItem();
+    if ( !item )
+        item = m_listview->firstChild();
+
+    selectItem( item );
+}
+
+void KNotifyWidget::addToView( const EventList& events )
+{
+    ListViewItem *item = 0L;
+
+    EventListIterator it( events );
+
+    for ( ; it.current(); ++it )
+    {
+        Event *event = it.current();
+        item = new ListViewItem( m_listview, event );
+
+        if ( (event->presentation & KNotifyClient::Execute) &&
+             !event->commandline.isEmpty() )
+            item->setPixmap( COL_EXECUTE, d->pixmaps[COL_EXECUTE] );
+        if ( (event->presentation & KNotifyClient::Sound) &&
+             !event->soundfile.isEmpty() )
+            item->setPixmap( COL_SOUND, d->pixmaps[COL_SOUND] );
+        if ( (event->presentation & KNotifyClient::Logfile) &&
+             !event->logfile.isEmpty() )
+            item->setPixmap( COL_LOGFILE, d->pixmaps[COL_LOGFILE] );
+        if ( event->presentation & (KNotifyClient::Messagebox|KNotifyClient::PassivePopup) )
+            item->setPixmap( COL_MESSAGE, d->pixmaps[COL_MESSAGE] );
+        if ( event->presentation & KNotifyClient::Stderr )
+            item->setPixmap( COL_STDERR, d->pixmaps[COL_STDERR] );
+        if ( event->presentation & KNotifyClient::Taskbar )
+            item->setPixmap( COL_TASKBAR, d->pixmaps[COL_TASKBAR] );
+    }
+}
+
+void KNotifyWidget::widgetChanged( TQListViewItem *item,
+                                   int what, bool on, TQWidget *buddy )
+{
+    if ( signalsBlocked() )
+        return;
+
+    if ( buddy )
+        buddy->setEnabled( on );
+
+    Event &e = static_cast<ListViewItem*>( item )->event();
+    if ( on )
+    {
+        e.presentation |= what;
+        if ( buddy )
+            buddy->setFocus();
+    }
+    else
+        e.presentation &= ~what;
+
+    emit changed( true );
+}
+
+void KNotifyWidget::soundToggled( bool on )
+{
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+    bool doIcon = on && !m_soundPath->url().isEmpty();
+    item->setPixmap( COL_SOUND, doIcon ? d->pixmaps[COL_SOUND] : TQPixmap() );
+    widgetChanged( item, KNotifyClient::Sound, on, m_soundPath );
+}
+
+void KNotifyWidget::loggingToggled( bool on )
+{
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+    bool doIcon = on && !m_logfilePath->url().isEmpty();
+    item->setPixmap(COL_LOGFILE, doIcon ? d->pixmaps[COL_LOGFILE] : TQPixmap());
+    widgetChanged( item, KNotifyClient::Logfile, on, m_logfilePath );
+}
+
+void KNotifyWidget::executeToggled( bool on )
+{
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+    bool doIcon = on && !m_executePath->url().isEmpty();
+    item->setPixmap(COL_EXECUTE, doIcon ? d->pixmaps[COL_EXECUTE] : TQPixmap());
+    widgetChanged( item, KNotifyClient::Execute, on, m_executePath );
+}
+
+void KNotifyWidget::messageBoxChanged()
+{
+    if ( signalsBlocked() )
+        return;
+
+    m_passivePopup->setEnabled( m_messageBox->isChecked() );
+
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+
+    bool on = m_passivePopup->isEnabled();
+    item->setPixmap( COL_MESSAGE, on ? d->pixmaps[COL_MESSAGE] : TQPixmap() );
+
+    Event &e = static_cast<ListViewItem*>( item )->event();
+
+    if ( m_messageBox->isChecked() ) {
+	if ( m_passivePopup->isChecked() ) {
+	    e.presentation |= KNotifyClient::PassivePopup;
+	    e.presentation &= ~KNotifyClient::Messagebox;
+	}
+	else {
+	    e.presentation &= ~KNotifyClient::PassivePopup;
+	    e.presentation |= KNotifyClient::Messagebox;
+	}
+    }
+    else {
+        e.presentation &= ~KNotifyClient::Messagebox;
+        e.presentation &= ~KNotifyClient::PassivePopup;
+    }
+
+    emit changed( true );
+}
+
+void KNotifyWidget::stderrToggled( bool on )
+{
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+    item->setPixmap( COL_STDERR, on ? d->pixmaps[COL_STDERR] : TQPixmap() );
+    widgetChanged( item, KNotifyClient::Stderr, on );
+}
+
+void KNotifyWidget::taskbarToggled( bool on )
+{
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+    item->setPixmap( COL_TASKBAR, on ? d->pixmaps[COL_TASKBAR] : TQPixmap() );
+    widgetChanged( item, KNotifyClient::Taskbar, on );
+}
+
+void KNotifyWidget::soundFileChanged( const TQString& text )
+{
+    if ( signalsBlocked() )
+        return;
+
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+
+    m_playButton->setEnabled( !text.isEmpty() );
+
+    currentEvent()->soundfile = text;
+    bool ok = !text.isEmpty() && m_playSound->isChecked();
+    item->setPixmap( COL_SOUND, ok ? d->pixmaps[COL_SOUND] : TQPixmap() );
+
+    emit changed( true );
+}
+
+void KNotifyWidget::logfileChanged( const TQString& text )
+{
+    if ( signalsBlocked() )
+        return;
+
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+
+    currentEvent()->logfile = text;
+    bool ok = !text.isEmpty() && m_logToFile->isChecked();
+    item->setPixmap( COL_LOGFILE, ok ? d->pixmaps[COL_LOGFILE] : TQPixmap() );
+
+    emit changed( true );
+}
+
+void KNotifyWidget::commandlineChanged( const TQString& text )
+{
+    if ( signalsBlocked() )
+        return;
+
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        return;
+
+    currentEvent()->commandline = text;
+    bool ok = !text.isEmpty() && m_execute->isChecked();
+    item->setPixmap( COL_EXECUTE, ok ? d->pixmaps[COL_EXECUTE] : TQPixmap() );
+
+    emit changed( true );
+}
+
+void KNotifyWidget::slotItemClicked( TQListViewItem *item, const TQPoint&,
+                                     int col )
+{
+    if ( !item || !item->isSelected() )
+        return;
+
+    Event *event = currentEvent();
+    if ( !event )
+        return; // very unlikely, but safety first
+
+    bool doShowAdvanced = false;
+
+    switch( col )
+    {
+        case COL_EXECUTE:
+            m_execute->toggle();
+            m_executePath->setFocus();
+            doShowAdvanced = true;
+            break;
+        case COL_STDERR:
+            m_stderr->toggle();
+            break;
+        case COL_TASKBAR:
+            m_taskbar->toggle();
+            break;
+        case COL_MESSAGE:
+            m_passivePopup->setChecked( true ); // default to passive popups
+            m_messageBox->toggle();
+            break;
+        case COL_LOGFILE:
+            m_logToFile->toggle();
+            m_logfilePath->setFocus();
+            doShowAdvanced = true;
+            break;
+        case COL_SOUND:
+            m_playSound->toggle();
+            break;
+        default: // do nothing
+            break;
+    }
+
+    if ( doShowAdvanced && !m_logToFile->isVisible() )
+    {
+        showAdvanced( true );
+        m_listview->ensureItemVisible( m_listview->currentItem() );
+    }
+}
+
+void KNotifyWidget::sort( bool ascending )
+{
+    m_listview->setSorting( COL_EVENT, ascending );
+    m_listview->sort();
+}
+
+void KNotifyWidget::selectItem( TQListViewItem *item )
+{
+    if ( item )
+    {
+        m_listview->setCurrentItem( item );
+        item->setSelected( true );
+        slotEventChanged( item );
+    }
+}
+
+void KNotifyWidget::resetDefaults( bool ask )
+{
+    if ( ask )
+    {
+        if ( KMessageBox::warningContinueCancel(this,
+                                   i18n("This will cause the notifications "
+                                        "to be reset to their defaults."),
+                                                i18n("Are You Sure?"),
+                                                i18n("&Reset"))
+             != KMessageBox::Continue)
+            return;
+    }
+
+    reload( true ); // defaults
+    emit changed( true );
+}
+
+void KNotifyWidget::reload( bool revertToDefaults )
+{
+    m_listview->clear();
+    ApplicationListIterator it( m_visibleApps );
+    for ( ; it.current(); ++it )
+    {
+        it.current()->reloadEvents( revertToDefaults );
+        addToView( it.current()->eventList() );
+    }
+
+    m_listview->sort();
+    selectItem( m_listview->firstChild()  );
+}
+
+void KNotifyWidget::save()
+{
+    kdDebug() << "save\n";
+
+    ApplicationListIterator it( m_allApps );
+    while ( it.current() )
+    {
+        (*it)->save();
+        ++it;
+    }
+
+    if ( kapp )
+    {
+        if ( !kapp->dcopClient()->isAttached() )
+            kapp->dcopClient()->attach();
+        kapp->dcopClient()->send("knotify", "", "reconfigure()", TQString(""));
+    }
+
+    emit changed( false );
+}
+
+// returns e.g. "twin/eventsrc" from a given path
+// "/opt/trinity/share/apps/twin/eventsrc"
+TQString KNotifyWidget::makeRelative( const TQString& fullPath )
+{
+    int slash = fullPath.findRev( '/' ) - 1;
+    slash = fullPath.findRev( '/', slash );
+
+    if ( slash < 0 )
+        return TQString::null;
+
+    return fullPath.mid( slash+1 );
+}
+
+Event * KNotifyWidget::currentEvent()
+{
+    TQListViewItem *current = m_listview->currentItem();
+    if ( !current )
+        return 0L;
+
+    return &static_cast<ListViewItem*>( current )->event();
+}
+
+void KNotifyWidget::openSoundDialog( KURLRequester *requester )
+{
+    // only need to init this once
+    requester->disconnect( TQT_SIGNAL( openFileDialog( KURLRequester * )),
+                           this, TQT_SLOT( openSoundDialog( KURLRequester * )));
+
+    KFileDialog *fileDialog = requester->fileDialog();
+    fileDialog->setCaption( i18n("Select Sound File") );
+    TQStringList filters;
+    filters << "audio/x-wav" << "audio/x-mp3" << "application/ogg"
+            << "audio/x-adpcm";
+    fileDialog->setMimeFilter( filters );
+
+    // find the first "sound"-resource that contains files
+    const Application *app = currentEvent()->application();
+    TQStringList soundDirs =
+        TDEGlobal::dirs()->findDirs("data", app->appName() + "/sounds");
+    soundDirs += TDEGlobal::dirs()->resourceDirs( "sound" );
+
+    if ( !soundDirs.isEmpty() ) {
+        KURL soundURL;
+        TQDir dir;
+        dir.setFilter( TQDir::Files | TQDir::Readable );
+        TQStringList::ConstIterator it = soundDirs.begin();
+        while ( it != soundDirs.end() ) {
+            dir = *it;
+            if ( dir.isReadable() && dir.count() > 2 ) {
+                soundURL.setPath( *it );
+                fileDialog->setURL( soundURL );
+                break;
+            }
+            ++it;
+        }
+    }
+}
+
+void KNotifyWidget::openLogDialog( KURLRequester *requester )
+{
+    // only need to init this once
+    requester->disconnect( TQT_SIGNAL( openFileDialog( KURLRequester * )),
+                           this, TQT_SLOT( openLogDialog( KURLRequester * )));
+
+    KFileDialog *fileDialog = requester->fileDialog();
+    fileDialog->setCaption( i18n("Select Log File") );
+    TQStringList filters;
+    filters << "text/x-log" << "text/plain";
+    fileDialog->setMimeFilter( filters );
+}
+
+void KNotifyWidget::openExecDialog( KURLRequester *requester )
+{
+    // only need to init this once
+    requester->disconnect( TQT_SIGNAL( openFileDialog( KURLRequester * )),
+                           this, TQT_SLOT( openExecDialog( KURLRequester * )));
+
+
+    KFileDialog *fileDialog = requester->fileDialog();
+    fileDialog->setCaption( i18n("Select File to Execute") );
+    TQStringList filters;
+    filters << "application/x-executable" << "application/x-shellscript"
+            << "application/x-perl" << "application/x-python";
+    fileDialog->setMimeFilter( filters );
+}
+
+void KNotifyWidget::playSound()
+{
+    TQString soundPath = m_soundPath->url();
+    if (!TDEIO::NetAccess::exists( m_soundPath->url(), true, 0 )) {        
+        bool foundSound=false;
+
+        // find the first "sound"-resource that contains files
+        const Application *app = currentEvent()->application();
+        TQStringList soundDirs = TDEGlobal::dirs()->findDirs("data", app->appName() + "/sounds");
+        soundDirs += TDEGlobal::dirs()->resourceDirs( "sound" );
+
+        if ( !soundDirs.isEmpty() ) {
+           TQDir dir;
+           dir.setFilter( TQDir::Files | TQDir::Readable );
+           TQStringList::ConstIterator it = soundDirs.begin();
+           while ( it != soundDirs.end() ) {
+               dir = *it;
+               if ( dir.isReadable() && dir.count() > 2 && 
+	            TDEIO::NetAccess::exists( *it + m_soundPath->url(), true, 0 )) {
+                       foundSound=true;
+                       soundPath = *it + m_soundPath->url();
+                       break;
+               }
+               ++it;
+           }
+        }
+        if ( !foundSound ) {
+            KMessageBox::sorry(this, i18n("The specified file does not exist." ));
+            return;
+        }
+    }
+    KAudioPlayer::play( soundPath );
+}
+
+void KNotifyWidget::enableAll()
+{
+    bool enable = (sender() == m_buttonEnable);
+    enableAll( SelectionCombo::type(enable ? m_comboEnable : m_comboDisable),
+               enable );
+}
+
+void KNotifyWidget::enableAll( int what, bool enable )
+{
+    if ( m_listview->childCount() == 0 )
+        return;
+
+    bool affectAll = m_affectAllApps->isChecked(); // multi-apps mode
+
+    ApplicationListIterator appIt( affectAll ? m_allApps : m_visibleApps );
+    for ( ; appIt.current(); ++appIt )
+    {
+        const EventList& events = appIt.current()->eventList();
+        EventListIterator it( events );
+        for ( ; it.current(); ++it )
+        {
+            if ( enable )
+                it.current()->presentation |= what;
+            else
+                it.current()->presentation &= ~what;
+        }
+    }
+
+    // now make the listview reflect the changes
+    TQListViewItemIterator it( m_listview->firstChild() );
+    for ( ; it.current(); ++it )
+    {
+        ListViewItem *item = static_cast<ListViewItem*>( it.current() );
+        updatePixmaps( item );
+    }
+
+    TQListViewItem *item = m_listview->currentItem();
+    if ( !item )
+        item = m_listview->firstChild();
+    selectItem( item );
+
+    emit changed( true );
+}
+
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+
+//
+// path must be "appname/eventsrc", i.e. a relative path
+//
+Application::Application( const TQString &path )
+{
+    TQString config_file = path;
+    config_file[config_file.find('/')] = '.';
+    m_events = 0L;
+    config = new TDEConfig(config_file, false, false);
+    kc = new TDEConfig(path, true, false, "data");
+    kc->setGroup( TQString::fromLatin1("!Global!") );
+    m_icon = kc->readEntry(TQString::fromLatin1("IconName"),
+                           TQString::fromLatin1("misc"));
+    m_description = kc->readEntry( TQString::fromLatin1("Comment"),
+                                   i18n("No description available") );
+
+    int index = path.find( '/' );
+    if ( index >= 0 )
+        m_appname = path.left( index );
+    else
+        kdDebug() << "Cannot determine application name from path: " << path << endl;
+}
+
+Application::~Application()
+{
+    delete config;
+    delete kc;
+    delete m_events;
+}
+
+
+const EventList&  Application::eventList()
+{
+    if ( !m_events ) {
+        m_events = new EventList;
+        m_events->setAutoDelete( true );
+        reloadEvents();
+    }
+
+    return *m_events;
+}
+
+
+void Application::save()
+{
+    if ( !m_events )
+        return;
+
+    EventListIterator it( *m_events );
+    Event *e;
+    while ( (e = it.current()) ) {
+        config->setGroup( e->configGroup );
+        config->writeEntry( "presentation", e->presentation );
+        config->writePathEntry( "soundfile", e->soundfile );
+        config->writePathEntry( "logfile", e->logfile );
+        config->writePathEntry( "commandline", e->commandline );
+
+        ++it;
+    }
+    config->sync();
+}
+
+
+void Application::reloadEvents( bool revertToDefaults )
+{
+    if ( m_events )
+        m_events->clear();
+    else
+    {
+        m_events = new EventList;
+        m_events->setAutoDelete( true );
+    }
+
+    Event *e = 0L;
+
+    TQString global = TQString::fromLatin1("!Global!");
+    TQString default_group = TQString::fromLatin1("<default>");
+    TQString name = TQString::fromLatin1("Name");
+    TQString comment = TQString::fromLatin1("Comment");
+
+    TQStringList conflist = kc->groupList();
+    TQStringList::ConstIterator it = conflist.begin();
+
+    while ( it != conflist.end() ) {
+        if ( (*it) != global && (*it) != default_group ) { // event group
+            kc->setGroup( *it );
+
+            e = new Event( this );
+            e->name = kc->readEntry( name );
+            e->description = kc->readEntry( comment );
+            e->dontShow = kc->readNumEntry("nopresentation", 0 );
+            e->configGroup = *it;
+            if ( e->name.isEmpty() && e->description.isEmpty() )
+                delete e;
+            else { // load the event
+                if( !e->name.isEmpty() && e->description.isEmpty() )
+                        e->description = e->name;
+                // default to passive popups over plain messageboxes
+                int default_rep = kc->readNumEntry("default_presentation",
+                                                   0 | KNotifyClient::PassivePopup);
+                TQString default_logfile = kc->readPathEntry("default_logfile");
+                TQString default_soundfile = kc->readPathEntry("default_sound");
+                TQString default_commandline = kc->readPathEntry("default_commandline");
+
+                config->setGroup(*it);
+
+                if ( revertToDefaults )
+                {
+                    e->presentation = default_rep;
+                    e->logfile = default_logfile;
+                    e->soundfile = default_soundfile;
+                    e->commandline = default_commandline;
+                }
+
+                else
+                {
+                    e->presentation = config->readNumEntry("presentation",
+                                                           default_rep);
+                    e->logfile = config->readPathEntry("logfile",
+                                                   default_logfile);
+                    e->soundfile = config->readPathEntry("soundfile",
+                                                     default_soundfile);
+                    e->commandline = config->readPathEntry("commandline",
+                                                       default_commandline);
+                }
+
+                m_events->append( e );
+            }
+        }
+
+        ++it;
+    }
+
+    return;
+}
+
+///////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////
+
+ListViewItem::ListViewItem( TQListView *view, Event *event )
+    : TQListViewItem( view ),
+      m_event( event )
+{
+    setText( COL_EVENT, event->text() );
+}
+
+int ListViewItem::compare ( TQListViewItem * i, int col, bool ascending ) const
+{
+    ListViewItem *item = static_cast<ListViewItem*>( i );
+    int myPres = m_event->presentation;
+    int otherPres = item->event().presentation;
+
+    int action = 0;
+
+    switch ( col )
+    {
+        case COL_EVENT: // use default sorting
+            return TQListViewItem::compare( i, col, ascending );
+
+        case COL_EXECUTE:
+            action = KNotifyClient::Execute;
+            break;
+        case COL_LOGFILE:
+            action = KNotifyClient::Logfile;
+            break;
+        case COL_MESSAGE:
+            action = (KNotifyClient::Messagebox | KNotifyClient::PassivePopup);
+            break;
+        case COL_SOUND:
+            action = KNotifyClient::Sound;
+            break;
+        case COL_STDERR:
+            action = KNotifyClient::Stderr;
+            break;
+        case COL_TASKBAR:
+            action = KNotifyClient::Taskbar;
+            break;
+    }
+
+    if ( (myPres & action) == (otherPres & action) )
+    {
+        // default sorting by event
+        return TQListViewItem::compare( i, COL_EVENT, true );
+    }
+
+    if ( myPres & action )
+        return -1;
+    if ( otherPres & action )
+        return 1;
+
+    return 0;
+}
+
+#include "knotifydialog.moc"