Initial import of knmap 2.1 sources

1 files changed, 664 insertions, 0 deletions

diff --git a/src/timingwidget.cpp b/src/timingwidget.cpp
new file mode 100644
index 0000000..30f121b
--- /dev/null
+++ b/src/timingwidget.cpp
@@ -0,0 +1,664 @@
+/***************************************************************************
+ *                                                                         *
+ *   Copyright (C) 2005, 2006 by Kevin Gilbert                             *
+ *   kev.gilbert@cdu.edu.au                                                *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   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 General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <qbuttongroup.h>
+#include <qcheckbox.h>
+#include <qiconset.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qradiobutton.h>
+
+#include <kconfig.h>
+#include <kdebug.h>
+#include <kglobal.h>
+#include <kiconloader.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+
+#include "timingwidget.h"
+#include "whatsthis.h"
+
+//	constructor
+//	===========
+
+TimingWidget::TimingWidget( QWidget* parent, const char* name )
+: QWidget( parent, name )
+{	createLayout( );
+}
+
+//	createLayout
+//	============
+
+void TimingWidget::createLayout( )
+{	QGridLayout* gridLayout       = new QGridLayout( this );
+	KIconLoader* iconLoader       = KGlobal::iconLoader( );
+	QIconSet     clearLeftIconSet = iconLoader->loadIconSet( "clear_left", KIcon::Small );
+
+	byte row = 1;
+	QButtonGroup* timingGroupBox = new QButtonGroup( 7, Qt::Vertical, "Simple Timing", this, "timing group box" );
+	m_defaultRadio               = new QRadioButton( i18n( "Default"          ), timingGroupBox, "default radio button"    );
+	m_aggressiveRadio            = new QRadioButton( i18n( "Aggressive (-T4)" ), timingGroupBox, "aggressive radio button" );
+	m_insaneRadio                = new QRadioButton( i18n( "Insane (-T5)"     ), timingGroupBox, "insane radio button"     );
+	m_normalRadio                = new QRadioButton( i18n( "Normal (-T3)"     ), timingGroupBox, "normal radio button"     );
+	m_paranoidRadio              = new QRadioButton( i18n( "Paranoid (-T0)"   ), timingGroupBox, "paranoid radio button"   );
+	m_politeRadio                = new QRadioButton( i18n( "Polite (-T2)"     ), timingGroupBox, "polite radio button"     );
+	m_sneakyRadio                = new QRadioButton( i18n( "Sneaky (-T1)"     ), timingGroupBox, "sneaky radio button"     );
+	gridLayout->addMultiCellWidget( timingGroupBox, row, row + 7, 1, 1 );
+	row += 7;
+	byte rowBlock1               = row;
+
+	m_hostTimeoutButton          = new QPushButton( clearLeftIconSet, NULL, this, "host timeout button"        );
+	m_initialRTTTimeoutButton    = new QPushButton( clearLeftIconSet, NULL, this, "initial rtt timeout button" );
+	m_maxHostGroupButton         = new QPushButton( clearLeftIconSet, NULL, this, "max host group button"      );
+	m_maxParallelismButton       = new QPushButton( clearLeftIconSet, NULL, this, "max parallelism button"     );
+	m_maxRTTTimeoutButton        = new QPushButton( clearLeftIconSet, NULL, this, "max rtt timeout button"     );
+	m_maxScanDelayButton         = new QPushButton( clearLeftIconSet, NULL, this, "max scan delay button"      );
+	m_minHostGroupButton         = new QPushButton( clearLeftIconSet, NULL, this, "min host group button"      );
+	m_minParallelismButton       = new QPushButton( clearLeftIconSet, NULL, this, "min parallelism button"     );
+	m_minRTTTimeoutButton        = new QPushButton( clearLeftIconSet, NULL, this, "min rtt timeout button"     );
+	m_scanDelayButton            = new QPushButton( clearLeftIconSet, NULL, this, "min scan delay button"      ); 
+
+	m_hostTimeoutCheckBox        = new QCheckBox( i18n( "Host timeout (--host_timeout)"               ), this, "host timeout checkbox" );
+	m_initialRTTTimeoutCheckBox  = new QCheckBox( i18n( "Initial RTT timeout (--initial_rtt_timeout)" ), this, "initial rtt timeout checkbox" );
+	m_maxHostGroupCheckBox       = new QCheckBox( i18n( "Max Host group (--max_hostgroup)"            ), this, "max host group checkbox" );
+	m_maxParallelismCheckBox     = new QCheckBox( i18n( "Max Parallelism (--max_parallelism)"         ), this, "max parallelism checkbox" );
+	m_maxRTTTimeoutCheckBox      = new QCheckBox( i18n( "Max RTT timeout (--max_rtt_timeout)"         ), this, "max rtt timeout checkbox" );
+	m_maxScanDelayCheckBox       = new QCheckBox( i18n( "Max Scan delay (--max_scan_delay)"           ), this, "max scan delay checkbox" );
+	m_minHostGroupCheckBox       = new QCheckBox( i18n( "Min Host group (--min_hostgroup)"            ), this, "min host group checkbox" );
+	m_minParallelismCheckBox     = new QCheckBox( i18n( "Min Parallelism (--min_parallelism)"         ), this, "min parallelism checkbox" );
+	m_minRTTTimeoutCheckBox      = new QCheckBox( i18n( "Min RTT timeout (--min_rtt_timeout)"         ), this, "min rtt timeout checkbox" );
+	m_scanDelayCheckBox          = new QCheckBox( i18n( "Min Scan delay (--scan_delay)"               ), this, "min scan delay checkbox" );
+
+	m_hostTimeoutLineEdit        = new QLineEdit( this, "host timeout line edit"        );
+	m_initialRTTTimeoutLineEdit  = new QLineEdit( this, "initial rtt timeout line edit" );
+	m_maxHostGroupLineEdit       = new QLineEdit( this, "max host group line edit"      );
+	m_maxParallelismLineEdit     = new QLineEdit( this, "max parallelism line edit"     );
+	m_maxRTTTimeoutLineEdit      = new QLineEdit( this, "max rtt timeout line edit"     );
+	m_maxScanDelayLineEdit       = new QLineEdit( this, "max scan delay line edit"      );
+	m_minHostGroupLineEdit       = new QLineEdit( this, "min host group line edit"      );
+	m_minParallelismLineEdit     = new QLineEdit( this, "min parallelism line edit"     );
+	m_minRTTTimeoutLineEdit      = new QLineEdit( this, "min rtt timeout line edit"     );
+	m_scanDelayLineEdit          = new QLineEdit( this, "min scan delay line edit"      );
+
+	m_hostTimeoutLineEdit->setInputMask( "999999" );
+	m_initialRTTTimeoutLineEdit->setInputMask( "999999" );
+	m_maxHostGroupLineEdit->setInputMask( "999999" );
+	m_maxParallelismLineEdit->setInputMask( "999999" );
+	m_maxRTTTimeoutLineEdit->setInputMask( "999999" );
+	m_maxScanDelayLineEdit->setInputMask( "999999" );
+	m_minHostGroupLineEdit->setInputMask( "999999" );
+	m_minParallelismLineEdit->setInputMask( "999999" );
+	m_minRTTTimeoutLineEdit->setInputMask( "999999" );
+	m_scanDelayLineEdit->setInputMask( "999999" );
+
+	row = 1;
+	gridLayout->addWidget( m_hostTimeoutCheckBox,       row,   3 );
+	gridLayout->addWidget( m_hostTimeoutLineEdit,       row,   4 );
+	gridLayout->addWidget( m_hostTimeoutButton,         row++, 5 );
+
+	gridLayout->addWidget( m_maxHostGroupCheckBox,      row,   3 );
+	gridLayout->addWidget( m_maxHostGroupLineEdit,      row,   4 );
+	gridLayout->addWidget( m_maxHostGroupButton,        row++, 5 );
+
+	gridLayout->addWidget( m_minHostGroupCheckBox,      row,   3 );
+	gridLayout->addWidget( m_minHostGroupLineEdit,      row,   4 );
+	gridLayout->addWidget( m_minHostGroupButton,        row++, 5 );
+
+	gridLayout->addWidget( m_maxParallelismCheckBox,    row,   3 );
+	gridLayout->addWidget( m_maxParallelismLineEdit,    row,   4 );
+	gridLayout->addWidget( m_maxParallelismButton,      row++, 5 );
+
+	gridLayout->addWidget( m_minParallelismCheckBox,    row,   3 );
+	gridLayout->addWidget( m_minParallelismLineEdit,    row,   4 );
+	gridLayout->addWidget( m_minParallelismButton,      row++, 5 );
+	byte rowBlock2 = row;
+
+	row = 1;
+	gridLayout->addWidget( m_initialRTTTimeoutCheckBox, row,   7 );
+	gridLayout->addWidget( m_initialRTTTimeoutLineEdit, row,   8 );
+	gridLayout->addWidget( m_initialRTTTimeoutButton,   row++, 9 );
+
+	gridLayout->addWidget( m_maxRTTTimeoutCheckBox,     row,   7 );
+	gridLayout->addWidget( m_maxRTTTimeoutLineEdit,     row,   8 );
+	gridLayout->addWidget( m_maxRTTTimeoutButton,       row++, 9 );
+
+	gridLayout->addWidget( m_minRTTTimeoutCheckBox,     row,   7 );
+	gridLayout->addWidget( m_minRTTTimeoutLineEdit,     row,   8 );
+	gridLayout->addWidget( m_minRTTTimeoutButton,       row++, 9 );
+
+	gridLayout->addWidget( m_maxScanDelayCheckBox,      row,   7 );
+	gridLayout->addWidget( m_maxScanDelayLineEdit,      row,   8 );
+	gridLayout->addWidget( m_maxScanDelayButton,        row++, 9 );
+
+	gridLayout->addWidget( m_scanDelayCheckBox,         row,   7 );
+	gridLayout->addWidget( m_scanDelayLineEdit,         row,   8 );
+	gridLayout->addWidget( m_scanDelayButton,           row++, 9 );
+	byte rowBlock3 = row;
+
+	gridLayout->setColStretch(  0,  3 );
+	gridLayout->setColStretch(  2,  3 );
+	gridLayout->setColStretch(  4, 10 );
+	gridLayout->setColStretch(  6,  3 );
+	gridLayout->setColStretch(  8, 10 );
+	gridLayout->setColStretch( 10,  3 );
+
+	gridLayout->setRowStretch( 0, 10 );
+	gridLayout->setRowStretch( _max_( rowBlock1, _max_( rowBlock2, rowBlock3 )) + 1, 10 );
+}
+
+//	finaliseInitialisation
+//	======================
+
+void TimingWidget::finaliseInitialisation( )
+{	WhatsThis* whatsThis = new WhatsThis( this );
+
+	connect( m_aggressiveRadio,           SIGNAL( clicked( )), SLOT( slotAggressiveRadioClicked( )));
+	connect( m_defaultRadio,              SIGNAL( clicked( )), SLOT( slotDefaultRadioClicked( )));
+	connect( m_hostTimeoutButton,         SIGNAL( clicked( )), SLOT( slotHostTimeoutButtonClicked( )));
+	connect( m_hostTimeoutCheckBox,       SIGNAL( clicked( )), SLOT( slotHostTimeoutCheckBoxClicked( )));
+	connect( m_initialRTTTimeoutButton,   SIGNAL( clicked( )), SLOT( slotInitialRTTTimeoutButtonClicked( )));
+	connect( m_initialRTTTimeoutCheckBox, SIGNAL( clicked( )), SLOT( slotInitialRTTTimeoutCheckBoxClicked( )));
+	connect( m_insaneRadio,               SIGNAL( clicked( )), SLOT( slotInsaneRadioClicked( )));
+	connect( m_maxHostGroupButton,        SIGNAL( clicked( )), SLOT( slotMaxHostGroupButtonClicked( )));
+	connect( m_maxHostGroupCheckBox,      SIGNAL( clicked( )), SLOT( slotMaxHostGroupCheckBoxClicked( )));
+	connect( m_maxParallelismButton,      SIGNAL( clicked( )), SLOT( slotMaxParallelismButtonClicked( )));
+	connect( m_maxParallelismCheckBox,    SIGNAL( clicked( )), SLOT( slotMaxParallelismCheckBoxClicked( )));
+	connect( m_maxRTTTimeoutButton,       SIGNAL( clicked( )), SLOT( slotMaxRTTTimeoutButtonClicked( )));
+	connect( m_maxRTTTimeoutCheckBox,     SIGNAL( clicked( )), SLOT( slotMaxRTTTimeoutCheckBoxClicked( )));
+	connect( m_maxScanDelayButton,        SIGNAL( clicked( )), SLOT( slotMaxScanDelayButtonClicked( )));
+	connect( m_maxScanDelayCheckBox,      SIGNAL( clicked( )), SLOT( slotMaxScanDelayCheckBoxClicked( )));
+	connect( m_minHostGroupButton,        SIGNAL( clicked( )), SLOT( slotMinHostGroupButtonClicked( )));
+	connect( m_minHostGroupCheckBox,      SIGNAL( clicked( )), SLOT( slotMinHostGroupCheckBoxClicked( )));
+	connect( m_minParallelismButton,      SIGNAL( clicked( )), SLOT( slotMinParallelismButtonClicked( )));
+	connect( m_minParallelismCheckBox,    SIGNAL( clicked( )), SLOT( slotMinParallelismCheckBoxClicked( )));
+	connect( m_minRTTTimeoutButton,       SIGNAL( clicked( )), SLOT( slotMinRTTTimeoutButtonClicked( )));
+	connect( m_minRTTTimeoutCheckBox,     SIGNAL( clicked( )), SLOT( slotMinRTTTimeoutCheckBoxClicked( )));
+	connect( m_normalRadio,               SIGNAL( clicked( )), SLOT( slotNormalRadioClicked( )));
+	connect( m_paranoidRadio,             SIGNAL( clicked( )), SLOT( slotParanoidRadioClicked( )));
+	connect( m_politeRadio,               SIGNAL( clicked( )), SLOT( slotPoliteRadioClicked( )));
+	connect( m_scanDelayButton,           SIGNAL( clicked( )), SLOT( slotScanDelayButtonClicked( )));
+	connect( m_scanDelayCheckBox,         SIGNAL( clicked( )), SLOT( slotScanDelayCheckBoxClicked( )));
+	connect( m_sneakyRadio,               SIGNAL( clicked( )), SLOT( slotSneakyRadioClicked( )));
+	connect( whatsThis,                   SIGNAL( clicked( )), SLOT( slotWhatsThisClicked( )));
+
+	connect( m_aggressiveRadio,           SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_defaultRadio,              SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_hostTimeoutCheckBox,       SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_hostTimeoutLineEdit,       SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_initialRTTTimeoutCheckBox, SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_initialRTTTimeoutLineEdit, SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_insaneRadio,               SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_maxHostGroupCheckBox,      SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_maxHostGroupLineEdit,      SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_maxParallelismCheckBox,    SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_maxParallelismLineEdit,    SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_maxRTTTimeoutCheckBox,     SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_maxRTTTimeoutLineEdit,     SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_maxScanDelayCheckBox,      SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_maxScanDelayLineEdit,      SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_minHostGroupCheckBox,      SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_minHostGroupLineEdit,      SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_minParallelismCheckBox,    SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_minParallelismLineEdit,    SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_minRTTTimeoutCheckBox,     SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_minRTTTimeoutLineEdit,     SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_normalRadio,               SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_paranoidRadio,             SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_politeRadio,               SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_scanDelayCheckBox,         SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+	connect( m_scanDelayLineEdit,         SIGNAL( textChanged( const QString& )), SIGNAL( optionsDirty( )));
+	connect( m_sneakyRadio,               SIGNAL( clicked( )),                    SIGNAL( optionsDirty( )));
+}
+
+//	getOptions
+//	==========
+
+bool TimingWidget::getOptions( )
+{	bool    maxHostGroupState   = m_maxHostGroupCheckBox->isChecked( );
+	uint    maxHostGroupValue   = m_maxHostGroupLineEdit->text( ).toUInt( );
+	bool    maxParallelismState = m_maxParallelismCheckBox->isChecked( );
+	uint    maxParallelismValue = m_maxParallelismLineEdit->text( ).toUInt( );
+	bool    maxRTTTimeoutState  = m_maxRTTTimeoutCheckBox->isChecked( );
+	uint    maxRTTTimeoutValue  = m_maxRTTTimeoutLineEdit->text( ).toUInt( );
+	bool    maxScanDelayState   = m_maxScanDelayCheckBox->isChecked( );
+	uint    maxScanDelayValue   = m_maxScanDelayLineEdit->text( ).toUInt( );
+	bool    minHostGroupState   = m_minHostGroupCheckBox->isChecked( );
+	uint    minHostGroupValue   = m_minHostGroupLineEdit->text( ).toUInt( );
+	bool    minParallelismState = m_minParallelismCheckBox->isChecked( );
+	uint    minParallelismValue = m_minParallelismLineEdit->text( ).toUInt( );
+	bool    minRTTTimeoutState  = m_minRTTTimeoutCheckBox->isChecked( );
+	uint    minRTTTimeoutValue  = m_minRTTTimeoutLineEdit->text( ).toUInt( );
+	bool    scanDelayState      = m_scanDelayCheckBox->isChecked( );
+	uint    scanDelayValue      = m_scanDelayLineEdit->text( ).toUInt( );
+
+	if( minHostGroupValue > maxHostGroupValue )
+	{	KMessageBox::error( this, i18n( QString( "Min host group not < Max host group" )), i18n( "Host group error" ));
+		return false;
+	}
+
+	if( minParallelismValue > maxParallelismValue )
+	{	KMessageBox::error( this, i18n( QString( "Min parallelism not < Max parallelism" )), i18n( "Parallelism error" ));
+		return false;
+	}
+
+	if( minRTTTimeoutValue > maxRTTTimeoutValue )
+	{	KMessageBox::error( this, i18n( QString( "Min RTT timeout not < Max RTT timeout" )), i18n( "RTT timeout error" ));
+		return false;
+	}
+
+	if( scanDelayValue > maxScanDelayValue )
+	{	KMessageBox::error( this, i18n( QString( "Min scan delay not < Max scan delay" )), i18n( "Scan delay error" ));
+		return false;
+	}
+
+	m_hostTimeoutState       = m_hostTimeoutCheckBox->isChecked( );
+	m_hostTimeoutValue       = m_hostTimeoutLineEdit->text( ).toUInt( );
+	m_initialRTTTimeoutState = m_initialRTTTimeoutCheckBox->isChecked( );
+	m_initialRTTTimeoutValue = m_initialRTTTimeoutLineEdit->text( ).toUInt( );
+	m_maxHostGroupState      = maxHostGroupState;
+	m_maxHostGroupValue      = maxHostGroupValue;
+	m_maxParallelismState    = maxParallelismState;
+	m_maxParallelismValue    = maxParallelismValue;
+	m_maxRTTTimeoutState     = maxRTTTimeoutState;
+	m_maxRTTTimeoutValue     = maxRTTTimeoutValue;
+	m_maxScanDelayState      = maxScanDelayState;
+	m_maxScanDelayValue      = maxScanDelayValue;
+	m_minHostGroupState      = minHostGroupState;
+	m_minHostGroupValue      = minHostGroupValue;
+	m_minParallelismState    = minParallelismState;
+	m_minParallelismValue    = minParallelismValue;
+	m_minRTTTimeoutState     = minRTTTimeoutState;
+	m_minRTTTimeoutValue     = minRTTTimeoutValue;
+	m_scanDelayState         = scanDelayState;
+	m_scanDelayValue         = scanDelayValue;
+
+	return true;
+}
+
+//	readProfile
+//	===========
+
+void TimingWidget::readProfile( KConfig* config )
+{	m_hostTimeoutState        = config->readBoolEntry( "hostTimeoutState"        );
+	m_hostTimeoutValue        = config->readNumEntry(  "hostTimeoutValue"        );
+	m_initialRTTTimeoutState  = config->readBoolEntry( "initialRTTTimeoutState"  );
+	m_initialRTTTimeoutValue  = config->readNumEntry(  "initialRTTTimeoutValue"  );
+	m_maxHostGroupState       = config->readBoolEntry( "maxHostGroupState"       );
+	m_maxHostGroupValue       = config->readNumEntry(  "maxHostGroupValue"       );
+	m_maxParallelismState     = config->readBoolEntry( "maxParallelismState"     );
+	m_maxParallelismValue     = config->readNumEntry(  "maxParallelismValue"     );
+	m_maxRTTTimeoutState      = config->readBoolEntry( "maxRTTTimeoutState"      );
+	m_maxRTTTimeoutValue      = config->readNumEntry(  "maxRTTTimeoutValue"      );
+	m_maxScanDelayState       = config->readBoolEntry( "maxScanDelayState"       );
+	m_maxScanDelayValue       = config->readNumEntry(  "maxScanDelayValue"       );
+	m_minHostGroupState       = config->readBoolEntry( "minHostGroupState"       );
+	m_minHostGroupValue       = config->readNumEntry(  "minHostGroupValue"       );
+	m_minParallelismState     = config->readBoolEntry( "minParallelismState"     );
+	m_minParallelismValue     = config->readNumEntry(  "minParallelismValue"     );
+	m_minRTTTimeoutState      = config->readBoolEntry( "minRTTTimeoutState"      );
+	m_minRTTTimeoutValue      = config->readNumEntry(  "minRTTTimeoutValue"      );
+	m_scanDelayState          = config->readBoolEntry( "scanDelayState"          );
+	m_scanDelayValue          = config->readNumEntry(  "scanDelayValue"          );
+
+	m_simpleTimingValue       = Timing( config->readNumEntry( "simpleTimingValue", Normal_T3_Timing ));
+}
+
+//	saveProfile
+//	===========
+
+void TimingWidget::saveProfile( KConfig* config )
+{	config->writeEntry( "hostTimeoutState",       m_hostTimeoutState       );
+	config->writeEntry( "hostTimeoutValue",       m_hostTimeoutValue       );
+	config->writeEntry( "initialRTTTimeoutState", m_initialRTTTimeoutState );
+	config->writeEntry( "initialRTTTimeoutValue", m_initialRTTTimeoutValue );
+	config->writeEntry( "maxHostGroupState",      m_maxHostGroupState      );
+	config->writeEntry( "maxHostGroupValue",      m_maxHostGroupValue      );
+	config->writeEntry( "maxParallelismState",    m_maxParallelismState    );
+	config->writeEntry( "maxParallelismValue",    m_maxParallelismValue    );
+	config->writeEntry( "maxRTTTimeoutState",     m_maxRTTTimeoutState     );
+	config->writeEntry( "maxRTTTimeoutValue",     m_maxRTTTimeoutValue     );
+	config->writeEntry( "maxScanDelayState",      m_maxScanDelayState      );	
+	config->writeEntry( "maxScanDelayValue",      m_maxScanDelayValue      );
+	config->writeEntry( "minHostGroupState",      m_minHostGroupState      );
+	config->writeEntry( "minHostGroupValue",      m_minHostGroupValue      );
+	config->writeEntry( "minParallelismState",    m_minParallelismState    );
+	config->writeEntry( "minParallelismValue",    m_minParallelismValue    );
+	config->writeEntry( "minRTTTimeoutState",     m_minRTTTimeoutState     );
+	config->writeEntry( "minRTTTimeoutValue",     m_minRTTTimeoutValue     );
+	config->writeEntry( "scanDelayState",         m_scanDelayState         );
+	config->writeEntry( "scanDelayValue",         m_scanDelayValue         );
+	config->writeEntry( "simpleTimingValue",      m_simpleTimingValue      );
+}
+
+//	setInitialValues
+//	================
+
+void TimingWidget::setInitialValues( )
+{	m_hostTimeoutCheckBox->setChecked( m_hostTimeoutState );
+	m_hostTimeoutLineEdit->setEnabled( m_hostTimeoutState );
+	m_hostTimeoutLineEdit->setText( QString::number( m_hostTimeoutValue ));
+	m_initialRTTTimeoutCheckBox->setChecked( m_initialRTTTimeoutState );
+	m_initialRTTTimeoutLineEdit->setEnabled( m_initialRTTTimeoutState );
+	m_initialRTTTimeoutLineEdit->setText( QString::number( m_initialRTTTimeoutValue ));
+	m_maxHostGroupCheckBox->setChecked( m_maxHostGroupState );
+	m_maxHostGroupLineEdit->setEnabled( m_maxHostGroupState );
+	m_maxHostGroupLineEdit->setText( QString::number( m_maxHostGroupValue ));
+	m_maxParallelismCheckBox->setChecked( m_maxParallelismState );
+	m_maxParallelismLineEdit->setEnabled( m_maxParallelismState );
+	m_maxParallelismLineEdit->setText( QString::number( m_maxParallelismValue ));
+	m_maxRTTTimeoutCheckBox->setChecked( m_maxRTTTimeoutState );
+	m_maxRTTTimeoutLineEdit->setEnabled( m_maxRTTTimeoutState );
+	m_maxRTTTimeoutLineEdit->setText( QString::number( m_maxRTTTimeoutValue ));
+	m_maxScanDelayCheckBox->setChecked( m_maxScanDelayState );
+	m_maxScanDelayLineEdit->setEnabled( m_maxScanDelayState );
+	m_maxScanDelayLineEdit->setText( QString::number( m_maxScanDelayValue ));
+	m_minHostGroupCheckBox->setChecked( m_minHostGroupState );
+	m_minHostGroupLineEdit->setEnabled( m_minHostGroupState );
+	m_minHostGroupLineEdit->setText( QString::number( m_minHostGroupValue ));
+	m_minParallelismCheckBox->setChecked( m_minParallelismState );
+	m_minParallelismLineEdit->setEnabled( m_minParallelismState );
+	m_minParallelismLineEdit->setText( QString::number( m_minParallelismValue ));
+	m_minRTTTimeoutCheckBox->setChecked( m_minRTTTimeoutState );
+	m_minRTTTimeoutLineEdit->setEnabled( m_minRTTTimeoutState );
+	m_minRTTTimeoutLineEdit->setText( QString::number( m_minRTTTimeoutValue ));
+	m_scanDelayCheckBox->setChecked( m_scanDelayState );
+	m_scanDelayLineEdit->setEnabled( m_scanDelayState );
+	m_scanDelayLineEdit->setText( QString::number( m_scanDelayValue ));
+
+	switch( m_simpleTimingValue )
+	{	case Aggressive_T4_Timing: m_aggressiveRadio->setChecked( true ); break;
+		case Default_Timing:       m_defaultRadio->setChecked( true );    break;
+		case Insane_T5_Timing:     m_insaneRadio->setChecked( true );     break;
+		case Normal_T3_Timing:     m_normalRadio->setChecked( true );     break;
+		case Paranoid_T0_Timing:   m_paranoidRadio->setChecked( true );   break;
+		case Polite_T2_Timing:     m_politeRadio->setChecked( true );     break;
+		case Sneaky_T1_Timing:     m_sneakyRadio->setChecked( true );     break;
+
+		default:
+			kdDebug( ) << "internal error - unknown simple timing value " << m_simpleTimingValue << endl;
+			ASSERT( false );
+	}
+}
+
+//	simpleTiming
+//	============
+
+QString TimingWidget::simpleTiming( ) const
+{	switch( m_simpleTimingValue )
+	{	case Aggressive_T4_Timing: return "Aggressive";
+		case Default_Timing:       return "";
+		case Insane_T5_Timing:     return "Insane";
+		case Normal_T3_Timing:     return "Normal";
+		case Paranoid_T0_Timing:   return "Paranoid";
+		case Polite_T2_Timing:     return "Polite";
+		case Sneaky_T1_Timing:     return "Sneaky";
+	}
+
+	kdDebug( ) << "internal error - unknown simple timing value " << m_simpleTimingValue << endl;
+	ASSERT( false );
+	return QString::null;
+}
+
+//	slotAggressiveRadioClicked
+//	==========================
+
+void TimingWidget::slotAggressiveRadioClicked( )
+{	m_simpleTimingValue = Aggressive_T4_Timing;
+}
+
+//	slotDefaultRadioClicked
+//	=======================
+
+void TimingWidget::slotDefaultRadioClicked( )
+{	m_simpleTimingValue = Default_Timing;
+}
+
+//	slotHostTimeoutButtonClicked
+//	============================
+
+void TimingWidget::slotHostTimeoutButtonClicked( )
+{	m_hostTimeoutLineEdit->clear( );
+}
+
+//	slotHostTimeoutCheckBoxClicked
+//	==============================
+
+void TimingWidget::slotHostTimeoutCheckBoxClicked( )
+{	m_hostTimeoutButton->setEnabled( m_hostTimeoutCheckBox->isChecked( ));
+	m_hostTimeoutLineEdit->setEnabled( m_hostTimeoutCheckBox->isChecked( ));
+}
+
+//	slotInitialRTTTimeoutButtonClicked
+//	==================================
+
+void TimingWidget::slotInitialRTTTimeoutButtonClicked( )
+{	m_initialRTTTimeoutLineEdit->clear( );
+}
+
+//	slotInitialRTTTimeoutCheckBoxClicked
+//	====================================
+
+void TimingWidget::slotInitialRTTTimeoutCheckBoxClicked( )
+{	m_initialRTTTimeoutButton->setEnabled( m_initialRTTTimeoutCheckBox->isChecked( ));
+	m_initialRTTTimeoutLineEdit->setEnabled( m_initialRTTTimeoutCheckBox->isChecked( ));
+}
+
+//	slotInsaneRadioClicked
+//	======================
+
+void TimingWidget::slotInsaneRadioClicked( )
+{	m_simpleTimingValue = Insane_T5_Timing;
+}
+
+//	slotMaxHostGroupButtonClicked
+//	=============================
+
+void TimingWidget::slotMaxHostGroupButtonClicked( )
+{	m_maxHostGroupLineEdit->clear( );
+}
+
+//	slotMaxHostGroupCheckBoxClicked
+//	===============================
+
+void TimingWidget::slotMaxHostGroupCheckBoxClicked( )
+{	m_maxHostGroupButton->setEnabled( m_maxHostGroupCheckBox->isChecked( ));
+	m_maxHostGroupLineEdit->setEnabled( m_maxHostGroupCheckBox->isChecked( ));
+}
+
+//	slotMaxParallelismButtonClicked
+//	===============================
+
+void TimingWidget::slotMaxParallelismButtonClicked( )
+{	m_maxParallelismLineEdit->clear( );
+}
+
+//	slotMaxParallelismCheckBoxClicked
+//	=================================
+
+void TimingWidget::slotMaxParallelismCheckBoxClicked( )
+{	m_maxParallelismButton->setEnabled( m_maxParallelismCheckBox->isChecked( ));
+	m_maxParallelismLineEdit->setEnabled( m_maxParallelismCheckBox->isChecked( ));
+}
+
+//	slotMaxRTTTimeoutButtonClicked
+//	==============================
+
+void TimingWidget::slotMaxRTTTimeoutButtonClicked( )
+{	m_maxRTTTimeoutLineEdit->clear( );
+}
+
+//	slotMaxRTTTimeoutCheckBoxClicked
+//	================================
+
+void TimingWidget::slotMaxRTTTimeoutCheckBoxClicked( )
+{	m_maxRTTTimeoutButton->setEnabled( m_maxRTTTimeoutCheckBox->isChecked( ));
+	m_maxRTTTimeoutLineEdit->setEnabled( m_maxRTTTimeoutCheckBox->isChecked( ));
+}
+
+//	slotMaxScanDelayButtonClicked
+//	=============================
+
+void TimingWidget::slotMaxScanDelayButtonClicked( )
+{	m_maxScanDelayLineEdit->clear( );
+}
+
+//	slotMaxScanDelayCheckBoxClicked
+//	===============================
+
+void TimingWidget::slotMaxScanDelayCheckBoxClicked( )
+{	m_maxScanDelayButton->setEnabled( m_maxScanDelayCheckBox->isChecked( ));
+	m_maxScanDelayLineEdit->setEnabled( m_maxScanDelayCheckBox->isChecked( ));
+}
+
+//	slotMinHostGroupButtonClicked
+//	=============================
+
+void TimingWidget::slotMinHostGroupButtonClicked( )
+{	m_minHostGroupLineEdit->clear( );
+}
+
+//	slotMinHostGroupCheckBoxClicked
+//	===============================
+
+void TimingWidget::slotMinHostGroupCheckBoxClicked( )
+{	m_minHostGroupButton->setEnabled( m_minHostGroupCheckBox->isChecked( ));
+	m_minHostGroupLineEdit->setEnabled( m_minHostGroupCheckBox->isChecked( ));
+}
+
+//	slotMinParallelismButtonClicked
+//	===============================
+
+void TimingWidget::slotMinParallelismButtonClicked( )
+{	m_minParallelismLineEdit->clear( );
+}
+
+//	slotMinParallelismCheckBoxClicked
+//	=================================
+
+void TimingWidget::slotMinParallelismCheckBoxClicked( )
+{	m_minParallelismButton->setEnabled( m_minParallelismCheckBox->isChecked( ));
+	m_minParallelismLineEdit->setEnabled( m_minParallelismCheckBox->isChecked( ));
+}
+
+//	slotMinRTTTimeoutButtonClicked
+//	==============================
+
+void TimingWidget::slotMinRTTTimeoutButtonClicked( )
+{	m_minRTTTimeoutLineEdit->clear( );
+}
+
+//	slotMinRTTTimeoutCheckBoxClicked
+//	================================
+
+void TimingWidget::slotMinRTTTimeoutCheckBoxClicked( )
+{	m_minRTTTimeoutButton->setEnabled( m_minRTTTimeoutCheckBox->isChecked( ));
+	m_minRTTTimeoutLineEdit->setEnabled( m_minRTTTimeoutCheckBox->isChecked( ));
+}
+
+//	slotNormalRadioClicked
+//	======================
+
+void TimingWidget::slotNormalRadioClicked( )
+{	m_simpleTimingValue = Normal_T3_Timing;
+}
+
+//	slotParanoidRadioClicked
+//	========================
+
+void TimingWidget::slotParanoidRadioClicked( )
+{	m_simpleTimingValue = Paranoid_T0_Timing;
+}
+
+//	slotPoliteRadioClicked
+//	======================
+
+void TimingWidget::slotPoliteRadioClicked( )
+{	m_simpleTimingValue = Polite_T2_Timing;
+}
+
+//	slotScanDelayButtonClicked
+//	==========================
+
+void TimingWidget::slotScanDelayButtonClicked( )
+{	m_scanDelayLineEdit->clear( );
+}
+
+//	slotScanDelayCheckBoxClicked
+//	============================
+
+void TimingWidget::slotScanDelayCheckBoxClicked( )
+{	m_scanDelayButton->setEnabled( m_scanDelayCheckBox->isChecked( ));
+	m_scanDelayLineEdit->setEnabled( m_scanDelayCheckBox->isChecked( ));
+}
+
+//	slotSneakyRadioClicked
+//	======================
+
+void TimingWidget::slotSneakyRadioClicked( )
+{	m_simpleTimingValue = Sneaky_T1_Timing;
+}
+
+//	slotWhatsThisClicked
+//	====================
+
+void TimingWidget::slotWhatsThisClicked( )
+{		 if( m_aggressiveRadio->hasMouse( ))           emit( displayHelp( "-T"                    ));
+	else if( m_defaultRadio->hasMouse( ))              emit( displayDocBook( "timing_options"     ));
+	else if( m_hostTimeoutButton->hasMouse( ))         emit( displayHelp( "--host_timeout"        ));
+	else if( m_hostTimeoutCheckBox->hasMouse( ))       emit( displayHelp( "--host_timeout"        ));
+	else if( m_hostTimeoutLineEdit->hasMouse( ))       emit( displayHelp( "--host_timeout"        ));
+	else if( m_initialRTTTimeoutButton->hasMouse( ))   emit( displayHelp( "--initial_rtt_timeout" ));
+	else if( m_initialRTTTimeoutCheckBox->hasMouse( )) emit( displayHelp( "--initial_rtt_timeout" ));
+	else if( m_initialRTTTimeoutLineEdit->hasMouse( )) emit( displayHelp( "--initial_rtt_timeout" ));
+	else if( m_insaneRadio->hasMouse( ))               emit( displayHelp( "-T"                    ));
+	else if( m_maxHostGroupButton->hasMouse( ))        emit( displayHelp( "--max_hostgroup"       ));
+	else if( m_maxHostGroupCheckBox->hasMouse( ))      emit( displayHelp( "--max_hostgroup"       ));
+	else if( m_maxHostGroupLineEdit->hasMouse( ))      emit( displayHelp( "--max_hostgroup"       ));
+	else if( m_maxParallelismButton->hasMouse( ))      emit( displayHelp( "--max_parallelism"     ));
+	else if( m_maxParallelismCheckBox->hasMouse( ))    emit( displayHelp( "--max_parallelism"     ));
+	else if( m_maxParallelismLineEdit->hasMouse( ))    emit( displayHelp( "--max_parallelism"     ));
+	else if( m_maxRTTTimeoutButton->hasMouse( ))       emit( displayHelp( "--max_rtt_timeout"     ));
+	else if( m_maxRTTTimeoutCheckBox->hasMouse( ))     emit( displayHelp( "--max_rtt_timeout"     ));
+	else if( m_maxRTTTimeoutLineEdit->hasMouse( ))     emit( displayHelp( "--max_rtt_timeout"     ));
+	else if( m_maxScanDelayButton->hasMouse( ))        emit( displayHelp( "--max_scan_delay"      ));
+	else if( m_maxScanDelayCheckBox->hasMouse( ))      emit( displayHelp( "--max_scan_delay"      ));
+	else if( m_maxScanDelayLineEdit->hasMouse( ))      emit( displayHelp( "--max_scan_delay"      ));
+	else if( m_minHostGroupButton->hasMouse( ))        emit( displayHelp( "--min_hostgroup"       ));
+	else if( m_minHostGroupCheckBox->hasMouse( ))      emit( displayHelp( "--min_hostgroup"       ));
+	else if( m_minHostGroupLineEdit->hasMouse( ))      emit( displayHelp( "--min_hostgroup"       ));
+	else if( m_minParallelismButton->hasMouse( ))      emit( displayHelp( "--min_parallelism"     ));
+	else if( m_minParallelismCheckBox->hasMouse( ))    emit( displayHelp( "--min_parallelism"     ));
+	else if( m_minParallelismLineEdit->hasMouse( ))    emit( displayHelp( "--min_parallelism"     ));
+	else if( m_minRTTTimeoutButton->hasMouse( ))       emit( displayHelp( "--min_rtt_timeout"     ));
+	else if( m_minRTTTimeoutCheckBox->hasMouse( ))     emit( displayHelp( "--min_rtt_timeout"     ));
+	else if( m_minRTTTimeoutLineEdit->hasMouse( ))     emit( displayHelp( "--min_rtt_timeout"     ));
+	else if( m_normalRadio->hasMouse( ))               emit( displayHelp( "-T"                    ));
+	else if( m_paranoidRadio->hasMouse( ))             emit( displayHelp( "-T"                    ));
+	else if( m_politeRadio->hasMouse( ))               emit( displayHelp( "-T"                    ));
+	else if( m_scanDelayButton->hasMouse( ))           emit( displayHelp( "--scan_delay"          ));
+	else if( m_scanDelayCheckBox->hasMouse( ))         emit( displayHelp( "--scan_delay"          ));
+	else if( m_scanDelayLineEdit->hasMouse( ))         emit( displayHelp( "--scan_delay"          ));
+	else if( m_sneakyRadio->hasMouse( ))               emit( displayHelp( "-T"                    ));
+	else emit( displayUnknown( ));
+}