Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

43 files changed, 244 insertions, 244 deletions

diff --git a/kalarm/alarmcalendar.cpp b/kalarm/alarmcalendar.cpp
index d0150d00e..f47e962cf 100644
--- a/kalarm/alarmcalendar.cpp
+++ b/kalarm/alarmcalendar.cpp
@@ -717,7 +717,7 @@ void AlarmCalendar::purgeIfQueued()
 void AlarmCalendar::startPurgeTimer()
 {
 	if (mPurgeDays > 0)
-		StartOfDayTimer::connect(this, TQT_SLOT(slotPurge()));
+		StartOfDayTimer::connect(this, TQ_SLOT(slotPurge()));
 }
 
 /******************************************************************************
diff --git a/kalarm/alarmtimewidget.cpp b/kalarm/alarmtimewidget.cpp
index fc2d1635a..6586b8968 100644
--- a/kalarm/alarmtimewidget.cpp
+++ b/kalarm/alarmtimewidget.cpp
@@ -83,7 +83,7 @@ void AlarmTimeWidget::init(int mode)
 	                                      "If a recurrence is configured, the start date/time will be adjusted "
 	                                      "to the first recurrence on or after the entered date/time.");
 
-	connect(this, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotButtonSet(int)));
+	connect(this, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotButtonSet(int)));
 	TQBoxLayout* topLayout = new TQVBoxLayout(this, 0, KDialog::spacingHint());
 	if (!title().isEmpty())
 	{
@@ -101,7 +101,7 @@ void AlarmTimeWidget::init(int mode)
 	// Date edit box
 	mDateEdit = new DateEdit(this);
 	mDateEdit->setFixedSize(mDateEdit->sizeHint());
-	connect(mDateEdit, TQT_SIGNAL(dateEntered(const TQDate&)), TQT_SLOT(dateTimeChanged()));
+	connect(mDateEdit, TQ_SIGNAL(dateEntered(const TQDate&)), TQ_SLOT(dateTimeChanged()));
 	static const TQString enterDateText = i18n("Enter the date to schedule the alarm.");
 	TQWhatsThis::add(mDateEdit, ((mode & DEFER_TIME) ? enterDateText
 	                            : TQString("%1\n%2").arg(enterDateText).arg(recurText)));
@@ -112,7 +112,7 @@ void AlarmTimeWidget::init(int mode)
 	timeBox->setSpacing(2*KDialog::spacingHint());
 	mTimeEdit = new TimeEdit(timeBox);
 	mTimeEdit->setFixedSize(mTimeEdit->sizeHint());
-	connect(mTimeEdit, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(dateTimeChanged()));
+	connect(mTimeEdit, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(dateTimeChanged()));
 	static const TQString enterTimeText = i18n("Enter the time to schedule the alarm.");
 	TQWhatsThis::add(mTimeEdit,
 	                ((mode & DEFER_TIME) ? TQString("%1\n\n%2").arg(enterTimeText).arg(TimeSpinBox::shiftWhatsThis())
@@ -129,7 +129,7 @@ void AlarmTimeWidget::init(int mode)
 		mAnyTimeAllowed = true;
 		mAnyTimeCheckBox = new CheckBox(i18n("An&y time"), timeBox);
 		mAnyTimeCheckBox->setFixedSize(mAnyTimeCheckBox->sizeHint());
-		connect(mAnyTimeCheckBox, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotAnyTimeToggled(bool)));
+		connect(mAnyTimeCheckBox, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAnyTimeToggled(bool)));
 		TQWhatsThis::add(mAnyTimeCheckBox, i18n("Schedule the alarm for any time during the day"));
 	}
 
@@ -145,7 +145,7 @@ void AlarmTimeWidget::init(int mode)
 	mDelayTimeEdit = new TimeSpinBox(1, maxDelayTime, this);
 	mDelayTimeEdit->setValue(maxDelayTime);
 	mDelayTimeEdit->setFixedSize(mDelayTimeEdit->sizeHint());
-	connect(mDelayTimeEdit, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(delayTimeChanged(int)));
+	connect(mDelayTimeEdit, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(delayTimeChanged(int)));
 	TQWhatsThis::add(mDelayTimeEdit,
 	                ((mode & DEFER_TIME) ? TQString("%1\n\n%2").arg(i18n_TimeAfterPeriod()).arg(TimeSpinBox::shiftWhatsThis())
 	                                     : TQString("%1\n%2\n\n%3").arg(i18n_TimeAfterPeriod()).arg(recurText).arg(TimeSpinBox::shiftWhatsThis())));
@@ -182,7 +182,7 @@ void AlarmTimeWidget::init(int mode)
 	setButton(id(mAtTimeRadio));
 
 	// Timeout every minute to update alarm time fields.
-	MinuteTimer::connect(this, TQT_SLOT(slotTimer()));
+	MinuteTimer::connect(this, TQ_SLOT(slotTimer()));
 }
 
 /******************************************************************************
diff --git a/kalarm/birthdaydlg.cpp b/kalarm/birthdaydlg.cpp
index 51a86e945..0a1cd1576 100644
--- a/kalarm/birthdaydlg.cpp
+++ b/kalarm/birthdaydlg.cpp
@@ -91,7 +91,7 @@ BirthdayDlg::BirthdayDlg(TQWidget* parent)
 	mPrefix = new BLineEdit(mPrefixText, textGroup);
 	mPrefix->setMinimumSize(mPrefix->sizeHint());
 	label->setBuddy(mPrefix);
-	connect(mPrefix, TQT_SIGNAL(focusLost()), TQT_SLOT(slotTextLostFocus()));
+	connect(mPrefix, TQ_SIGNAL(focusLost()), TQ_SLOT(slotTextLostFocus()));
 	TQWhatsThis::add(mPrefix,
 	      i18n("Enter text to appear before the person's name in the alarm message, "
 	           "including any necessary trailing spaces."));
@@ -100,7 +100,7 @@ BirthdayDlg::BirthdayDlg(TQWidget* parent)
 	mSuffix = new BLineEdit(mSuffixText, textGroup);
 	mSuffix->setMinimumSize(mSuffix->sizeHint());
 	label->setBuddy(mSuffix);
-	connect(mSuffix, TQT_SIGNAL(focusLost()), TQT_SLOT(slotTextLostFocus()));
+	connect(mSuffix, TQ_SIGNAL(focusLost()), TQ_SLOT(slotTextLostFocus()));
 	TQWhatsThis::add(mSuffix,
 	      i18n("Enter text to appear after the person's name in the alarm message, "
 	           "including any necessary leading spaces."));
@@ -114,7 +114,7 @@ BirthdayDlg::BirthdayDlg(TQWidget* parent)
 	mAddresseeList->setFullWidth(true);
 	mAddresseeList->addColumn(i18n("Name"));
 	mAddresseeList->addColumn(i18n("Birthday"));
-	connect(mAddresseeList, TQT_SIGNAL(selectionChanged()), TQT_SLOT(slotSelectionChanged()));
+	connect(mAddresseeList, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelectionChanged()));
 	TQWhatsThis::add(mAddresseeList,
 	      i18n("Select birthdays to set alarms for.\n"
 	           "This list shows all birthdays in KAddressBook except those for which alarms already exist.\n\n"
@@ -198,7 +198,7 @@ void BirthdayDlg::loadAddressBook()
 #if KDE_IS_VERSION(3,1,90)
         	mAddressBook = TDEABC::StdAddressBook::self(true);
 		if (mAddressBook)
-                	connect(mAddressBook, TQT_SIGNAL(addressBookChanged(AddressBook*)), TQT_SLOT(updateSelectionList()));
+                	connect(mAddressBook, TQ_SIGNAL(addressBookChanged(AddressBook*)), TQ_SLOT(updateSelectionList()));
 #else
 		mAddressBook = TDEABC::StdAddressBook::self();
 		if (mAddressBook)
@@ -421,7 +421,7 @@ BListView::BListView(TQWidget* parent, const char* name)
 	: TDEListView(parent, name)
 {
 	TDEAccel* accel = new TDEAccel(this);
-	accel->insert(TDEStdAccel::SelectAll, this, TQT_SLOT(slotSelectAll()));
-	accel->insert(TDEStdAccel::Deselect, this, TQT_SLOT(slotDeselect()));
+	accel->insert(TDEStdAccel::SelectAll, this, TQ_SLOT(slotSelectAll()));
+	accel->insert(TDEStdAccel::Deselect, this, TQ_SLOT(slotDeselect()));
 	accel->readSettings();
 }
diff --git a/kalarm/daemon.cpp b/kalarm/daemon.cpp
index 842514d9a..fd0996326 100644
--- a/kalarm/daemon.cpp
+++ b/kalarm/daemon.cpp
@@ -95,7 +95,7 @@ void Daemon::initialise()
 {
 	if (!mInstance)
 		mInstance = new Daemon();
-	connect(AlarmCalendar::activeCalendar(), TQT_SIGNAL(calendarSaved(AlarmCalendar*)), mInstance, TQT_SLOT(slotCalendarSaved(AlarmCalendar*)));
+	connect(AlarmCalendar::activeCalendar(), TQ_SIGNAL(calendarSaved(AlarmCalendar*)), mInstance, TQ_SLOT(slotCalendarSaved(AlarmCalendar*)));
 }
 
 /******************************************************************************
@@ -111,10 +111,10 @@ void Daemon::createDcopHandler()
 	mRunning = isRunning(false);
 
 	mStatusTimerInterval = Preferences::daemonTrayCheckInterval();
-	Preferences::connect(TQT_SIGNAL(preferencesChanged()), mInstance, TQT_SLOT(slotPreferencesChanged()));
+	Preferences::connect(TQ_SIGNAL(preferencesChanged()), mInstance, TQ_SLOT(slotPreferencesChanged()));
 
 	mStatusTimer = new TQTimer(mInstance);
-	connect(mStatusTimer, TQT_SIGNAL(timeout()), mInstance, TQT_SLOT(timerCheckIfRunning()));
+	connect(mStatusTimer, TQ_SIGNAL(timeout()), mInstance, TQ_SLOT(timerCheckIfRunning()));
 	mStatusTimer->start(mStatusTimerInterval * 1000);  // check regularly if daemon is running
 }
 
@@ -145,7 +145,7 @@ bool Daemon::start()
 			kdDebug(5950) << "Daemon::start(): Alarm daemon started" << endl;
 			mStartTimeout = 5000/startCheckInterval + 1;    // check daemon status for 5 seconds before giving up
 			mStartTimer = new TQTimer(mInstance);
-			connect(mStartTimer, TQT_SIGNAL(timeout()), mInstance, TQT_SLOT(checkIfStarted()));
+			connect(mStartTimer, TQ_SIGNAL(timeout()), mInstance, TQ_SLOT(checkIfStarted()));
 			mStartTimer->start(startCheckInterval);
 			mInstance->checkIfStarted();
 			return true;
@@ -201,7 +201,7 @@ bool Daemon::registerWith(bool reregister)
 		return false;
 	}
 	mRegisterTimer = new TQTimer(mInstance);
-	connect(mRegisterTimer, TQT_SIGNAL(timeout()), mInstance, TQT_SLOT(registerTimerExpired()));
+	connect(mRegisterTimer, TQ_SIGNAL(timeout()), mInstance, TQ_SLOT(registerTimerExpired()));
 	mRegisterTimer->start(REGISTER_TIMEOUT * 1000);     // wait for the reply
 	return true;
 }
@@ -327,7 +327,7 @@ void Daemon::updateRegisteredStatus(bool timeout)
 				// The daemon has newly been detected as registered with DCOP.
 				// Wait for a short time to ensure that it is ready for DCOP calls.
 				mStatus = RUNNING;
-				TQTimer::singleShot(startCheckInterval, mInstance, TQT_SLOT(slotStarted()));
+				TQTimer::singleShot(startCheckInterval, mInstance, TQ_SLOT(slotStarted()));
 				break;
 			case RUNNING:
 				if (timeout)
@@ -569,8 +569,8 @@ void Daemon::slotPreferencesChanged()
 AlarmEnableAction* Daemon::createAlarmEnableAction(TDEActionCollection* actions, const char* name)
 {
 	AlarmEnableAction* a = new AlarmEnableAction(0, actions, name);
-	connect(a, TQT_SIGNAL(userClicked(bool)), mInstance, TQT_SLOT(setAlarmsEnabled(bool)));
-	connect(mInstance, TQT_SIGNAL(daemonRunning(bool)), a, TQT_SLOT(setCheckedActual(bool)));
+	connect(a, TQ_SIGNAL(userClicked(bool)), mInstance, TQ_SLOT(setAlarmsEnabled(bool)));
+	connect(mInstance, TQ_SIGNAL(daemonRunning(bool)), a, TQ_SLOT(setCheckedActual(bool)));
 	return a;
 }
 
diff --git a/kalarm/deferdlg.cpp b/kalarm/deferdlg.cpp
index c5fab8808..7a37f3f92 100644
--- a/kalarm/deferdlg.cpp
+++ b/kalarm/deferdlg.cpp
@@ -53,7 +53,7 @@ DeferAlarmDlg::DeferAlarmDlg(const TQString& caption, const DateTime& initialDT,
 	mTimeWidget = new AlarmTimeWidget(AlarmTimeWidget::DEFER_TIME, page, "timeGroup");
 	mTimeWidget->setDateTime(initialDT);
 	mTimeWidget->setMinDateTimeIsCurrent();
-	connect(mTimeWidget, TQT_SIGNAL(pastMax()), TQT_SLOT(slotPastLimit()));
+	connect(mTimeWidget, TQ_SIGNAL(pastMax()), TQ_SLOT(slotPastLimit()));
 	layout->addWidget(mTimeWidget);
 	layout->addSpacing(spacingHint());
 
diff --git a/kalarm/editdlg.cpp b/kalarm/editdlg.cpp
index 5ceb16e1e..a95b35db3 100644
--- a/kalarm/editdlg.cpp
+++ b/kalarm/editdlg.cpp
@@ -211,7 +211,7 @@ EditAlarmDlg::EditAlarmDlg(bool Template, const TQString& caption, TQWidget* par
 	mTabs->addTab(mainPageBox, i18n("&Alarm"));
 	mMainPageIndex = 0;
 	PageFrame* mainPage = new PageFrame(mainPageBox);
-	connect(mainPage, TQT_SIGNAL(shown()), TQT_SLOT(slotShowMainPage()));
+	connect(mainPage, TQ_SIGNAL(shown()), TQ_SLOT(slotShowMainPage()));
 	TQVBoxLayout* topLayout = new TQVBoxLayout(mainPage, 0, spacingHint());
 
 	// Recurrence tab
@@ -220,15 +220,15 @@ EditAlarmDlg::EditAlarmDlg(bool Template, const TQString& caption, TQWidget* par
 	mTabs->addTab(recurTab, TQString());
 	mRecurPageIndex = 1;
 	mRecurrenceEdit = new RecurrenceEdit(readOnly, recurTab, "recurPage");
-	connect(mRecurrenceEdit, TQT_SIGNAL(shown()), TQT_SLOT(slotShowRecurrenceEdit()));
-	connect(mRecurrenceEdit, TQT_SIGNAL(typeChanged(int)), TQT_SLOT(slotRecurTypeChange(int)));
-	connect(mRecurrenceEdit, TQT_SIGNAL(frequencyChanged()), TQT_SLOT(slotRecurFrequencyChange()));
-	connect(mRecurrenceEdit, TQT_SIGNAL(repeatNeedsInitialisation()), TQT_SLOT(slotSetSubRepetition()));
+	connect(mRecurrenceEdit, TQ_SIGNAL(shown()), TQ_SLOT(slotShowRecurrenceEdit()));
+	connect(mRecurrenceEdit, TQ_SIGNAL(typeChanged(int)), TQ_SLOT(slotRecurTypeChange(int)));
+	connect(mRecurrenceEdit, TQ_SIGNAL(frequencyChanged()), TQ_SLOT(slotRecurFrequencyChange()));
+	connect(mRecurrenceEdit, TQ_SIGNAL(repeatNeedsInitialisation()), TQ_SLOT(slotSetSubRepetition()));
 
 	// Alarm action
 
 	mActionGroup = new ButtonGroup(i18n("Action"), mainPage, "actionGroup");
-	connect(mActionGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotAlarmTypeChanged(int)));
+	connect(mActionGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotAlarmTypeChanged(int)));
 	topLayout->addWidget(mActionGroup, 1);
 	TQBoxLayout* layout = new TQVBoxLayout(mActionGroup, marginHint(), spacingHint());
 	layout->addSpacing(fontMetrics().lineSpacing()/2);
@@ -281,7 +281,7 @@ EditAlarmDlg::EditAlarmDlg(bool Template, const TQString& caption, TQWidget* par
 
 	mDeferChangeButton = new TQPushButton(i18n("C&hange..."), mDeferGroup);
 	mDeferChangeButton->setFixedSize(mDeferChangeButton->sizeHint());
-	connect(mDeferChangeButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotEditDeferral()));
+	connect(mDeferChangeButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotEditDeferral()));
 	TQWhatsThis::add(mDeferChangeButton, i18n("Change the alarm's deferred time, or cancel the deferral"));
 	mDeferGroup->addSpace(0);
 
@@ -291,7 +291,7 @@ EditAlarmDlg::EditAlarmDlg(bool Template, const TQString& caption, TQWidget* par
 	if (mTemplate)
 	{
 		mTemplateTimeGroup = new ButtonGroup(i18n("Time"), mainPage, "templateGroup");
-		connect(mTemplateTimeGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotTemplateTimeType(int)));
+		connect(mTemplateTimeGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotTemplateTimeType(int)));
 		layout->addWidget(mTemplateTimeGroup);
 		grid = new TQGridLayout(mTemplateTimeGroup, 2, 2, marginHint(), spacingHint());
 		grid->addRowSpacing(0, fontMetrics().lineSpacing()/2);
@@ -355,7 +355,7 @@ EditAlarmDlg::EditAlarmDlg(bool Template, const TQString& caption, TQWidget* par
 	else
 	{
 		mTimeWidget = new AlarmTimeWidget(i18n("Time"), AlarmTimeWidget::AT_TIME, mainPage, "timeGroup");
-		connect(mTimeWidget, TQT_SIGNAL(anyTimeToggled(bool)), TQT_SLOT(slotAnyTimeToggled(bool)));
+		connect(mTimeWidget, TQ_SIGNAL(anyTimeToggled(bool)), TQ_SLOT(slotAnyTimeToggled(bool)));
 		topLayout->addWidget(mTimeWidget);
 	}
 
@@ -489,7 +489,7 @@ void EditAlarmDlg::initCommand(TQWidget* parent)
 
 	mCmdTypeScript = new CheckBox(i18n_p_EnterScript(), mCommandFrame);
 	mCmdTypeScript->setFixedSize(mCmdTypeScript->sizeHint());
-	connect(mCmdTypeScript, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotCmdScriptToggled(bool)));
+	connect(mCmdTypeScript, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotCmdScriptToggled(bool)));
 	TQWhatsThis::add(mCmdTypeScript, i18n("Check to enter the contents of a script instead of a shell command line"));
 	frameLayout->addWidget(mCmdTypeScript, 0, TQt::AlignAuto);
 
@@ -595,7 +595,7 @@ void EditAlarmDlg::initEmail(TQWidget* parent)
 	mEmailAddressButton = new TQPushButton(mEmailFrame);
 	mEmailAddressButton->setPixmap(SmallIcon("contents"));
 	mEmailAddressButton->setFixedSize(mEmailAddressButton->sizeHint());
-	connect(mEmailAddressButton, TQT_SIGNAL(clicked()), TQT_SLOT(openAddressBook()));
+	connect(mEmailAddressButton, TQ_SIGNAL(clicked()), TQ_SLOT(openAddressBook()));
 	TQToolTip::add(mEmailAddressButton, i18n("Open address book"));
 	TQWhatsThis::add(mEmailAddressButton, i18n("Select email addresses from your address book."));
 	grid->addWidget(mEmailAddressButton, 1, 2);
@@ -635,12 +635,12 @@ list->setGeometry(rect.left() - 50, rect.top(), rect.width(), rect.height());
 	grid->setColStretch(1, 1);
 
 	mEmailAddAttachButton = new TQPushButton(i18n("Add..."), mEmailFrame);
-	connect(mEmailAddAttachButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddAttachment()));
+	connect(mEmailAddAttachButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotAddAttachment()));
 	TQWhatsThis::add(mEmailAddAttachButton, i18n("Add an attachment to the email."));
 	grid->addWidget(mEmailAddAttachButton, 0, 2);
 
 	mEmailRemoveButton = new TQPushButton(i18n("Remo&ve"), mEmailFrame);
-	connect(mEmailRemoveButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveAttachment()));
+	connect(mEmailRemoveButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotRemoveAttachment()));
 	TQWhatsThis::add(mEmailRemoveButton, i18n("Remove the highlighted attachment from the email."));
 	grid->addWidget(mEmailRemoveButton, 1, 2);
 
diff --git a/kalarm/eventlistviewbase.cpp b/kalarm/eventlistviewbase.cpp
index 14a7afd62..2425a11b7 100644
--- a/kalarm/eventlistviewbase.cpp
+++ b/kalarm/eventlistviewbase.cpp
@@ -199,7 +199,7 @@ void EventListViewBase::slotFind()
 	if (!mFind)
 	{
 		mFind = new Find(this);
-		connect(mFind, TQT_SIGNAL(active(bool)), TQT_SIGNAL(findActive(bool)));
+		connect(mFind, TQ_SIGNAL(active(bool)), TQ_SIGNAL(findActive(bool)));
 	}
 	mFind->display();
 }
diff --git a/kalarm/find.cpp b/kalarm/find.cpp
index 8882b6b21..9e30388ed 100644
--- a/kalarm/find.cpp
+++ b/kalarm/find.cpp
@@ -146,7 +146,7 @@ void Find::display()
 		mEmailType->setChecked(mOptions & FIND_EMAIL);
 
 #ifndef MODAL_FIND
-		connect(mDialog, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotFind()));
+		connect(mDialog, TQ_SIGNAL(okClicked()), this, TQ_SLOT(slotFind()));
 #endif
 	}
 
@@ -245,7 +245,7 @@ void Find::slotFind()
 #else
 		mFind = new KFind(mLastPattern, options, mListView, mDialog);
 #endif
-		connect(mFind, TQT_SIGNAL(destroyed()), TQT_SLOT(slotKFindDestroyed()));
+		connect(mFind, TQ_SIGNAL(destroyed()), TQ_SLOT(slotKFindDestroyed()));
 		mFind->closeFindNextDialog();    // prevent 'Find Next' dialog appearing
 	}
 
diff --git a/kalarm/fontcolour.cpp b/kalarm/fontcolour.cpp
index 74feffb67..64a8cdce5 100644
--- a/kalarm/fontcolour.cpp
+++ b/kalarm/fontcolour.cpp
@@ -68,7 +68,7 @@ FontColourChooser::FontColourChooser(TQWidget *parent, const char *name,
 		TQLabel* label = new TQLabel(i18n("&Foreground color:"), box);
 		box->setStretchFactor(new TQWidget(box), 0);
 		mFgColourButton = new ColourCombo(box);
-		connect(mFgColourButton, TQT_SIGNAL(activated(const TQString&)), TQT_SLOT(setSampleColour()));
+		connect(mFgColourButton, TQ_SIGNAL(activated(const TQString&)), TQ_SLOT(setSampleColour()));
 		label->setBuddy(mFgColourButton);
 		TQWhatsThis::add(box, i18n("Select the alarm message foreground color"));
 	}
@@ -80,7 +80,7 @@ FontColourChooser::FontColourChooser(TQWidget *parent, const char *name,
 	TQLabel* label = new TQLabel(i18n("&Background color:"), box);
 	box->setStretchFactor(new TQWidget(box), 0);
 	mBgColourButton = new ColourCombo(box);
-	connect(mBgColourButton, TQT_SIGNAL(activated(const TQString&)), TQT_SLOT(setSampleColour()));
+	connect(mBgColourButton, TQ_SIGNAL(activated(const TQString&)), TQ_SLOT(setSampleColour()));
 	label->setBuddy(mBgColourButton);
 	TQWhatsThis::add(box, i18n("Select the alarm message background color"));
 	hlayout->addStretch();
@@ -90,13 +90,13 @@ FontColourChooser::FontColourChooser(TQWidget *parent, const char *name,
 		TQHBoxLayout* layout = new TQHBoxLayout(topLayout);
 		TQPushButton* button = new TQPushButton(i18n("Add Co&lor..."), page);
 		button->setFixedSize(button->sizeHint());
-		connect(button, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddColour()));
+		connect(button, TQ_SIGNAL(clicked()), TQ_SLOT(slotAddColour()));
 		TQWhatsThis::add(button, i18n("Choose a new color to add to the color selection list."));
 		layout->addWidget(button);
 
 		mRemoveColourButton = new TQPushButton(i18n("&Remove Color"), page);
 		mRemoveColourButton->setFixedSize(mRemoveColourButton->sizeHint());
-		connect(mRemoveColourButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveColour()));
+		connect(mRemoveColourButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotRemoveColour()));
 		TQWhatsThis::add(mRemoveColourButton,
 		      i18n("Remove the color currently shown in the background color chooser, from the color selection list."));
 		layout->addWidget(mRemoveColourButton);
@@ -107,7 +107,7 @@ FontColourChooser::FontColourChooser(TQWidget *parent, const char *name,
 		TQHBoxLayout* layout = new TQHBoxLayout(topLayout);
 		mDefaultFont = new CheckBox(i18n("Use &default font"), page);
 		mDefaultFont->setMinimumSize(mDefaultFont->sizeHint());
-		connect(mDefaultFont, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotDefaultFontToggled(bool)));
+		connect(mDefaultFont, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotDefaultFontToggled(bool)));
 		TQWhatsThis::add(mDefaultFont,
 		      i18n("Check to use the default font current at the time the alarm is displayed."));
 		layout->addWidget(mDefaultFont);
diff --git a/kalarm/fontcolourbutton.cpp b/kalarm/fontcolourbutton.cpp
index 5321cdc93..a291a3769 100644
--- a/kalarm/fontcolourbutton.cpp
+++ b/kalarm/fontcolourbutton.cpp
@@ -47,7 +47,7 @@ FontColourButton::FontColourButton(TQWidget* parent, const char* name)
 
 	mButton = new PushButton(i18n("Font && Co&lor..."), this);
 	mButton->setFixedSize(mButton->sizeHint());
-	connect(mButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotButtonPressed()));
+	connect(mButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotButtonPressed()));
 	TQWhatsThis::add(mButton,
 	      i18n("Choose the font, and foreground and background color, for the alarm message."));
 	layout->addWidget(mButton);
diff --git a/kalarm/kalarmapp.cpp b/kalarm/kalarmapp.cpp
index 16186355d..d9adbf7ce 100644
--- a/kalarm/kalarmapp.cpp
+++ b/kalarm/kalarmapp.cpp
@@ -109,7 +109,7 @@ KAlarmApp::KAlarmApp()
 	  mSpeechEnabled(false)
 {
 	Preferences::initialise();
-	Preferences::connect(TQT_SIGNAL(preferencesChanged()), this, TQT_SLOT(slotPreferencesChanged()));
+	Preferences::connect(TQ_SIGNAL(preferencesChanged()), this, TQ_SLOT(slotPreferencesChanged()));
 	KCal::CalFormat::setApplication(aboutData()->programName(), AlarmCalendar::icalProductId());
 	KARecurrence::setDefaultFeb29Type(Preferences::defaultFeb29Type());
 
@@ -118,7 +118,7 @@ KAlarmApp::KAlarmApp()
 
 	if (AlarmCalendar::initialiseCalendars())
 	{
-		connect(AlarmCalendar::expiredCalendar(), TQT_SIGNAL(purged()), TQT_SLOT(slotExpiredPurged()));
+		connect(AlarmCalendar::expiredCalendar(), TQ_SIGNAL(purged()), TQ_SLOT(slotExpiredPurged()));
 
 		TDEConfig* config = kapp->config();
 		config->setGroup(TQString::fromLatin1("General"));
@@ -849,7 +849,7 @@ void KAlarmApp::displayFatalError(const TQString& message)
 		mFatalError = 1;
 		mFatalMessage = message;
 		if (theInstance)
-			TQTimer::singleShot(0, theInstance, TQT_SLOT(quitFatal()));
+			TQTimer::singleShot(0, theInstance, TQ_SLOT(quitFatal()));
 	}
 }
 
@@ -873,7 +873,7 @@ void KAlarmApp::quitFatal()
 				theInstance->quitIf(1, true);
 			break;
 	}
-	TQTimer::singleShot(1000, this, TQT_SLOT(quitFatal()));
+	TQTimer::singleShot(1000, this, TQ_SLOT(quitFatal()));
 }
 
 /******************************************************************************
@@ -989,7 +989,7 @@ bool KAlarmApp::displayTrayIcon(bool show, MainWindow* parent)
 				creating = false;
 			}
 			mTrayWindow = new TrayWindow(parent ? parent : MainWindow::firstWindow());
-			connect(mTrayWindow, TQT_SIGNAL(deleted()), TQT_SIGNAL(trayIconToggled()));
+			connect(mTrayWindow, TQ_SIGNAL(deleted()), TQ_SIGNAL(trayIconToggled()));
 			mTrayWindow->show();
 			emit trayIconToggled();
 
@@ -998,7 +998,7 @@ bool KAlarmApp::displayTrayIcon(bool show, MainWindow* parent)
 			mCheckingSystemTray = true;
 			mSavedNoSystemTray  = mNoSystemTray;
 			mNoSystemTray       = false;
-			TQTimer::singleShot(0, this, TQT_SLOT(slotSystemTrayTimer()));
+			TQTimer::singleShot(0, this, TQ_SLOT(slotSystemTrayTimer()));
 		}
 	}
 	else if (mTrayWindow)
@@ -1212,7 +1212,7 @@ bool KAlarmApp::scheduleEvent(KAEvent::Action action, const TQString& text, cons
 	// Queue the alarm for insertion into the calendar file
 	mDcopQueue.append(DcopTQEntry(event));
 	if (mInitialised)
-		TQTimer::singleShot(0, this, TQT_SLOT(processQueue()));
+		TQTimer::singleShot(0, this, TQ_SLOT(processQueue()));
 	return true;
 }
 
@@ -1234,7 +1234,7 @@ bool KAlarmApp::handleEvent(const TQString& urlString, const TQString& eventID,
 	}
 	mDcopQueue.append(DcopTQEntry(function, eventID));
 	if (mInitialised)
-		TQTimer::singleShot(0, this, TQT_SLOT(processQueue()));
+		TQTimer::singleShot(0, this, TQ_SLOT(processQueue()));
 	return true;
 }
 
@@ -1751,16 +1751,16 @@ ShellProcess* KAlarmApp::doShellCommand(const TQString& command, const KAEvent&
 		comms = TDEProcess::AllOutput;
 	}
 	ShellProcess* proc = new ShellProcess(cmd);
-	connect(proc, TQT_SIGNAL(shellExited(ShellProcess*)), TQT_SLOT(slotCommandExited(ShellProcess*)));
+	connect(proc, TQ_SIGNAL(shellExited(ShellProcess*)), TQ_SLOT(slotCommandExited(ShellProcess*)));
 	TQGuardedPtr<ShellProcess> logproc = 0;
 	if (comms == TDEProcess::AllOutput  &&  !event.logFile().isEmpty())
 	{
 		// Output is to be appended to a log file.
 		// Set up a logging process to write the command's output to.
-		connect(proc, TQT_SIGNAL(receivedStdout(TDEProcess*,char*,int)), TQT_SLOT(slotCommandOutput(TDEProcess*,char*,int)));
-		connect(proc, TQT_SIGNAL(receivedStderr(TDEProcess*,char*,int)), TQT_SLOT(slotCommandOutput(TDEProcess*,char*,int)));
+		connect(proc, TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)), TQ_SLOT(slotCommandOutput(TDEProcess*,char*,int)));
+		connect(proc, TQ_SIGNAL(receivedStderr(TDEProcess*,char*,int)), TQ_SLOT(slotCommandOutput(TDEProcess*,char*,int)));
 		logproc = new ShellProcess(TQString::fromLatin1("cat >>%1").arg(event.logFile()));
-		connect(logproc, TQT_SIGNAL(shellExited(ShellProcess*)), TQT_SLOT(slotLogProcExited(ShellProcess*)));
+		connect(logproc, TQ_SIGNAL(shellExited(ShellProcess*)), TQ_SLOT(slotLogProcExited(ShellProcess*)));
 		logproc->start(TDEProcess::Stdin);
 		TQCString heading;
 		if (alarm  &&  alarm->dateTime().isValid())
@@ -1940,7 +1940,7 @@ void KAlarmApp::setUpDcop()
 	{
 		mInitialised = true;      // we're now ready to handle DCOP calls
 		Daemon::createDcopHandler();
-		TQTimer::singleShot(0, this, TQT_SLOT(processQueue()));    // process anything already queued
+		TQTimer::singleShot(0, this, TQ_SLOT(processQueue()));    // process anything already queued
 	}
 }
 
diff --git a/kalarm/kalarmd/adcalendar.cpp b/kalarm/kalarmd/adcalendar.cpp
index b1033eb04..699e9684e 100644
--- a/kalarm/kalarmd/adcalendar.cpp
+++ b/kalarm/kalarmd/adcalendar.cpp
@@ -96,7 +96,7 @@ bool ADCalendar::loadFile(bool reset)
 		KURL dest;
 		dest.setPath(mTempFileName);
 		TDEIO::FileCopyJob* job = TDEIO::file_copy(url, dest, -1, true);
-		connect(job, TQT_SIGNAL(result(TDEIO::Job*)), TQT_SLOT(slotDownloadJobResult(TDEIO::Job*)));
+		connect(job, TQ_SIGNAL(result(TDEIO::Job*)), TQ_SLOT(slotDownloadJobResult(TDEIO::Job*)));
 	}
 	return true;
 }
diff --git a/kalarm/kalarmd/alarmdaemon.cpp b/kalarm/kalarmd/alarmdaemon.cpp
index 573cac0d9..71c39f1e7 100644
--- a/kalarm/kalarmd/alarmdaemon.cpp
+++ b/kalarm/kalarmd/alarmdaemon.cpp
@@ -119,7 +119,7 @@ AlarmDaemon::AlarmDaemon(bool autostart, TQObject *parent, const char *name)
 					}
 				}
 			// Give some extra time to KAlarm to be fully restored, then proceed as usual
-			TQTimer::singleShot(3000, this, TQT_SLOT(autostartKAlarm()));
+			TQTimer::singleShot(3000, this, TQ_SLOT(autostartKAlarm()));
 			}
 		}
 	}
@@ -168,7 +168,7 @@ void AlarmDaemon::startMonitoring()
 {
 	// Set up the alarm timer
 	mAlarmTimer = new TQTimer(this);
-	connect(mAlarmTimer, TQT_SIGNAL(timeout()), TQT_SLOT(checkAlarmsSlot()));
+	connect(mAlarmTimer, TQ_SIGNAL(timeout()), TQ_SLOT(checkAlarmsSlot()));
 	setTimerStatus();
 
 	// Start monitoring calendar files.
@@ -216,7 +216,7 @@ void AlarmDaemon::reloadCal(ADCalendar* cal, bool reset)
 	{
 		cal->close();
 		if (!cal->setLoadedConnected())
-			connect(cal, TQT_SIGNAL(loaded(ADCalendar*, bool)), TQT_SLOT(calendarLoaded(ADCalendar*, bool)));
+			connect(cal, TQ_SIGNAL(loaded(ADCalendar*, bool)), TQ_SLOT(calendarLoaded(ADCalendar*, bool)));
 		cal->loadFile(reset);
 	}
 	else if (reset)
diff --git a/kalarm/latecancel.cpp b/kalarm/latecancel.cpp
index ff684a774..6f6564109 100644
--- a/kalarm/latecancel.cpp
+++ b/kalarm/latecancel.cpp
@@ -61,7 +61,7 @@ LateCancelSelector::LateCancelSelector(bool allowHourMinute, TQWidget* parent, c
 	TQBoxLayout* layout = new TQVBoxLayout(mCheckboxFrame, 0, 0);
 	mCheckbox = new CheckBox(i18n_n_CancelIfLate(), mCheckboxFrame);
 	mCheckbox->setFixedSize(mCheckbox->sizeHint());
-	connect(mCheckbox, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotToggled(bool)));
+	connect(mCheckbox, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotToggled(bool)));
 	TQWhatsThis::add(mCheckbox, whatsThis);
 	layout->addWidget(mCheckbox, 0, TQt::AlignAuto);
 
@@ -72,7 +72,7 @@ LateCancelSelector::LateCancelSelector(bool allowHourMinute, TQWidget* parent, c
 	mTimeSelector = new TimeSelector(i18n("Cancel if late by 10 minutes", "Ca&ncel if late by"), TQString(),
 	                                 whatsThis, i18n("Enter how late will cause the alarm to be canceled"),
 	                                 allowHourMinute, mTimeSelectorFrame);
-	connect(mTimeSelector, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotToggled(bool)));
+	connect(mTimeSelector, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotToggled(bool)));
 	layout->addWidget(mTimeSelector);
 	mLayout->addWidget(mStack);
 
diff --git a/kalarm/lib/buttongroup.cpp b/kalarm/lib/buttongroup.cpp
index e3d47e413..d1ba243f8 100644
--- a/kalarm/lib/buttongroup.cpp
+++ b/kalarm/lib/buttongroup.cpp
@@ -29,25 +29,25 @@
 ButtonGroup::ButtonGroup(TQWidget* parent, const char* name)
 	: TQButtonGroup(parent, name)
 {
-	connect(this, TQT_SIGNAL(clicked(int)), TQT_SIGNAL(buttonSet(int)));
+	connect(this, TQ_SIGNAL(clicked(int)), TQ_SIGNAL(buttonSet(int)));
 }
 
 ButtonGroup::ButtonGroup(const TQString& title, TQWidget* parent, const char* name)
 	: TQButtonGroup(title, parent, name)
 {
-	connect(this, TQT_SIGNAL(clicked(int)), TQT_SIGNAL(buttonSet(int)));
+	connect(this, TQ_SIGNAL(clicked(int)), TQ_SIGNAL(buttonSet(int)));
 }
 
 ButtonGroup::ButtonGroup(int strips, TQt::Orientation orient, TQWidget* parent, const char* name)
 	: TQButtonGroup(strips, orient, parent, name)
 {
-	connect(this, TQT_SIGNAL(clicked(int)), TQT_SIGNAL(buttonSet(int)));
+	connect(this, TQ_SIGNAL(clicked(int)), TQ_SIGNAL(buttonSet(int)));
 }
 
 ButtonGroup::ButtonGroup(int strips, TQt::Orientation orient, const TQString& title, TQWidget* parent, const char* name)
 	: TQButtonGroup(strips, orient, title, parent, name)
 {
-	connect(this, TQT_SIGNAL(clicked(int)), TQT_SIGNAL(buttonSet(int)));
+	connect(this, TQ_SIGNAL(clicked(int)), TQ_SIGNAL(buttonSet(int)));
 }
 
 /******************************************************************************
@@ -57,7 +57,7 @@ ButtonGroup::ButtonGroup(int strips, TQt::Orientation orient, const TQString& ti
 int ButtonGroup::insert(TQButton* button, int id)
 {
 	id = TQButtonGroup::insert(button, id);
-	connect(button, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotButtonToggled(bool)));
+	connect(button, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotButtonToggled(bool)));
 	return id;
 }
 
diff --git a/kalarm/lib/checkbox.cpp b/kalarm/lib/checkbox.cpp
index a1f594bc4..4b29d927a 100644
--- a/kalarm/lib/checkbox.cpp
+++ b/kalarm/lib/checkbox.cpp
@@ -58,9 +58,9 @@ void CheckBox::setFocusWidget(TQWidget* w, bool enable)
 	mFocusWidget = w;
 	mFocusWidgetEnable = enable;
 	if (w)
-		connect(this, TQT_SIGNAL(clicked()), TQT_SLOT(slotClicked()));
+		connect(this, TQ_SIGNAL(clicked()), TQ_SLOT(slotClicked()));
 	else
-		disconnect(this, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClicked()));
+		disconnect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClicked()));
 }
 
 /******************************************************************************
diff --git a/kalarm/lib/colourcombo.cpp b/kalarm/lib/colourcombo.cpp
index e52501eec..d612180ae 100644
--- a/kalarm/lib/colourcombo.cpp
+++ b/kalarm/lib/colourcombo.cpp
@@ -39,9 +39,9 @@ ColourCombo::ColourCombo(TQWidget* parent, const char* name, const TQColor& defa
 	  mDisabled(false)
 {
 	addColours();
-	connect(this, TQT_SIGNAL(activated(int)), TQT_SLOT(slotActivated(int)));
-	connect(this, TQT_SIGNAL(highlighted(int)), TQT_SLOT(slotHighlighted(int)));
-	Preferences::connect(TQT_SIGNAL(preferencesChanged()), this, TQT_SLOT(slotPreferencesChanged()));
+	connect(this, TQ_SIGNAL(activated(int)), TQ_SLOT(slotActivated(int)));
+	connect(this, TQ_SIGNAL(highlighted(int)), TQ_SLOT(slotHighlighted(int)));
+	Preferences::connect(TQ_SIGNAL(preferencesChanged()), this, TQ_SLOT(slotPreferencesChanged()));
 }
 
 void ColourCombo::setColour(const TQColor& colour)
diff --git a/kalarm/lib/dateedit.cpp b/kalarm/lib/dateedit.cpp
index 051e3a640..862e859f8 100644
--- a/kalarm/lib/dateedit.cpp
+++ b/kalarm/lib/dateedit.cpp
@@ -28,7 +28,7 @@
 DateEdit::DateEdit(TQWidget* parent, const char* name)
 	: KDateEdit(parent, name)
 {
-	connect(this, TQT_SIGNAL(dateEntered(const TQDate&)), TQT_SLOT(newDateEntered(const TQDate&)));
+	connect(this, TQ_SIGNAL(dateEntered(const TQDate&)), TQ_SLOT(newDateEntered(const TQDate&)));
 }
 
 void DateEdit::setMinDate(const TQDate& d, const TQString& errorDate)
diff --git a/kalarm/lib/label.cpp b/kalarm/lib/label.cpp
index 49c176955..8a41d624b 100644
--- a/kalarm/lib/label.cpp
+++ b/kalarm/lib/label.cpp
@@ -50,7 +50,7 @@ Label::Label(TQWidget* buddy, const TQString& text, TQWidget* parent, const char
 void Label::setBuddy(TQWidget* bud)
 {
 	if (mRadioButton)
-		disconnect(mRadioButton, TQT_SIGNAL(destroyed()), this, TQT_SLOT(buddyDead()));
+		disconnect(mRadioButton, TQ_SIGNAL(destroyed()), this, TQ_SLOT(buddyDead()));
 	TQWidget* w = bud;
 	if (w)
 	{
@@ -74,7 +74,7 @@ void Label::setBuddy(TQWidget* bud)
 			mFocusWidget = new LabelFocusWidget(this);
 		TQLabel::setBuddy(mFocusWidget);
 		mRadioButton = (TQRadioButton*)bud;
-		connect(mRadioButton, TQT_SIGNAL(destroyed()), this, TQT_SLOT(buddyDead()));
+		connect(mRadioButton, TQ_SIGNAL(destroyed()), this, TQ_SLOT(buddyDead()));
 	}
 }
 
diff --git a/kalarm/lib/radiobutton.cpp b/kalarm/lib/radiobutton.cpp
index e9f604306..62fb9b630 100644
--- a/kalarm/lib/radiobutton.cpp
+++ b/kalarm/lib/radiobutton.cpp
@@ -58,9 +58,9 @@ void RadioButton::setFocusWidget(TQWidget* w, bool enable)
 	mFocusWidget = w;
 	mFocusWidgetEnable = enable;
 	if (w)
-		connect(this, TQT_SIGNAL(clicked()), TQT_SLOT(slotClicked()));
+		connect(this, TQ_SIGNAL(clicked()), TQ_SLOT(slotClicked()));
 	else
-		disconnect(this, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotClicked()));
+		disconnect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotClicked()));
 }
 
 /******************************************************************************
diff --git a/kalarm/lib/shellprocess.cpp b/kalarm/lib/shellprocess.cpp
index 1ed64df72..0fe0159bd 100644
--- a/kalarm/lib/shellprocess.cpp
+++ b/kalarm/lib/shellprocess.cpp
@@ -56,8 +56,8 @@ bool ShellProcess::start(Communication comm)
 		return false;
 	}
 	KShellProcess::operator<<(mCommand);
-	connect(this, TQT_SIGNAL(wroteStdin(TDEProcess*)), TQT_SLOT(writtenStdin(TDEProcess*)));
-	connect(this, TQT_SIGNAL(processExited(TDEProcess*)), TQT_SLOT(slotExited(TDEProcess*)));
+	connect(this, TQ_SIGNAL(wroteStdin(TDEProcess*)), TQ_SLOT(writtenStdin(TDEProcess*)));
+	connect(this, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(slotExited(TDEProcess*)));
 	if (!KShellProcess::start(TDEProcess::NotifyOnExit, comm))
 	{
 		mStatus = START_FAIL;
diff --git a/kalarm/lib/spinbox.cpp b/kalarm/lib/spinbox.cpp
index 80adc6d88..667d5c7c7 100644
--- a/kalarm/lib/spinbox.cpp
+++ b/kalarm/lib/spinbox.cpp
@@ -65,7 +65,7 @@ void SpinBox::init()
 
 #if KDE_IS_VERSION(3,1,90)
 	// Detect when the text field is edited
-	connect(editor(), TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(textEdited()));
+	connect(editor(), TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(textEdited()));
 #endif
 }
 
diff --git a/kalarm/lib/spinbox2.cpp b/kalarm/lib/spinbox2.cpp
index 43570dbad..328813e22 100644
--- a/kalarm/lib/spinbox2.cpp
+++ b/kalarm/lib/spinbox2.cpp
@@ -89,11 +89,11 @@ void SpinBox2::init()
 	mSpinMirror = new SpinMirror(mUpdown2, mUpdown2Frame, this);
 	if (!mirrorStyle(style()))
 		mSpinMirror->hide();    // hide mirrored spin buttons when they are inappropriate
-	connect(mSpinbox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(valueChange()));
-	connect(mSpinbox, TQT_SIGNAL(valueChanged(int)), TQT_SIGNAL(valueChanged(int)));
-	connect(mSpinbox, TQT_SIGNAL(valueChanged(const TQString&)), TQT_SIGNAL(valueChanged(const TQString&)));
-	connect(mUpdown2, TQT_SIGNAL(stepped(int)), TQT_SLOT(stepPage(int)));
-	connect(mUpdown2, TQT_SIGNAL(styleUpdated()), TQT_SLOT(updateMirror()));
+	connect(mSpinbox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(valueChange()));
+	connect(mSpinbox, TQ_SIGNAL(valueChanged(int)), TQ_SIGNAL(valueChanged(int)));
+	connect(mSpinbox, TQ_SIGNAL(valueChanged(const TQString&)), TQ_SIGNAL(valueChanged(const TQString&)));
+	connect(mUpdown2, TQ_SIGNAL(stepped(int)), TQ_SLOT(stepPage(int)));
+	connect(mUpdown2, TQ_SIGNAL(styleUpdated()), TQ_SLOT(updateMirror()));
 }
 
 void SpinBox2::setReadOnly(bool ro)
@@ -451,7 +451,7 @@ void SpinMirror::contentsMouseEvent(TQMouseEvent* e)
 	{
 		case TQEvent::MouseButtonPress:
 		case TQEvent::MouseButtonRelease:
-			TQTimer::singleShot(0, this, TQT_SLOT(redraw()));
+			TQTimer::singleShot(0, this, TQ_SLOT(redraw()));
 			break;
 		default:
 			break;
@@ -481,11 +481,11 @@ bool SpinMirror::event(TQEvent* e)
 		case TQEvent::Leave:
 		case TQEvent::Enter:
 			TQApplication::postEvent(mSpinWidget, new TQEvent(e->type()));
-			TQTimer::singleShot(0, this, TQT_SLOT(redraw()));
+			TQTimer::singleShot(0, this, TQ_SLOT(redraw()));
 			break;
 		case TQEvent::FocusIn:
 			mSpinbox->setFocus();
-			TQTimer::singleShot(0, this, TQT_SLOT(redraw()));
+			TQTimer::singleShot(0, this, TQ_SLOT(redraw()));
 			break;
 		default:
 			break;
diff --git a/kalarm/lib/synchtimer.cpp b/kalarm/lib/synchtimer.cpp
index eecef7d4b..e32cf659c 100644
--- a/kalarm/lib/synchtimer.cpp
+++ b/kalarm/lib/synchtimer.cpp
@@ -48,11 +48,11 @@ void SynchTimer::connecT(TQObject* receiver, const char* member)
 	Connection connection(receiver, member);
 	if (mConnections.find(connection) != mConnections.end())
 		return;           // the slot is already connected, so ignore request
-	connect(mTimer, TQT_SIGNAL(timeout()), receiver, member);
+	connect(mTimer, TQ_SIGNAL(timeout()), receiver, member);
 	mConnections.append(connection);
 	if (!mTimer->isActive())
 	{
-		connect(mTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotTimer()));
+		connect(mTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotTimer()));
 		start();
 	}
 }
diff --git a/kalarm/lib/timeedit.cpp b/kalarm/lib/timeedit.cpp
index 80713f2fe..21215a6c5 100644
--- a/kalarm/lib/timeedit.cpp
+++ b/kalarm/lib/timeedit.cpp
@@ -38,13 +38,13 @@ TimeEdit::TimeEdit(TQWidget* parent, const char* name)
 	bool use12hour = TDEGlobal::locale()->use12Clock();
 	mSpinBox = new TimeSpinBox(!use12hour, this);
 	mSpinBox->setFixedSize(mSpinBox->sizeHint());
-	connect(mSpinBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotValueChanged(int)));
+	connect(mSpinBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotValueChanged(int)));
 	if (use12hour)
 	{
 		mAmPm = new ComboBox(this);
 		setAmPmCombo(1, 1);     // add "am" and "pm" options to the combo box
 		mAmPm->setFixedSize(mAmPm->sizeHint());
-		connect(mAmPm, TQT_SIGNAL(highlighted(int)), TQT_SLOT(slotAmPmChanged(int)));
+		connect(mAmPm, TQ_SIGNAL(highlighted(int)), TQ_SLOT(slotAmPmChanged(int)));
 	}
 }
 
diff --git a/kalarm/lib/timeperiod.cpp b/kalarm/lib/timeperiod.cpp
index 37c787029..b2290a77d 100644
--- a/kalarm/lib/timeperiod.cpp
+++ b/kalarm/lib/timeperiod.cpp
@@ -63,12 +63,12 @@ TimePeriod::TimePeriod(bool allowHourMinute, TQWidget* parent, const char* name)
 	mSpinBox->setLineStep(1);
 	mSpinBox->setLineShiftStep(10);
 	mSpinBox->setRange(1, mMaxDays);
-	connect(mSpinBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotDaysChanged(int)));
+	connect(mSpinBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotDaysChanged(int)));
 	mSpinStack->addWidget(mSpinBox, 0);
 
 	mTimeSpinBox = new TimeSpinBox(0, 99999, mSpinStack);
 	mTimeSpinBox->setRange(1, maxMinutes);    // max 999H59M
-	connect(mTimeSpinBox, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotTimeChanged(int)));
+	connect(mTimeSpinBox, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotTimeChanged(int)));
 	mSpinStack->addWidget(mTimeSpinBox, 1);
 
 	mSpinStack->setFixedSize(mSpinBox->sizeHint().expandedTo(mTimeSpinBox->sizeHint()));
@@ -88,7 +88,7 @@ TimePeriod::TimePeriod(bool allowHourMinute, TQWidget* parent, const char* name)
 	mUnitsCombo->insertItem(i18n_weeks());
 	mMaxUnitShown = WEEKS;
 	mUnitsCombo->setFixedSize(mUnitsCombo->sizeHint());
-	connect(mUnitsCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotUnitsSelected(int)));
+	connect(mUnitsCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotUnitsSelected(int)));
 
 	setFocusProxy(mUnitsCombo);
 	setTabOrder(mUnitsCombo, mSpinStack);
diff --git a/kalarm/lib/timespinbox.cpp b/kalarm/lib/timespinbox.cpp
index 4bc161fda..db3d54002 100644
--- a/kalarm/lib/timespinbox.cpp
+++ b/kalarm/lib/timespinbox.cpp
@@ -70,7 +70,7 @@ TimeSpinBox::TimeSpinBox(bool use24hour, TQWidget* parent, const char* name)
 	setShiftSteps(5, 360);    // shift-left button increments 5 min / 6 hours
 	setSelectOnStep(false);
 	setAlignment(TQt::AlignHCenter);
-	connect(this, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(slotValueChanged(int)));
+	connect(this, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(slotValueChanged(int)));
 }
 
 /******************************************************************************
diff --git a/kalarm/mainwindow.cpp b/kalarm/mainwindow.cpp
index 0a7a25984..66a93a9ca 100644
--- a/kalarm/mainwindow.cpp
+++ b/kalarm/mainwindow.cpp
@@ -149,14 +149,14 @@ MainWindow::MainWindow(bool restored)
 	mListView->refresh();          // populate the alarm list
 	mListView->clearSelection();
 
-	connect(mListView, TQT_SIGNAL(itemDeleted()), TQT_SLOT(slotDeletion()));
-	connect(mListView, TQT_SIGNAL(selectionChanged()), TQT_SLOT(slotSelection()));
-	connect(mListView, TQT_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
-	        TQT_SLOT(slotContextMenuRequested(TQListViewItem*, const TQPoint&, int)));
-	connect(mListView, TQT_SIGNAL(mouseButtonClicked(int, TQListViewItem*, const TQPoint&, int)),
-	        TQT_SLOT(slotMouseClicked(int, TQListViewItem*, const TQPoint&, int)));
-	connect(mListView, TQT_SIGNAL(executed(TQListViewItem*)), TQT_SLOT(slotDoubleClicked(TQListViewItem*)));
-	connect(mListView->header(), TQT_SIGNAL(indexChange(int, int, int)), TQT_SLOT(columnsReordered()));
+	connect(mListView, TQ_SIGNAL(itemDeleted()), TQ_SLOT(slotDeletion()));
+	connect(mListView, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelection()));
+	connect(mListView, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
+	        TQ_SLOT(slotContextMenuRequested(TQListViewItem*, const TQPoint&, int)));
+	connect(mListView, TQ_SIGNAL(mouseButtonClicked(int, TQListViewItem*, const TQPoint&, int)),
+	        TQ_SLOT(slotMouseClicked(int, TQListViewItem*, const TQPoint&, int)));
+	connect(mListView, TQ_SIGNAL(executed(TQListViewItem*)), TQ_SLOT(slotDoubleClicked(TQListViewItem*)));
+	connect(mListView->header(), TQ_SIGNAL(indexChange(int, int, int)), TQ_SLOT(columnsReordered()));
 	initActions();
 
 	mWindowList.append(this);
@@ -326,27 +326,27 @@ void MainWindow::columnsReordered()
 void MainWindow::initActions()
 {
 	TDEActionCollection* actions = actionCollection();
-	mActionTemplates       = new TDEAction(i18n("&Templates..."), 0, this, TQT_SLOT(slotTemplates()), actions, "templates");
-	mActionNew             = KAlarm::createNewAlarmAction(i18n("&New..."), this, TQT_SLOT(slotNew()), actions, "new");
-	mActionNewFromTemplate = KAlarm::createNewFromTemplateAction(i18n("New &From Template"), this, TQT_SLOT(slotNewFromTemplate(const KAEvent&)), actions, "newFromTempl");
-	mActionCreateTemplate  = new TDEAction(i18n("Create Tem&plate..."), 0, this, TQT_SLOT(slotNewTemplate()), actions, "createTemplate");
-	mActionCopy            = new TDEAction(i18n("&Copy..."), "edit-copy", TQt::SHIFT+TQt::Key_Insert, this, TQT_SLOT(slotCopy()), actions, "copy");
-	mActionModify          = new TDEAction(i18n("&Edit..."), "edit", TQt::CTRL+TQt::Key_E, this, TQT_SLOT(slotModify()), actions, "modify");
-	mActionDelete          = new TDEAction(i18n("&Delete"), "edit-delete", TQt::Key_Delete, this, TQT_SLOT(slotDelete()), actions, "delete");
-	mActionReactivate      = new TDEAction(i18n("Reac&tivate"), 0, TQt::CTRL+TQt::Key_R, this, TQT_SLOT(slotReactivate()), actions, "undelete");
-	mActionEnable          = new TDEAction(TQString(), 0, TQt::CTRL+TQt::Key_B, this, TQT_SLOT(slotEnable()), actions, "disable");
-	mActionView            = new TDEAction(i18n("&View"), "viewmag", TQt::CTRL+TQt::Key_W, this, TQT_SLOT(slotView()), actions, "view");
-	mActionShowTime        = new TDEToggleAction(i18n_a_ShowAlarmTimes(), TQt::CTRL+TQt::Key_M, this, TQT_SLOT(slotShowTime()), actions, "showAlarmTimes");
+	mActionTemplates       = new TDEAction(i18n("&Templates..."), 0, this, TQ_SLOT(slotTemplates()), actions, "templates");
+	mActionNew             = KAlarm::createNewAlarmAction(i18n("&New..."), this, TQ_SLOT(slotNew()), actions, "new");
+	mActionNewFromTemplate = KAlarm::createNewFromTemplateAction(i18n("New &From Template"), this, TQ_SLOT(slotNewFromTemplate(const KAEvent&)), actions, "newFromTempl");
+	mActionCreateTemplate  = new TDEAction(i18n("Create Tem&plate..."), 0, this, TQ_SLOT(slotNewTemplate()), actions, "createTemplate");
+	mActionCopy            = new TDEAction(i18n("&Copy..."), "edit-copy", TQt::SHIFT+TQt::Key_Insert, this, TQ_SLOT(slotCopy()), actions, "copy");
+	mActionModify          = new TDEAction(i18n("&Edit..."), "edit", TQt::CTRL+TQt::Key_E, this, TQ_SLOT(slotModify()), actions, "modify");
+	mActionDelete          = new TDEAction(i18n("&Delete"), "edit-delete", TQt::Key_Delete, this, TQ_SLOT(slotDelete()), actions, "delete");
+	mActionReactivate      = new TDEAction(i18n("Reac&tivate"), 0, TQt::CTRL+TQt::Key_R, this, TQ_SLOT(slotReactivate()), actions, "undelete");
+	mActionEnable          = new TDEAction(TQString(), 0, TQt::CTRL+TQt::Key_B, this, TQ_SLOT(slotEnable()), actions, "disable");
+	mActionView            = new TDEAction(i18n("&View"), "viewmag", TQt::CTRL+TQt::Key_W, this, TQ_SLOT(slotView()), actions, "view");
+	mActionShowTime        = new TDEToggleAction(i18n_a_ShowAlarmTimes(), TQt::CTRL+TQt::Key_M, this, TQ_SLOT(slotShowTime()), actions, "showAlarmTimes");
 	mActionShowTime->setCheckedState(i18n("Hide &Alarm Times"));
-	mActionShowTimeTo      = new TDEToggleAction(i18n_o_ShowTimeToAlarms(), TQt::CTRL+TQt::Key_I, this, TQT_SLOT(slotShowTimeTo()), actions, "showTimeToAlarms");
+	mActionShowTimeTo      = new TDEToggleAction(i18n_o_ShowTimeToAlarms(), TQt::CTRL+TQt::Key_I, this, TQ_SLOT(slotShowTimeTo()), actions, "showTimeToAlarms");
 	mActionShowTimeTo->setCheckedState(i18n("Hide Time t&o Alarms"));
-	mActionShowExpired     = new TDEToggleAction(i18n_e_ShowExpiredAlarms(), "history", TQt::CTRL+TQt::Key_P, this, TQT_SLOT(slotShowExpired()), actions, "showExpiredAlarms");
+	mActionShowExpired     = new TDEToggleAction(i18n_e_ShowExpiredAlarms(), "history", TQt::CTRL+TQt::Key_P, this, TQ_SLOT(slotShowExpired()), actions, "showExpiredAlarms");
 	mActionShowExpired->setCheckedState(i18n_e_HideExpiredAlarms());
-	mActionToggleTrayIcon  = new TDEToggleAction(i18n("Show in System &Tray"), 0, this, TQT_SLOT(slotToggleTrayIcon()), actions, "showInSystemTray");
+	mActionToggleTrayIcon  = new TDEToggleAction(i18n("Show in System &Tray"), 0, this, TQ_SLOT(slotToggleTrayIcon()), actions, "showInSystemTray");
 	mActionToggleTrayIcon->setCheckedState(i18n("Hide From System &Tray"));
-	new TDEAction(i18n("Import &Alarms..."), 0, this, TQT_SLOT(slotImportAlarms()), actions, "importAlarms");
-	new TDEAction(i18n("Import &Birthdays..."), 0, this, TQT_SLOT(slotBirthdays()), actions, "importBirthdays");
-	new TDEAction(i18n("&Refresh Alarms"), "reload", 0, this, TQT_SLOT(slotResetDaemon()), actions, "refreshAlarms");
+	new TDEAction(i18n("Import &Alarms..."), 0, this, TQ_SLOT(slotImportAlarms()), actions, "importAlarms");
+	new TDEAction(i18n("Import &Birthdays..."), 0, this, TQ_SLOT(slotBirthdays()), actions, "importBirthdays");
+	new TDEAction(i18n("&Refresh Alarms"), "reload", 0, this, TQ_SLOT(slotResetDaemon()), actions, "refreshAlarms");
 	Daemon::createAlarmEnableAction(actions, "alarmEnable");
 	if (undoText.isNull())
 	{
@@ -364,32 +364,32 @@ void MainWindow::initActions()
 		redoTextStripped = KAlarm::stripAccel(redoText);
 		delete act;
 	}
-	mActionUndo = new TDEToolBarPopupAction(undoText, undoIcon, undoShortcut, this, TQT_SLOT(slotUndo()), actions, "edit_undo");
-	mActionRedo = new TDEToolBarPopupAction(redoText, redoIcon, redoShortcut, this, TQT_SLOT(slotRedo()), actions, "edit_redo");
-	KStdAction::find(mListView, TQT_SLOT(slotFind()), actions);
-	mActionFindNext = KStdAction::findNext(mListView, TQT_SLOT(slotFindNext()), actions);
-	mActionFindPrev = KStdAction::findPrev(mListView, TQT_SLOT(slotFindPrev()), actions);
-	KStdAction::selectAll(mListView, TQT_SLOT(slotSelectAll()), actions);
-	KStdAction::deselect(mListView, TQT_SLOT(slotDeselect()), actions);
-	KStdAction::quit(this, TQT_SLOT(slotQuit()), actions);
-	KStdAction::keyBindings(this, TQT_SLOT(slotConfigureKeys()), actions);
-	KStdAction::configureToolbars(this, TQT_SLOT(slotConfigureToolbar()), actions);
-	KStdAction::preferences(this, TQT_SLOT(slotPreferences()), actions);
+	mActionUndo = new TDEToolBarPopupAction(undoText, undoIcon, undoShortcut, this, TQ_SLOT(slotUndo()), actions, "edit_undo");
+	mActionRedo = new TDEToolBarPopupAction(redoText, redoIcon, redoShortcut, this, TQ_SLOT(slotRedo()), actions, "edit_redo");
+	KStdAction::find(mListView, TQ_SLOT(slotFind()), actions);
+	mActionFindNext = KStdAction::findNext(mListView, TQ_SLOT(slotFindNext()), actions);
+	mActionFindPrev = KStdAction::findPrev(mListView, TQ_SLOT(slotFindPrev()), actions);
+	KStdAction::selectAll(mListView, TQ_SLOT(slotSelectAll()), actions);
+	KStdAction::deselect(mListView, TQ_SLOT(slotDeselect()), actions);
+	KStdAction::quit(this, TQ_SLOT(slotQuit()), actions);
+	KStdAction::keyBindings(this, TQ_SLOT(slotConfigureKeys()), actions);
+	KStdAction::configureToolbars(this, TQ_SLOT(slotConfigureToolbar()), actions);
+	KStdAction::preferences(this, TQ_SLOT(slotPreferences()), actions);
 	setStandardToolBarMenuEnabled(true);
 	createGUI(UI_FILE);
 
 	mContextMenu = static_cast<TDEPopupMenu*>(factory()->container("listContext", this));
 	mActionsMenu = static_cast<TDEPopupMenu*>(factory()->container("actions", this));
 	mMenuError = (!mContextMenu  ||  !mActionsMenu);
-	connect(mActionsMenu, TQT_SIGNAL(aboutToShow()), TQT_SLOT(updateActionsMenu()));
-	connect(mActionUndo->popupMenu(), TQT_SIGNAL(aboutToShow()), TQT_SLOT(slotInitUndoMenu()));
-	connect(mActionUndo->popupMenu(), TQT_SIGNAL(activated(int)), TQT_SLOT(slotUndoItem(int)));
-	connect(mActionRedo->popupMenu(), TQT_SIGNAL(aboutToShow()), TQT_SLOT(slotInitRedoMenu()));
-	connect(mActionRedo->popupMenu(), TQT_SIGNAL(activated(int)), TQT_SLOT(slotRedoItem(int)));
-	connect(Undo::instance(), TQT_SIGNAL(changed(const TQString&, const TQString&)), TQT_SLOT(slotUndoStatus(const TQString&, const TQString&)));
-	connect(mListView, TQT_SIGNAL(findActive(bool)), TQT_SLOT(slotFindActive(bool)));
-	Preferences::connect(TQT_SIGNAL(preferencesChanged()), this, TQT_SLOT(slotPrefsChanged()));
-	connect(theApp(), TQT_SIGNAL(trayIconToggled()), TQT_SLOT(updateTrayIconAction()));
+	connect(mActionsMenu, TQ_SIGNAL(aboutToShow()), TQ_SLOT(updateActionsMenu()));
+	connect(mActionUndo->popupMenu(), TQ_SIGNAL(aboutToShow()), TQ_SLOT(slotInitUndoMenu()));
+	connect(mActionUndo->popupMenu(), TQ_SIGNAL(activated(int)), TQ_SLOT(slotUndoItem(int)));
+	connect(mActionRedo->popupMenu(), TQ_SIGNAL(aboutToShow()), TQ_SLOT(slotInitRedoMenu()));
+	connect(mActionRedo->popupMenu(), TQ_SIGNAL(activated(int)), TQ_SLOT(slotRedoItem(int)));
+	connect(Undo::instance(), TQ_SIGNAL(changed(const TQString&, const TQString&)), TQ_SLOT(slotUndoStatus(const TQString&, const TQString&)));
+	connect(mListView, TQ_SIGNAL(findActive(bool)), TQ_SLOT(slotFindActive(bool)));
+	Preferences::connect(TQ_SIGNAL(preferencesChanged()), this, TQ_SLOT(slotPrefsChanged()));
+	connect(theApp(), TQ_SIGNAL(trayIconToggled()), TQ_SLOT(updateTrayIconAction()));
 
 	// Set menu item states
 	setEnableText(true);
@@ -485,7 +485,7 @@ void MainWindow::setUpdateTimer()
 	{
 		// Timeout every minute.
 		needTimer->mMinuteTimerActive = true;
-		MinuteTimer::connect(needTimer, TQT_SLOT(slotUpdateTimeTo()));
+		MinuteTimer::connect(needTimer, TQ_SLOT(slotUpdateTimeTo()));
 		kdDebug(5950) << "MainWindow::setUpdateTimer(): started timer" << endl;
 	}
 	else if (!needTimer  &&  timerWindow)
@@ -895,7 +895,7 @@ void MainWindow::slotTemplates()
 	{
 		mTemplateDlg = TemplateDlg::create(this);
 		enableTemplateMenuItem(false);     // disable menu item in all windows
-		connect(mTemplateDlg, TQT_SIGNAL(finished()), TQT_SLOT(slotTemplatesEnd()));
+		connect(mTemplateDlg, TQ_SIGNAL(finished()), TQ_SLOT(slotTemplatesEnd()));
 		mTemplateDlg->show();
 	}
 }
@@ -1088,7 +1088,7 @@ void MainWindow::slotConfigureToolbar()
 {
 	saveMainWindowSettings(TDEGlobal::config(), WINDOW_NAME);
 	KEditToolbar dlg(factory());
-	connect(&dlg, TQT_SIGNAL(newToolbarConfig()), this, TQT_SLOT(slotNewToolbarConfig()));
+	connect(&dlg, TQ_SIGNAL(newToolbarConfig()), this, TQ_SLOT(slotNewToolbarConfig()));
 	dlg.exec();
 }
 
diff --git a/kalarm/messagewin.cpp b/kalarm/messagewin.cpp
index f05770d05..7479ce4e6 100644
--- a/kalarm/messagewin.cpp
+++ b/kalarm/messagewin.cpp
@@ -429,12 +429,12 @@ void MessageWin::initView()
 			if (mDateTime.isDateOnly()  ||  TQDate::currentDate().daysTo(mDateTime.date()) > 0)
 			{
 				setRemainingTextDay();
-				MidnightTimer::connect(this, TQT_SLOT(setRemainingTextDay()));    // update every day
+				MidnightTimer::connect(this, TQ_SLOT(setRemainingTextDay()));    // update every day
 			}
 			else
 			{
 				setRemainingTextMinute();
-				MinuteTimer::connect(this, TQT_SLOT(setRemainingTextMinute()));   // update every minute
+				MinuteTimer::connect(this, TQ_SLOT(setRemainingTextMinute()));   // update every minute
 			}
 			topLayout->addWidget(mRemainingText, 0, TQt::AlignHCenter);
 			topLayout->addSpacing(KDialog::spacingHint());
@@ -512,7 +512,7 @@ void MessageWin::initView()
 	mOkButton->clearFocus();
 	mOkButton->setFocusPolicy(TQWidget::ClickFocus);    // don't allow keyboard selection
 	mOkButton->setFixedSize(mOkButton->sizeHint());
-	connect(mOkButton, TQT_SIGNAL(clicked()), TQT_SLOT(close()));
+	connect(mOkButton, TQ_SIGNAL(clicked()), TQ_SLOT(close()));
 	grid->addWidget(mOkButton, 0, gridIndex++, AlignHCenter);
 	TQWhatsThis::add(mOkButton, i18n("Acknowledge the alarm"));
 
@@ -522,7 +522,7 @@ void MessageWin::initView()
 		mEditButton = new TQPushButton(i18n("&Edit..."), topWidget);
 		mEditButton->setFocusPolicy(TQWidget::ClickFocus);    // don't allow keyboard selection
 		mEditButton->setFixedSize(mEditButton->sizeHint());
-		connect(mEditButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotEdit()));
+		connect(mEditButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotEdit()));
 		grid->addWidget(mEditButton, 0, gridIndex++, AlignHCenter);
 		TQWhatsThis::add(mEditButton, i18n("Edit the alarm."));
 	}
@@ -533,7 +533,7 @@ void MessageWin::initView()
 		mDeferButton = new TQPushButton(i18n("&Defer..."), topWidget);
 		mDeferButton->setFocusPolicy(TQWidget::ClickFocus);    // don't allow keyboard selection
 		mDeferButton->setFixedSize(mDeferButton->sizeHint());
-		connect(mDeferButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotDefer()));
+		connect(mDeferButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotDefer()));
 		grid->addWidget(mDeferButton, 0, gridIndex++, AlignHCenter);
 		TQWhatsThis::add(mDeferButton,
 		      i18n("Defer the alarm until later.\n"
@@ -550,7 +550,7 @@ void MessageWin::initView()
 		mSilenceButton = new TQPushButton(topWidget);
 		mSilenceButton->setPixmap(pixmap);
 		mSilenceButton->setFixedSize(mSilenceButton->sizeHint());
-		connect(mSilenceButton, TQT_SIGNAL(clicked()), TQT_SLOT(stopPlay()));
+		connect(mSilenceButton, TQ_SIGNAL(clicked()), TQ_SLOT(stopPlay()));
 		grid->addWidget(mSilenceButton, 0, gridIndex++, AlignHCenter);
 		TQToolTip::add(mSilenceButton, i18n("Stop sound"));
 		TQWhatsThis::add(mSilenceButton, i18n("Stop playing the sound"));
@@ -567,7 +567,7 @@ void MessageWin::initView()
 		mKMailButton = new TQPushButton(topWidget);
 		mKMailButton->setPixmap(pixmap);
 		mKMailButton->setFixedSize(mKMailButton->sizeHint());
-		connect(mKMailButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotShowKMailMessage()));
+		connect(mKMailButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotShowKMailMessage()));
 		grid->addWidget(mKMailButton, 0, gridIndex++, AlignHCenter);
 		TQToolTip::add(mKMailButton, i18n("Locate this email in KMail", "Locate in KMail"));
 		TQWhatsThis::add(mKMailButton, i18n("Locate and highlight this email in KMail"));
@@ -580,7 +580,7 @@ void MessageWin::initView()
 	mKAlarmButton = new TQPushButton(topWidget);
 	mKAlarmButton->setPixmap(pixmap);
 	mKAlarmButton->setFixedSize(mKAlarmButton->sizeHint());
-	connect(mKAlarmButton, TQT_SIGNAL(clicked()), TQT_SLOT(displayMainWindow()));
+	connect(mKAlarmButton, TQ_SIGNAL(clicked()), TQ_SLOT(displayMainWindow()));
 	grid->addWidget(mKAlarmButton, 0, gridIndex++, AlignHCenter);
 	TQString actKAlarm = i18n("Activate KAlarm");
 	TQToolTip::add(mKAlarmButton, actKAlarm);
@@ -619,9 +619,9 @@ void MessageWin::setRemainingTextDay()
 	if (days <= 0  &&  !mDateTime.isDateOnly())
 	{
 		// The alarm is due today, so start refreshing every minute
-		MidnightTimer::disconnect(this, TQT_SLOT(setRemainingTextDay()));
+		MidnightTimer::disconnect(this, TQ_SLOT(setRemainingTextDay()));
 		setRemainingTextMinute();
-		MinuteTimer::connect(this, TQT_SLOT(setRemainingTextMinute()));   // update every minute
+		MinuteTimer::connect(this, TQ_SLOT(setRemainingTextMinute()));   // update every minute
 	}
 	else
 	{
@@ -796,14 +796,14 @@ void MessageWin::playAudio()
 #else
 		// An audio file is specified. Because loading it may take some time,
 		// call it on a timer to allow the window to display first.
-		TQTimer::singleShot(0, this, TQT_SLOT(slotPlayAudio()));
+		TQTimer::singleShot(0, this, TQ_SLOT(slotPlayAudio()));
 #endif
 	}
 	else if (mSpeak)
 	{
 		// The message is to be spoken. In case of error messges,
 		// call it on a timer to allow the window to display first.
-		TQTimer::singleShot(0, this, TQT_SLOT(slotSpeak()));
+		TQTimer::singleShot(0, this, TQ_SLOT(slotSpeak()));
 	}
 }
 
@@ -868,7 +868,7 @@ void MessageWin::slotPlayAudio()
 	{
 		mFadeTimer = 0;
 		mPlayTimer = new TQTimer(this);
-		connect(mPlayTimer, TQT_SIGNAL(timeout()), TQT_SLOT(checkAudioPlay()));
+		connect(mPlayTimer, TQ_SIGNAL(timeout()), TQ_SLOT(checkAudioPlay()));
 		mArtsDispatcher = new KArtsDispatcher;
 		mPlayedOnce = false;
 		mAudioFileStart = TQTime::currentTime();
@@ -935,7 +935,7 @@ void MessageWin::initAudio(bool firstTime)
 	}
 	mSilenceButton->setEnabled(true);
 	mPlayed = false;
-	connect(mPlayObject, TQT_SIGNAL(playObjectCreated()), TQT_SLOT(checkAudioPlay()));
+	connect(mPlayObject, TQ_SIGNAL(playObjectCreated()), TQ_SLOT(checkAudioPlay()));
 	if (!mPlayObject->object().isNull())
 		checkAudioPlay();
 }
@@ -976,7 +976,7 @@ void MessageWin::checkAudioPlay()
 				// Set up volume fade
 				mAudioFileStart = now;
 				mFadeTimer = new TQTimer(this);
-				connect(mFadeTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotFade()));
+				connect(mFadeTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotFade()));
 				mFadeTimer->start(1000);     // adjust volume every second
 			}
 			mPlayedOnce = true;
@@ -1186,7 +1186,7 @@ void MessageWin::show()
 		int delay = TQDateTime::currentDateTime().secsTo(mCloseTime);
 		if (delay < 0)
 			delay = 0;
-		TQTimer::singleShot(delay * 1000, this, TQT_SLOT(close()));
+		TQTimer::singleShot(delay * 1000, this, TQ_SLOT(close()));
 		if (!delay)
 			return;    // don't show the window if auto-closing is already due
 	}
@@ -1302,7 +1302,7 @@ void MessageWin::showEvent(TQShowEvent* se)
 			if (mAction == KAEvent::MESSAGE)
 			{
 				// Set the window size once the frame size is known
-				TQTimer::singleShot(0, this, TQT_SLOT(setMaxSize()));
+				TQTimer::singleShot(0, this, TQ_SLOT(setMaxSize()));
 			}
 		}
 		mShown = true;
@@ -1345,7 +1345,7 @@ void MessageWin::displayComplete()
 
 	// Enable the window's buttons either now or after the configured delay
 	if (mButtonDelay > 0)
-		TQTimer::singleShot(mButtonDelay, this, TQT_SLOT(enableButtons()));
+		TQTimer::singleShot(mButtonDelay, this, TQ_SLOT(enableButtons()));
 	else
 		enableButtons();
 }
@@ -1497,7 +1497,7 @@ void MessageWin::setDeferralLimit(const KAEvent& event)
 	if (mDeferButton)
 	{
 		mDeferLimit = event.deferralLimit().dateTime();
-		MidnightTimer::connect(this, TQT_SLOT(checkDeferralLimit()));   // check every day
+		MidnightTimer::connect(this, TQ_SLOT(checkDeferralLimit()));   // check every day
 		mDisableDeferral = false;
 		checkDeferralLimit();
 	}
@@ -1519,14 +1519,14 @@ void MessageWin::checkDeferralLimit()
 	int n = TQDate::currentDate().daysTo(mDeferLimit.date());
 	if (n > 0)
 		return;
-	MidnightTimer::disconnect(this, TQT_SLOT(checkDeferralLimit()));
+	MidnightTimer::disconnect(this, TQ_SLOT(checkDeferralLimit()));
 	if (n == 0)
 	{
 		// The deferral limit will be reached today
 		n = TQTime::currentTime().secsTo(mDeferLimit.time());
 		if (n > 0)
 		{
-			TQTimer::singleShot(n * 1000, this, TQT_SLOT(checkDeferralLimit()));
+			TQTimer::singleShot(n * 1000, this, TQ_SLOT(checkDeferralLimit()));
 			return;
 		}
 	}
diff --git a/kalarm/pickfileradio.cpp b/kalarm/pickfileradio.cpp
index 15b56d942..bdfb2bb45 100644
--- a/kalarm/pickfileradio.cpp
+++ b/kalarm/pickfileradio.cpp
@@ -41,10 +41,10 @@ PickFileRadio::PickFileRadio(TQPushButton* button, LineEdit* edit, const TQStrin
 	Q_ASSERT(parent);
 	Q_ASSERT(button);
 	mButton->setEnabled(false);
-	connect(mButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotPickFile()));
+	connect(mButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotPickFile()));
 	if (mEdit)
 		mEdit->setEnabled(false);
-	connect(mGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotSelectionChanged(int)));
+	connect(mGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotSelectionChanged(int)));
 }
 
 PickFileRadio::PickFileRadio(const TQString& text, TQButtonGroup* parent, const char* name)
@@ -64,10 +64,10 @@ void PickFileRadio::init(TQPushButton* button, LineEdit* edit)
 	mEdit   = edit;
 	mButton = button;
 	mButton->setEnabled(false);
-	connect(mButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotPickFile()));
+	connect(mButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotPickFile()));
 	if (mEdit)
 		mEdit->setEnabled(false);
-	connect(mGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotSelectionChanged(int)));
+	connect(mGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotSelectionChanged(int)));
 	setReadOnly(RadioButton::isReadOnly());
 }
 
@@ -165,7 +165,7 @@ void PickFileRadio::slotPickFile()
 		// No file is selected, so revert to the previous radio button selection.
 		// But wait a moment before setting the radio button, or it won't work.
 		mRevertId = true;   // prevent picker dialogue popping up twice
-		TQTimer::singleShot(0, this, TQT_SLOT(setLastId()));
+		TQTimer::singleShot(0, this, TQ_SLOT(setLastId()));
 	}
 }
 
diff --git a/kalarm/prefdlg.cpp b/kalarm/prefdlg.cpp
index f439d609d..38cd56034 100644
--- a/kalarm/prefdlg.cpp
+++ b/kalarm/prefdlg.cpp
@@ -263,7 +263,7 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 	// Run-on-demand radio button
 	mRunOnDemand = new TQRadioButton(i18n("&Run only on demand"), group, "runDemand");
 	mRunOnDemand->setFixedSize(mRunOnDemand->sizeHint());
-	connect(mRunOnDemand, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotRunModeToggled(bool)));
+	connect(mRunOnDemand, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotRunModeToggled(bool)));
 	TQWhatsThis::add(mRunOnDemand,
 	      i18n("Check to run KAlarm only when required.\n\n"
 	           "Notes:\n"
@@ -274,7 +274,7 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 	// Run-in-system-tray radio button
 	mRunInSystemTray = new TQRadioButton(i18n("Run continuously in system &tray"), group, "runTray");
 	mRunInSystemTray->setFixedSize(mRunInSystemTray->sizeHint());
-	connect(mRunInSystemTray, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotRunModeToggled(bool)));
+	connect(mRunInSystemTray, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotRunModeToggled(bool)));
 	TQWhatsThis::add(mRunInSystemTray,
 	      i18n("Check to run KAlarm continuously in the TDE system tray.\n\n"
 	           "Notes:\n"
@@ -286,7 +286,7 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 	// Run continuously options
 	mDisableAlarmsIfStopped = new TQCheckBox(i18n("Disa&ble alarms while not running"), group, "disableAl");
 	mDisableAlarmsIfStopped->setFixedSize(mDisableAlarmsIfStopped->sizeHint());
-	connect(mDisableAlarmsIfStopped, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotDisableIfStoppedToggled(bool)));
+	connect(mDisableAlarmsIfStopped, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotDisableIfStoppedToggled(bool)));
 	TQWhatsThis::add(mDisableAlarmsIfStopped,
 	      i18n("Check to disable alarms whenever KAlarm is not running. Alarms will only appear while the system tray icon is visible."));
 	grid->addMultiCellWidget(mDisableAlarmsIfStopped, 3, 3, 1, 2, alignment);
@@ -299,14 +299,14 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 
 	mAutostartTrayIcon = new TQCheckBox(i18n("Autostart at &login"), group, "autoTray");
 #ifdef AUTOSTART_BY_KALARMD
-	connect(mAutostartTrayIcon, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotAutostartToggled(bool)));
+	connect(mAutostartTrayIcon, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAutostartToggled(bool)));
 #endif
 	grid->addMultiCellWidget(mAutostartTrayIcon, 5, 5, 0, 2, alignment);
 
 	// Autostart alarm daemon
 	mAutostartDaemon = new TQCheckBox(i18n("Start alarm monitoring at lo&gin"), group, "startDaemon");
 	mAutostartDaemon->setFixedSize(mAutostartDaemon->sizeHint());
-	connect(mAutostartDaemon, TQT_SIGNAL(clicked()), TQT_SLOT(slotAutostartDaemonClicked()));
+	connect(mAutostartDaemon, TQ_SIGNAL(clicked()), TQ_SLOT(slotAutostartDaemonClicked()));
 	TQWhatsThis::add(mAutostartDaemon,
 	      i18n("Automatically start alarm monitoring whenever you start TDE, by running the alarm daemon (%1).\n\n"
 	           "This option should always be checked unless you intend to discontinue use of KAlarm.")
@@ -346,7 +346,7 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 	grid->addRowSpacing(0, fontMetrics().lineSpacing()/2);
 	mKeepExpired = new TQCheckBox(i18n("Keep alarms after e&xpiry"), group, "keepExpired");
 	mKeepExpired->setFixedSize(mKeepExpired->sizeHint());
-	connect(mKeepExpired, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotExpiredToggled(bool)));
+	connect(mKeepExpired, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotExpiredToggled(bool)));
 	TQWhatsThis::add(mKeepExpired,
 	      i18n("Check to store alarms after expiry or deletion (except deleted alarms which were never triggered)."));
 	grid->addMultiCellWidget(mKeepExpired, 1, 1, 0, 1, alignment);
@@ -355,7 +355,7 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 	box->setSpacing(KDialog::spacingHint());
 	mPurgeExpired = new TQCheckBox(i18n("Discard ex&pired alarms after:"), box, "purgeExpired");
 	mPurgeExpired->setMinimumSize(mPurgeExpired->sizeHint());
-	connect(mPurgeExpired, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotExpiredToggled(bool)));
+	connect(mPurgeExpired, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotExpiredToggled(bool)));
 	mPurgeAfter = new SpinBox(box);
 	mPurgeAfter->setMinValue(1);
 	mPurgeAfter->setLineShiftStep(10);
@@ -369,7 +369,7 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 
 	mClearExpired = new TQPushButton(i18n("Clear Expired Alar&ms"), group);
 	mClearExpired->setFixedSize(mClearExpired->sizeHint());
-	connect(mClearExpired, TQT_SIGNAL(clicked()), TQT_SLOT(slotClearExpired()));
+	connect(mClearExpired, TQ_SIGNAL(clicked()), TQ_SLOT(slotClearExpired()));
 	TQWhatsThis::add(mClearExpired,
 	      i18n("Delete all existing expired alarms."));
 	grid->addWidget(mClearExpired, 3, 1, alignment);
@@ -413,7 +413,7 @@ MiscPrefTab::MiscPrefTab(TQVBox* frame)
 	grid->addMultiCellWidget(box, row + 1, row + 1, 0, 2, TQt::AlignAuto);
 	TQRadioButton* radio = new TQRadioButton(i18n("Other:"), box);
 	radio->setFixedSize(radio->sizeHint());
-	connect(radio, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotOtherTerminalToggled(bool)));
+	connect(radio, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotOtherTerminalToggled(bool)));
 	mXtermType->insert(radio, mXtermCount);
 	if (mXtermFirst < 0)
 		mXtermFirst = mXtermCount;   // note the id of the first button
@@ -609,7 +609,7 @@ EmailPrefTab::EmailPrefTab(TQVBox* frame)
 	radio = new RadioButton(i18n("&Sendmail"), box, "sendmail");
 	radio->setMinimumSize(radio->sizeHint());
 	mEmailClient->insert(radio, Preferences::SENDMAIL);
-	connect(mEmailClient, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotEmailClientChanged(int)));
+	connect(mEmailClient, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotEmailClientChanged(int)));
 	box->setFixedHeight(box->sizeHint().height());
 	TQWhatsThis::add(box,
 	      i18n("Choose how to send email when an email alarm is triggered.\n"
@@ -637,7 +637,7 @@ EmailPrefTab::EmailPrefTab(TQVBox* frame)
 	grid->addWidget(label, 1, 0);
 	mFromAddressGroup = new ButtonGroup(group);
 	mFromAddressGroup->hide();
-	connect(mFromAddressGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotFromAddrChanged(int)));
+	connect(mFromAddressGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotFromAddrChanged(int)));
 
 	// Line edit to enter a 'From' email address
 	radio = new RadioButton(group);
@@ -646,7 +646,7 @@ EmailPrefTab::EmailPrefTab(TQVBox* frame)
 	label->setBuddy(radio);
 	grid->addWidget(radio, 1, 1);
 	mEmailAddress = new TQLineEdit(group);
-	connect(mEmailAddress, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotAddressChanged()));
+	connect(mEmailAddress, TQ_SIGNAL(textChanged(const TQString&)), TQ_SLOT(slotAddressChanged()));
 	TQString whatsThis = i18n("Your email address, used to identify you as the sender when sending email alarms.");
 	TQWhatsThis::add(radio, whatsThis);
 	TQWhatsThis::add(mEmailAddress, whatsThis);
@@ -678,7 +678,7 @@ EmailPrefTab::EmailPrefTab(TQVBox* frame)
 	grid->addWidget(label, 5, 0);
 	mBccAddressGroup = new ButtonGroup(group);
 	mBccAddressGroup->hide();
-	connect(mBccAddressGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(slotBccAddrChanged(int)));
+	connect(mBccAddressGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotBccAddrChanged(int)));
 
 	// Line edit to enter a 'Bcc' email address
 	radio = new RadioButton(group);
@@ -962,7 +962,7 @@ EditPrefTab::EditPrefTab(TQVBox* frame)
 	mSoundFileBrowse = new TQPushButton(box);
 	mSoundFileBrowse->setPixmap(SmallIcon("document-open"));
 	mSoundFileBrowse->setFixedSize(mSoundFileBrowse->sizeHint());
-	connect(mSoundFileBrowse, TQT_SIGNAL(clicked()), TQT_SLOT(slotBrowseSoundFile()));
+	connect(mSoundFileBrowse, TQ_SIGNAL(clicked()), TQ_SLOT(slotBrowseSoundFile()));
 	TQToolTip::add(mSoundFileBrowse, i18n("Choose a sound file"));
 	TQWhatsThis::add(box,
 	      i18n("Enter the default sound file to use in the alarm edit dialog."));
@@ -1201,7 +1201,7 @@ ViewPrefTab::ViewPrefTab(TQVBox* frame)
 
 	mTooltipShowAlarms = new TQCheckBox(i18n("Show next &24 hours' alarms"), group, "tooltipShow");
 	mTooltipShowAlarms->setMinimumSize(mTooltipShowAlarms->sizeHint());
-	connect(mTooltipShowAlarms, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotTooltipAlarmsToggled(bool)));
+	connect(mTooltipShowAlarms, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotTooltipAlarmsToggled(bool)));
 	TQWhatsThis::add(mTooltipShowAlarms,
 	      i18n("Specify whether to include in the system tray tooltip, a summary of alarms due in the next 24 hours"));
 	grid->addMultiCellWidget(mTooltipShowAlarms, 1, 1, 0, 2, TQt::AlignAuto);
@@ -1210,7 +1210,7 @@ ViewPrefTab::ViewPrefTab(TQVBox* frame)
 	box->setSpacing(KDialog::spacingHint());
 	mTooltipMaxAlarms = new TQCheckBox(i18n("Ma&ximum number of alarms to show:"), box, "tooltipMax");
 	mTooltipMaxAlarms->setMinimumSize(mTooltipMaxAlarms->sizeHint());
-	connect(mTooltipMaxAlarms, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotTooltipMaxToggled(bool)));
+	connect(mTooltipMaxAlarms, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotTooltipMaxToggled(bool)));
 	mTooltipMaxAlarmCount = new SpinBox(1, 99, 1, box);
 	mTooltipMaxAlarmCount->setLineShiftStep(5);
 	mTooltipMaxAlarmCount->setMinimumSize(mTooltipMaxAlarmCount->sizeHint());
@@ -1221,14 +1221,14 @@ ViewPrefTab::ViewPrefTab(TQVBox* frame)
 
 	mTooltipShowTime = new TQCheckBox(MainWindow::i18n_m_ShowAlarmTime(), group, "tooltipTime");
 	mTooltipShowTime->setMinimumSize(mTooltipShowTime->sizeHint());
-	connect(mTooltipShowTime, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotTooltipTimeToggled(bool)));
+	connect(mTooltipShowTime, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotTooltipTimeToggled(bool)));
 	TQWhatsThis::add(mTooltipShowTime,
 	      i18n("Specify whether to show in the system tray tooltip, the time at which each alarm is due"));
 	grid->addMultiCellWidget(mTooltipShowTime, 3, 3, 1, 2, TQt::AlignAuto);
 
 	mTooltipShowTimeTo = new TQCheckBox(MainWindow::i18n_l_ShowTimeToAlarm(), group, "tooltipTimeTo");
 	mTooltipShowTimeTo->setMinimumSize(mTooltipShowTimeTo->sizeHint());
-	connect(mTooltipShowTimeTo, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotTooltipTimeToToggled(bool)));
+	connect(mTooltipShowTimeTo, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotTooltipTimeToToggled(bool)));
 	TQWhatsThis::add(mTooltipShowTimeTo,
 	      i18n("Specify whether to show in the system tray tooltip, how long until each alarm is due"));
 	grid->addMultiCellWidget(mTooltipShowTimeTo, 4, 4, 1, 2, TQt::AlignAuto);
diff --git a/kalarm/recurrenceedit.cpp b/kalarm/recurrenceedit.cpp
index 7c04c1dbc..feee5e84d 100644
--- a/kalarm/recurrenceedit.cpp
+++ b/kalarm/recurrenceedit.cpp
@@ -116,7 +116,7 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 	mRuleButtonGroup->setFrameStyle(TQFrame::NoFrame);
 	lay->addWidget(mRuleButtonGroup);
 	lay->addStretch();    // top-adjust the interval radio buttons
-	connect(mRuleButtonGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(periodClicked(int)));
+	connect(mRuleButtonGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(periodClicked(int)));
 
 	mNoneButton = new RadioButton(i18n_Norecur(), mRuleButtonGroup);
 	mNoneButton->setFixedSize(mNoneButton->sizeHint());
@@ -172,8 +172,8 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 	mSubRepetition = new RepetitionButton(i18n("Sub-Repetition"), true, ruleFrame);
 	mSubRepetition->setFixedSize(mSubRepetition->sizeHint());
 	mSubRepetition->setReadOnly(mReadOnly);
-	connect(mSubRepetition, TQT_SIGNAL(needsInitialisation()), TQT_SIGNAL(repeatNeedsInitialisation()));
-	connect(mSubRepetition, TQT_SIGNAL(changed()), TQT_SIGNAL(frequencyChanged()));
+	connect(mSubRepetition, TQ_SIGNAL(needsInitialisation()), TQ_SIGNAL(repeatNeedsInitialisation()));
+	connect(mSubRepetition, TQ_SIGNAL(changed()), TQ_SIGNAL(frequencyChanged()));
 	TQWhatsThis::add(mSubRepetition, i18n("Set up a repetition within the recurrence, to trigger the alarm multiple times each time the recurrence is due."));
 	lay->addSpacing(KDialog::spacingHint());
 	lay->addWidget(mSubRepetition);
@@ -196,11 +196,11 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 	mMonthlyRule  = new MonthlyRule(mReadOnly, ruleFrame, "monthFrame");
 	mYearlyRule   = new YearlyRule(mReadOnly, ruleFrame, "yearFrame");
 
-	connect(mSubDailyRule, TQT_SIGNAL(frequencyChanged()), this, TQT_SIGNAL(frequencyChanged()));
-	connect(mDailyRule, TQT_SIGNAL(frequencyChanged()), this, TQT_SIGNAL(frequencyChanged()));
-	connect(mWeeklyRule, TQT_SIGNAL(frequencyChanged()), this, TQT_SIGNAL(frequencyChanged()));
-	connect(mMonthlyRule, TQT_SIGNAL(frequencyChanged()), this, TQT_SIGNAL(frequencyChanged()));
-	connect(mYearlyRule, TQT_SIGNAL(frequencyChanged()), this, TQT_SIGNAL(frequencyChanged()));
+	connect(mSubDailyRule, TQ_SIGNAL(frequencyChanged()), this, TQ_SIGNAL(frequencyChanged()));
+	connect(mDailyRule, TQ_SIGNAL(frequencyChanged()), this, TQ_SIGNAL(frequencyChanged()));
+	connect(mWeeklyRule, TQ_SIGNAL(frequencyChanged()), this, TQ_SIGNAL(frequencyChanged()));
+	connect(mMonthlyRule, TQ_SIGNAL(frequencyChanged()), this, TQ_SIGNAL(frequencyChanged()));
+	connect(mYearlyRule, TQ_SIGNAL(frequencyChanged()), this, TQ_SIGNAL(frequencyChanged()));
 
 	mRuleStack = new TQWidgetStack(ruleFrame);
 	layout->addWidget(mRuleStack);
@@ -217,7 +217,7 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 	// which specify how long the recurrence is to last.
 
 	mRangeButtonGroup = new ButtonGroup(i18n("Recurrence End"), this, "mRangeButtonGroup");
-	connect(mRangeButtonGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(rangeTypeClicked()));
+	connect(mRangeButtonGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(rangeTypeClicked()));
 	topLayout->addWidget(mRangeButtonGroup);
 
 	TQVBoxLayout* vlayout = new TQVBoxLayout(mRangeButtonGroup, KDialog::marginHint(), KDialog::spacingHint());
@@ -239,7 +239,7 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 	mRepeatCountEntry->setLineShiftStep(10);
 	mRepeatCountEntry->setSelectOnStep(false);
 	mRepeatCountEntry->setReadOnly(mReadOnly);
-	connect(mRepeatCountEntry, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(repeatCountChanged(int)));
+	connect(mRepeatCountEntry, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(repeatCountChanged(int)));
 	TQWhatsThis::add(mRepeatCountEntry,
 	      i18n("Enter the total number of times to trigger the alarm"));
 	mRepeatCountButton->setFocusWidget(mRepeatCountEntry);
@@ -272,7 +272,7 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 	mEndAnyTimeCheckBox = new CheckBox(i18n("Any time"), mRangeButtonGroup);
 	mEndAnyTimeCheckBox->setFixedSize(mEndAnyTimeCheckBox->sizeHint());
 	mEndAnyTimeCheckBox->setReadOnly(mReadOnly);
-	connect(mEndAnyTimeCheckBox, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotAnyTimeToggled(bool)));
+	connect(mEndAnyTimeCheckBox, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAnyTimeToggled(bool)));
 	TQWhatsThis::add(mEndAnyTimeCheckBox,
 	      i18n("Stop repeating the alarm after your first login on or after the specified end date"));
 	layout->addWidget(mEndDateButton);
@@ -300,7 +300,7 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 
 	mExceptionDateList = new TQListBox(mExceptionGroup);
 	mExceptionDateList->setSizePolicy(TQSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding));
-	connect(mExceptionDateList, TQT_SIGNAL(selectionChanged()), TQT_SLOT(enableExceptionButtons()));
+	connect(mExceptionDateList, TQ_SIGNAL(selectionChanged()), TQ_SLOT(enableExceptionButtons()));
 	TQWhatsThis::add(mExceptionDateList,
 	      i18n("The list of exceptions, i.e. dates/times excluded from the recurrence"));
 	vlayout->addWidget(mExceptionDateList);
@@ -325,21 +325,21 @@ RecurrenceEdit::RecurrenceEdit(bool readOnly, TQWidget* parent, const char* name
 		layout = new TQHBoxLayout(vlayout, KDialog::spacingHint());
 		TQPushButton* button = new TQPushButton(i18n("Add"), mExceptionGroup);
 		button->setFixedSize(button->sizeHint());
-		connect(button, TQT_SIGNAL(clicked()), TQT_SLOT(addException()));
+		connect(button, TQ_SIGNAL(clicked()), TQ_SLOT(addException()));
 		TQWhatsThis::add(button,
 		      i18n("Add the date entered above to the exceptions list"));
 		layout->addWidget(button);
 
 		mChangeExceptionButton = new TQPushButton(i18n("Change"), mExceptionGroup);
 		mChangeExceptionButton->setFixedSize(mChangeExceptionButton->sizeHint());
-		connect(mChangeExceptionButton, TQT_SIGNAL(clicked()), TQT_SLOT(changeException()));
+		connect(mChangeExceptionButton, TQ_SIGNAL(clicked()), TQ_SLOT(changeException()));
 		TQWhatsThis::add(mChangeExceptionButton,
 		      i18n("Replace the currently highlighted item in the exceptions list with the date entered above"));
 		layout->addWidget(mChangeExceptionButton);
 
 		mDeleteExceptionButton = new TQPushButton(i18n("Delete"), mExceptionGroup);
 		mDeleteExceptionButton->setFixedSize(mDeleteExceptionButton->sizeHint());
-		connect(mDeleteExceptionButton, TQT_SIGNAL(clicked()), TQT_SLOT(deleteException()));
+		connect(mDeleteExceptionButton, TQ_SIGNAL(clicked()), TQ_SLOT(deleteException()));
 		TQWhatsThis::add(mDeleteExceptionButton,
 		      i18n("Remove the currently highlighted item from the exceptions list"));
 		layout->addWidget(mDeleteExceptionButton);
@@ -1137,7 +1137,7 @@ Rule::Rule(const TQString& freqText, const TQString& freqWhatsThis, bool time, b
 		mIntSpinBox->setFixedSize(mIntSpinBox->sizeHint());
 		mIntSpinBox->setReadOnly(readOnly);
 	}
-	connect(mSpinBox, TQT_SIGNAL(valueChanged(int)), TQT_SIGNAL(frequencyChanged()));
+	connect(mSpinBox, TQ_SIGNAL(valueChanged(int)), TQ_SIGNAL(frequencyChanged()));
 	label->setBuddy(mSpinBox);
 	label = new TQLabel(freqText, box);
 	label->setFixedSize(label->sizeHint());
@@ -1368,7 +1368,7 @@ MonthYearRule::MonthYearRule(const TQString& freqText, const TQString& freqWhats
 	mDayCombo->setReadOnly(readOnly);
 	TQWhatsThis::add(mDayCombo, i18n("Select the day of the month on which to repeat the alarm"));
 	mDayButton->setFocusWidget(mDayCombo);
-	connect(mDayCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotDaySelected(int)));
+	connect(mDayCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotDaySelected(int)));
 
 	box->setStretchFactor(new TQWidget(box), 1);    // left adjust the controls
 	box->setFixedHeight(box->sizeHint().height());
@@ -1418,7 +1418,7 @@ MonthYearRule::MonthYearRule(const TQString& freqText, const TQString& freqWhats
 
 	box->setStretchFactor(new TQWidget(box), 1);    // left adjust the controls
 	box->setFixedHeight(box->sizeHint().height());
-	connect(mButtonGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(clicked(int)));
+	connect(mButtonGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(clicked(int)));
 }
 
 MonthYearRule::DayPosType MonthYearRule::type() const
@@ -1567,7 +1567,7 @@ YearlyRule::YearlyRule(bool readOnly, TQWidget* parent, const char* name)
 		mMonthBox[i]->setReadOnly(readOnly);
 		grid->addWidget(mMonthBox[i], i%3, i/3, TQt::AlignAuto);
 	}
-	connect(mMonthBox[1], TQT_SIGNAL(toggled(bool)), TQT_SLOT(enableFeb29()));
+	connect(mMonthBox[1], TQ_SIGNAL(toggled(bool)), TQ_SLOT(enableFeb29()));
 	w->setFixedHeight(w->sizeHint().height());
 	TQWhatsThis::add(w, i18n("Select the months of the year in which to repeat the alarm"));
 
diff --git a/kalarm/reminder.cpp b/kalarm/reminder.cpp
index dd4b41510..7f327a859 100644
--- a/kalarm/reminder.cpp
+++ b/kalarm/reminder.cpp
@@ -52,7 +52,7 @@ Reminder::Reminder(const TQString& caption, const TQString& reminderWhatsThis, c
 	mTime = new TimeSelector(caption, i18n("in advance"), reminderWhatsThis,
 	                       valueWhatsThis, allowHourMinute, this, "timeOption");
 	mTime->setFixedSize(mTime->sizeHint());
-	connect(mTime, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotReminderToggled(bool)));
+	connect(mTime, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotReminderToggled(bool)));
 	topLayout->addWidget(mTime);
 
 	if (showOnceOnly)
diff --git a/kalarm/repetition.cpp b/kalarm/repetition.cpp
index 4305cd651..8a964eacd 100644
--- a/kalarm/repetition.cpp
+++ b/kalarm/repetition.cpp
@@ -52,7 +52,7 @@ RepetitionButton::RepetitionButton(const TQString& caption, bool waitForInitiali
 {
 	setToggleButton(true);
 	setOn(false);
-	connect(this, TQT_SIGNAL(clicked()), TQT_SLOT(slotPressed()));
+	connect(this, TQ_SIGNAL(clicked()), TQ_SLOT(slotPressed()));
 }
 
 void RepetitionButton::set(int interval, int count)
@@ -166,12 +166,12 @@ RepetitionDlg::RepetitionDlg(const TQString& caption, bool readOnly, TQWidget* p
 	                  i18n("Enter the time between repetitions of the alarm"),
 	                  true, page);
 	mTimeSelector->setFixedSize(mTimeSelector->sizeHint());
-	connect(mTimeSelector, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(intervalChanged(int)));
-	connect(mTimeSelector, TQT_SIGNAL(toggled(bool)), TQT_SLOT(repetitionToggled(bool)));
+	connect(mTimeSelector, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(intervalChanged(int)));
+	connect(mTimeSelector, TQ_SIGNAL(toggled(bool)), TQ_SLOT(repetitionToggled(bool)));
 	topLayout->addWidget(mTimeSelector, 0, TQt::AlignAuto);
 
 	mButtonGroup = new ButtonGroup(page, "buttonGroup");
-	connect(mButtonGroup, TQT_SIGNAL(buttonSet(int)), TQT_SLOT(typeClicked()));
+	connect(mButtonGroup, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(typeClicked()));
 	topLayout->addWidget(mButtonGroup);
 
 	TQBoxLayout* vlayout = new TQVBoxLayout(mButtonGroup, marginHint(), spacing);
@@ -185,7 +185,7 @@ RepetitionDlg::RepetitionDlg(const TQString& caption, bool readOnly, TQWidget* p
 	mCount->setFixedSize(mCount->sizeHint());
 	mCount->setLineShiftStep(10);
 	mCount->setSelectOnStep(false);
-	connect(mCount, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(countChanged(int)));
+	connect(mCount, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(countChanged(int)));
 	TQWhatsThis::add(mCount,
 	      i18n("Enter the number of times to trigger the alarm after its initial occurrence"));
 	layout->addWidget(mCount);
@@ -200,7 +200,7 @@ RepetitionDlg::RepetitionDlg(const TQString& caption, bool readOnly, TQWidget* p
 	layout->addWidget(mDurationButton);
 	mDuration = new TimePeriod(true, mButtonGroup);
 	mDuration->setFixedSize(mDuration->sizeHint());
-	connect(mDuration, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(durationChanged(int)));
+	connect(mDuration, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(durationChanged(int)));
 	TQWhatsThis::add(mDuration,
 	      i18n("Enter the length of time to repeat the alarm"));
 	layout->addWidget(mDuration);
diff --git a/kalarm/sounddlg.cpp b/kalarm/sounddlg.cpp
index d7dc77383..a94bb6fe8 100644
--- a/kalarm/sounddlg.cpp
+++ b/kalarm/sounddlg.cpp
@@ -86,7 +86,7 @@ SoundDlg::SoundDlg(const TQString& file, float volume, float fadeVolume, int fad
 	mFilePlay = new TQPushButton(box);
 	mFilePlay->setPixmap(SmallIcon("media-playback-start"));
 	mFilePlay->setFixedSize(mFilePlay->sizeHint());
-	connect(mFilePlay, TQT_SIGNAL(clicked()), TQT_SLOT(playSound()));
+	connect(mFilePlay, TQ_SIGNAL(clicked()), TQ_SLOT(playSound()));
 	TQToolTip::add(mFilePlay, i18n("Test the sound"));
 	TQWhatsThis::add(mFilePlay, i18n("Play the selected sound file."));
 
@@ -99,7 +99,7 @@ SoundDlg::SoundDlg(const TQString& file, float volume, float fadeVolume, int fad
 	mFileBrowseButton = new PushButton(box);
 	mFileBrowseButton->setPixmap(SmallIcon("document-open"));
 	mFileBrowseButton->setFixedSize(mFileBrowseButton->sizeHint());
-	connect(mFileBrowseButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotPickFile()));
+	connect(mFileBrowseButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotPickFile()));
 	TQToolTip::add(mFileBrowseButton, i18n("Choose a file"));
 	TQWhatsThis::add(mFileBrowseButton, i18n("Select a sound file to play."));
 
@@ -128,7 +128,7 @@ SoundDlg::SoundDlg(const TQString& file, float volume, float fadeVolume, int fad
 	grid->addMultiCellWidget(box, 1, 1, 0, 2);
 	mVolumeCheckbox = new CheckBox(i18n_v_SetVolume(), box);
 	mVolumeCheckbox->setFixedSize(mVolumeCheckbox->sizeHint());
-	connect(mVolumeCheckbox, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotVolumeToggled(bool)));
+	connect(mVolumeCheckbox, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotVolumeToggled(bool)));
 	TQWhatsThis::add(mVolumeCheckbox,
 	      i18n("Select to choose the volume for playing the sound file."));
 
@@ -143,7 +143,7 @@ SoundDlg::SoundDlg(const TQString& file, float volume, float fadeVolume, int fad
 	// Fade checkbox
 	mFadeCheckbox = new CheckBox(i18n("Fade"), group);
 	mFadeCheckbox->setFixedSize(mFadeCheckbox->sizeHint());
-	connect(mFadeCheckbox, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotFadeToggled(bool)));
+	connect(mFadeCheckbox, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotFadeToggled(bool)));
 	TQWhatsThis::add(mFadeCheckbox,
 	      i18n("Select to fade the volume when the sound file first starts to play."));
 	grid->addMultiCellWidget(mFadeCheckbox, 2, 2, 1, 2, alignment);
@@ -303,7 +303,7 @@ void SoundDlg::playSound()
 		return;
 	}
 	mPlayTimer = new TQTimer(this);
-	connect(mPlayTimer, TQT_SIGNAL(timeout()), TQT_SLOT(checkAudioPlay()));
+	connect(mPlayTimer, TQ_SIGNAL(timeout()), TQ_SLOT(checkAudioPlay()));
 	mArtsDispatcher = new KArtsDispatcher;
 	mPlayStarted = false;
 	KArtsServer aserver;
@@ -313,7 +313,7 @@ void SoundDlg::playSound()
 	mFilePlay->setPixmap(SmallIcon("media-playback-stop"));
 	TQToolTip::add(mFilePlay, i18n("Stop sound"));
 	TQWhatsThis::add(mFilePlay, i18n("Stop playing the sound"));
-	connect(mPlayObject, TQT_SIGNAL(playObjectCreated()), TQT_SLOT(checkAudioPlay()));
+	connect(mPlayObject, TQ_SIGNAL(playObjectCreated()), TQ_SLOT(checkAudioPlay()));
 	if (!mPlayObject->object().isNull())
 		checkAudioPlay();
 #endif
diff --git a/kalarm/soundpicker.cpp b/kalarm/soundpicker.cpp
index 947e9fb91..d9e431902 100644
--- a/kalarm/soundpicker.cpp
+++ b/kalarm/soundpicker.cpp
@@ -74,7 +74,7 @@ SoundPicker::SoundPicker(TQWidget* parent, const char* name)
 	mTypeCombo->insertItem(i18n_File());     // index PLAY_FILE
 	mSpeakShowing = !theApp()->speechEnabled();
 	showSpeak(!mSpeakShowing);               // index SPEAK (only displayed if appropriate)
-	connect(mTypeCombo, TQT_SIGNAL(activated(int)), TQT_SLOT(slotTypeSelected(int)));
+	connect(mTypeCombo, TQ_SIGNAL(activated(int)), TQ_SLOT(slotTypeSelected(int)));
 	label->setBuddy(mTypeCombo);
 	soundLayout->addWidget(mTypeBox);
 
@@ -82,7 +82,7 @@ SoundPicker::SoundPicker(TQWidget* parent, const char* name)
 	mFilePicker = new PushButton(this);
 	mFilePicker->setPixmap(SmallIcon("playsound"));
 	mFilePicker->setFixedSize(mFilePicker->sizeHint());
-	connect(mFilePicker, TQT_SIGNAL(clicked()), TQT_SLOT(slotPickFile()));
+	connect(mFilePicker, TQ_SIGNAL(clicked()), TQ_SLOT(slotPickFile()));
 	TQToolTip::add(mFilePicker, i18n("Configure sound file"));
 	TQWhatsThis::add(mFilePicker, i18n("Configure a sound file to play when the alarm is displayed."));
 	soundLayout->addWidget(mFilePicker);
diff --git a/kalarm/specialactions.cpp b/kalarm/specialactions.cpp
index fd4b7a7d5..f2599e356 100644
--- a/kalarm/specialactions.cpp
+++ b/kalarm/specialactions.cpp
@@ -46,7 +46,7 @@ SpecialActionsButton::SpecialActionsButton(const TQString& caption, TQWidget* pa
 {
 	setToggleButton(true);
 	setOn(false);
-	connect(this, TQT_SIGNAL(clicked()), TQT_SLOT(slotButtonPressed()));
+	connect(this, TQ_SIGNAL(clicked()), TQ_SLOT(slotButtonPressed()));
 	TQWhatsThis::add(this,
 	      i18n("Specify actions to execute before and after the alarm is displayed."));
 }
diff --git a/kalarm/startdaytimer.cpp b/kalarm/startdaytimer.cpp
index 84f0096ce..ef8ddf867 100644
--- a/kalarm/startdaytimer.cpp
+++ b/kalarm/startdaytimer.cpp
@@ -29,7 +29,7 @@ StartOfDayTimer* StartOfDayTimer::mInstance = 0;
 StartOfDayTimer::StartOfDayTimer()
 	: DailyTimer(Preferences::startOfDay(), false)
 {
-	Preferences::connect(TQT_SIGNAL(startOfDayChanged(const TQTime&)), this, TQT_SLOT(startOfDayChanged(const TQTime&)));
+	Preferences::connect(TQ_SIGNAL(startOfDayChanged(const TQTime&)), this, TQ_SLOT(startOfDayChanged(const TQTime&)));
 }
 
 StartOfDayTimer* StartOfDayTimer::instance()
diff --git a/kalarm/templatedlg.cpp b/kalarm/templatedlg.cpp
index 7627b8d1e..ebf7f1c6a 100644
--- a/kalarm/templatedlg.cpp
+++ b/kalarm/templatedlg.cpp
@@ -54,34 +54,34 @@ TemplateDlg::TemplateDlg(TQWidget* parent, const char* name)
 	mTemplateList = new TemplateListView(true, i18n("The list of alarm templates"), topWidget);
 	mTemplateList->setSelectionMode(TQListView::Extended);
 	mTemplateList->setSizePolicy(TQSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding));
-	connect(mTemplateList, TQT_SIGNAL(selectionChanged()), TQT_SLOT(slotSelectionChanged()));
+	connect(mTemplateList, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelectionChanged()));
 	layout->addWidget(mTemplateList);
 
 	layout = new TQVBoxLayout(topLayout);
 	TQPushButton* button = new TQPushButton(i18n("&New..."), topWidget);
-	connect(button, TQT_SIGNAL(clicked()), TQT_SLOT(slotNew()));
+	connect(button, TQ_SIGNAL(clicked()), TQ_SLOT(slotNew()));
 	TQWhatsThis::add(button, i18n("Create a new alarm template"));
 	layout->addWidget(button);
 
 	mEditButton = new TQPushButton(i18n("&Edit..."), topWidget);
-	connect(mEditButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotEdit()));
+	connect(mEditButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotEdit()));
 	TQWhatsThis::add(mEditButton, i18n("Edit the currently highlighted alarm template"));
 	layout->addWidget(mEditButton);
 
 	mCopyButton = new TQPushButton(i18n("Co&py"), topWidget);
-	connect(mCopyButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotCopy()));
+	connect(mCopyButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotCopy()));
 	TQWhatsThis::add(mCopyButton,
 	      i18n("Create a new alarm template based on a copy of the currently highlighted template"));
 	layout->addWidget(mCopyButton);
 
 	mDeleteButton = new TQPushButton(i18n("&Delete"), topWidget);
-	connect(mDeleteButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotDelete()));
+	connect(mDeleteButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotDelete()));
 	TQWhatsThis::add(mDeleteButton, i18n("Delete the currently highlighted alarm template"));
 	layout->addWidget(mDeleteButton);
 
 	TDEAccel* accel = new TDEAccel(this);
-	accel->insert(TDEStdAccel::SelectAll, mTemplateList, TQT_SLOT(slotSelectAll()));
-	accel->insert(TDEStdAccel::Deselect, mTemplateList, TQT_SLOT(slotDeselect()));
+	accel->insert(TDEStdAccel::SelectAll, mTemplateList, TQ_SLOT(slotSelectAll()));
+	accel->insert(TDEStdAccel::Deselect, mTemplateList, TQ_SLOT(slotDeselect()));
 	accel->readSettings();
 
 	mTemplateList->refresh();
diff --git a/kalarm/templatemenuaction.cpp b/kalarm/templatemenuaction.cpp
index 5da72a6d5..1bcabf120 100644
--- a/kalarm/templatemenuaction.cpp
+++ b/kalarm/templatemenuaction.cpp
@@ -35,9 +35,9 @@ TemplateMenuAction::TemplateMenuAction(const TQString& label, const TQString& ic
 	: TDEActionMenu(label, icon, actions, name)
 {
 	setDelayed(false);
-	connect(popupMenu(), TQT_SIGNAL(aboutToShow()), TQT_SLOT(slotInitMenu()));
-	connect(popupMenu(), TQT_SIGNAL(activated(int)), TQT_SLOT(slotSelected(int)));
-	connect(this, TQT_SIGNAL(selected(const KAEvent&)), receiver, slot);
+	connect(popupMenu(), TQ_SIGNAL(aboutToShow()), TQ_SLOT(slotInitMenu()));
+	connect(popupMenu(), TQ_SIGNAL(activated(int)), TQ_SLOT(slotSelected(int)));
+	connect(this, TQ_SIGNAL(selected(const KAEvent&)), receiver, slot);
 }
 
 /******************************************************************************
diff --git a/kalarm/templatepickdlg.cpp b/kalarm/templatepickdlg.cpp
index b3bc44886..9acd8fb8f 100644
--- a/kalarm/templatepickdlg.cpp
+++ b/kalarm/templatepickdlg.cpp
@@ -46,9 +46,9 @@ TemplatePickDlg::TemplatePickDlg(TQWidget* parent, const char* name)
 	mTemplateList = new TemplateListView(includeCmdAlarms, i18n("Select a template to base the new alarm on."), topWidget, "list");
 	mTemplateList->setSelectionMode(TQListView::Single);
 	mTemplateList->refresh();      // populate the template list
-	connect(mTemplateList, TQT_SIGNAL(selectionChanged()), TQT_SLOT(slotSelectionChanged()));
+	connect(mTemplateList, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelectionChanged()));
 	// Require a real double click (even if KDE is in single-click mode) to accept the selection
-	connect(mTemplateList, TQT_SIGNAL(doubleClicked(TQListViewItem*, const TQPoint&, int)), TQT_SLOT(slotOk()));
+	connect(mTemplateList, TQ_SIGNAL(doubleClicked(TQListViewItem*, const TQPoint&, int)), TQ_SLOT(slotOk()));
 	topLayout->addWidget(mTemplateList);
 
 	slotSelectionChanged();        // enable or disable the OK button
diff --git a/kalarm/timeselector.cpp b/kalarm/timeselector.cpp
index de7ef828d..710152b45 100644
--- a/kalarm/timeselector.cpp
+++ b/kalarm/timeselector.cpp
@@ -44,7 +44,7 @@ TimeSelector::TimeSelector(const TQString& selectText, const TQString& postfix,
 	TQHBoxLayout* layout = new TQHBoxLayout(topLayout, KDialog::spacingHint());
 	mSelect = new CheckBox(selectText, this);
 	mSelect->setFixedSize(mSelect->sizeHint());
-	connect(mSelect, TQT_SIGNAL(toggled(bool)), TQT_SLOT(selectToggled(bool)));
+	connect(mSelect, TQ_SIGNAL(toggled(bool)), TQ_SLOT(selectToggled(bool)));
 	TQWhatsThis::add(mSelect, selectWhatsThis);
 	layout->addWidget(mSelect);
 
@@ -54,7 +54,7 @@ TimeSelector::TimeSelector(const TQString& selectText, const TQString& postfix,
 	mPeriod = new TimePeriod(allowHourMinute, box);
 	mPeriod->setFixedSize(mPeriod->sizeHint());
 	mPeriod->setSelectOnStep(false);
-	connect(mPeriod, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(periodChanged(int)));
+	connect(mPeriod, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(periodChanged(int)));
 	mSelect->setFocusWidget(mPeriod);
 	mPeriod->setEnabled(false);
 
diff --git a/kalarm/traywindow.cpp b/kalarm/traywindow.cpp
index 81eb4a066..90bd92edd 100644
--- a/kalarm/traywindow.cpp
+++ b/kalarm/traywindow.cpp
@@ -87,16 +87,16 @@ TrayWindow::TrayWindow(MainWindow* parent, const char* name)
 	TDEActionCollection* actcol = actionCollection();
 	AlarmEnableAction* a = Daemon::createAlarmEnableAction(actcol, "tAlarmEnable");
 	a->plug(contextMenu());
-	connect(a, TQT_SIGNAL(switched(bool)), TQT_SLOT(setEnabledStatus(bool)));
-	KAlarm::createNewAlarmAction(i18n("&New Alarm..."), this, TQT_SLOT(slotNewAlarm()), actcol, "tNew")->plug(contextMenu());
-	KAlarm::createNewFromTemplateAction(i18n("New Alarm From &Template"), this, TQT_SLOT(slotNewFromTemplate(const KAEvent&)), actcol, "tNewFromTempl")->plug(contextMenu());
-	KStdAction::preferences(this, TQT_SLOT(slotPreferences()), actcol)->plug(contextMenu());
+	connect(a, TQ_SIGNAL(switched(bool)), TQ_SLOT(setEnabledStatus(bool)));
+	KAlarm::createNewAlarmAction(i18n("&New Alarm..."), this, TQ_SLOT(slotNewAlarm()), actcol, "tNew")->plug(contextMenu());
+	KAlarm::createNewFromTemplateAction(i18n("New Alarm From &Template"), this, TQ_SLOT(slotNewFromTemplate(const KAEvent&)), actcol, "tNewFromTempl")->plug(contextMenu());
+	KStdAction::preferences(this, TQ_SLOT(slotPreferences()), actcol)->plug(contextMenu());
 
 	// Replace the default handler for the Quit context menu item
 	const char* quitName = KStdAction::name(KStdAction::Quit);
 	actcol->remove(actcol->action(quitName));
 	actcol->tdeaccel()->remove(quitName);
-	KStdAction::quit(this, TQT_SLOT(slotQuit()), actcol);
+	KStdAction::quit(this, TQ_SLOT(slotQuit()), actcol);
 
 	// Set icon to correspond with the alarms enabled menu status
 	Daemon::checkStatus();