Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/252/head
Michele Calgaro 1 year ago
parent 5d320b587b
commit ba3b5b77e1
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF

@ -155,9 +155,9 @@ not be available.
<li> TDEAccel::insertItem() and TDEAccel::connectItem().
<pre>
- tdeaccel-&gt;insertItem( i18n("Scroll Up"), "Scroll Up", "Up" );
- tdeaccel-&gt;connectItem( "Scroll Up", this, TQT_SLOT(scrollUp()) );
- tdeaccel-&gt;connectItem( "Scroll Up", this, TQ_SLOT(scrollUp()) );
+ tdeaccel-&gt;insert( "Scroll Up", i18n("Scroll Up"), TQString::null,
Key_Up, this, TQT_SLOT(scrollUp()) );
Key_Up, this, TQ_SLOT(scrollUp()) );
</pre>
Note that a What's This parameter is now a part of the insert function.
You might replace the TQString::null parameter with
@ -176,7 +176,7 @@ not be available.
The preferred means of defining a shortcut, however, is to use <b>TDEAction</b>.
<pre>
new TDEAction( i18n("Scroll Up"), Key_Up,
this, TQT_SLOT(scrollUp()), actionCollection(), "Scroll Up" );
this, TQ_SLOT(scrollUp()), actionCollection(), "Scroll Up" );
</pre>
<h5>TDEGlobalAccel</h5>

@ -44,7 +44,7 @@ namespace Arts { class KFloatWatchProxy_impl; }
* \code
* StereoVolumeControl stereoVolumeControl = ...;
* KArtsFloatWatch *w = new KArtsFloatWatch(stereoVolumeControl, "scaleFactor_changed", this);
* connect(w, TQT_SIGNAL(valueChanged(float)), this, TQT_SLOT(setValue(float)));
* connect(w, TQ_SIGNAL(valueChanged(float)), this, TQ_SLOT(setValue(float)));
* \endcode
*/
class KArtsFloatWatch : public TQObject {

@ -88,7 +88,7 @@ void KAudioConverter::requestPlayObject(const KURL &url)
Arts::TDEIOInputStream_impl *inputStreamImpl = new Arts::TDEIOInputStream_impl();
inputStream = Arts::TDEIOInputStream::_from_base(inputStreamImpl);
TQObject::connect(inputStreamImpl, TQT_SIGNAL(mimeTypeFound(const TQString &)), TQT_SLOT(slotMimeType(const TQString &)));
TQObject::connect(inputStreamImpl, TQ_SIGNAL(mimeTypeFound(const TQString &)), TQ_SLOT(slotMimeType(const TQString &)));
inputStream.openURL(url.url().latin1());
inputStream.streamStart();
@ -161,9 +161,9 @@ void KAudioConverter::start()
Arts::connect(m_incoming->object(), "left", m_request, "left");
Arts::connect(m_incoming->object(), "right", m_request, "right");
TQObject::connect(requestImpl, TQT_SIGNAL(newBlockSize(long)), TQT_SIGNAL(newBlockSize(long)));
TQObject::connect(requestImpl, TQT_SIGNAL(newBlockPointer(long)), TQT_SIGNAL(newBlockPointer(long)));
TQObject::connect(requestImpl, TQT_SIGNAL(newData()), TQT_SIGNAL(newData()));
TQObject::connect(requestImpl, TQ_SIGNAL(newBlockSize(long)), TQ_SIGNAL(newBlockSize(long)));
TQObject::connect(requestImpl, TQ_SIGNAL(newBlockPointer(long)), TQ_SIGNAL(newBlockPointer(long)));
TQObject::connect(requestImpl, TQ_SIGNAL(newData()), TQ_SIGNAL(newData()));
// Special mpeglib case
// TODO: needed at all??

@ -66,7 +66,7 @@ KAudioRecordStream::KAudioRecordStream( KArtsServer * kserver, const TQString &
d->inqueue.setAutoDelete( true );
d->title = title;
connect( d->kserver, TQT_SIGNAL( restartedServer() ), TQT_SLOT( slotRestartedServer() ) );
connect( d->kserver, TQ_SIGNAL( restartedServer() ), TQ_SLOT( slotRestartedServer() ) );
d->in = Arts::DynamicCast( d->kserver->server().createObject( "Arts::Synth_AMAN_RECORD" ) );
d->effectStack = Arts::DynamicCast( d->kserver->server().createObject( "Arts::StereoEffectStack" ) );
@ -196,8 +196,8 @@ void KAudioRecordStream::start( int samplingRate, int bits, int channels )
d->receiver_base = new KByteSoundReceiver( samplingRate, bits, channels, d->title.local8Bit() );
d->receiver = Arts::ByteSoundReceiver::_from_base( d->receiver_base );
connect( d->receiver_base, TQT_SIGNAL( data( const char *, unsigned int ) ),
TQT_SLOT( slotData( const char *, unsigned int ) ) );
connect( d->receiver_base, TQ_SIGNAL( data( const char *, unsigned int ) ),
TQ_SLOT( slotData( const char *, unsigned int ) ) );
Arts::connect( d->convert, "outdata", d->receiver, "indata" );
d->convert.start();

@ -81,13 +81,13 @@ int main(int argc, char **argv)
// converter.setup(44100);
converter.requestPlayObject(url);
TQObject::connect(&converter, TQT_SIGNAL(rawStreamStart()), get, TQT_SLOT(slotRawStreamStart()));
TQObject::connect(&converter, TQ_SIGNAL(rawStreamStart()), get, TQ_SLOT(slotRawStreamStart()));
TQObject::connect(&converter, TQT_SIGNAL(newBlockSize(long)), get, TQT_SLOT(slotNewBlockSize(long)));
TQObject::connect(&converter, TQT_SIGNAL(newBlockPointer(long)), get, TQT_SLOT(slotNewBlockPointer(long)));
TQObject::connect(&converter, TQT_SIGNAL(newData()), get, TQT_SLOT(slotNewData()));
TQObject::connect(&converter, TQ_SIGNAL(newBlockSize(long)), get, TQ_SLOT(slotNewBlockSize(long)));
TQObject::connect(&converter, TQ_SIGNAL(newBlockPointer(long)), get, TQ_SLOT(slotNewBlockPointer(long)));
TQObject::connect(&converter, TQ_SIGNAL(newData()), get, TQ_SLOT(slotNewData()));
TQObject::connect(&converter, TQT_SIGNAL(rawStreamFinished()), get, TQT_SLOT(slotRawStreamFinished()));
TQObject::connect(&converter, TQ_SIGNAL(rawStreamFinished()), get, TQ_SLOT(slotRawStreamFinished()));
converter.start();

@ -80,14 +80,14 @@ void TDEIOInputStream_impl::streamStart()
m_job->addMetaData("accept", "audio/x-mp3, video/mpeg, application/ogg");
m_job->addMetaData("UserAgent", TQString::fromLatin1("aRts/") + TQString::fromLatin1(ARTS_VERSION));
TQObject::connect(m_job, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(slotData(TDEIO::Job *, const TQByteArray &)));
TQObject::connect(m_job, TQT_SIGNAL(result(TDEIO::Job *)),
this, TQT_SLOT(slotResult(TDEIO::Job *)));
TQObject::connect(m_job, TQT_SIGNAL(mimetype(TDEIO::Job *, const TQString &)),
this, TQT_SLOT(slotScanMimeType(TDEIO::Job *, const TQString &)));
TQObject::connect(m_job, TQT_SIGNAL(totalSize( TDEIO::Job *, TDEIO::filesize_t)),
this, TQT_SLOT(slotTotalSize(TDEIO::Job *, TDEIO::filesize_t)));
TQObject::connect(m_job, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(slotData(TDEIO::Job *, const TQByteArray &)));
TQObject::connect(m_job, TQ_SIGNAL(result(TDEIO::Job *)),
this, TQ_SLOT(slotResult(TDEIO::Job *)));
TQObject::connect(m_job, TQ_SIGNAL(mimetype(TDEIO::Job *, const TQString &)),
this, TQ_SLOT(slotScanMimeType(TDEIO::Job *, const TQString &)));
TQObject::connect(m_job, TQ_SIGNAL(totalSize( TDEIO::Job *, TDEIO::filesize_t)),
this, TQ_SLOT(slotTotalSize(TDEIO::Job *, TDEIO::filesize_t)));
m_streamStarted = true;
}
@ -98,14 +98,14 @@ void TDEIOInputStream_impl::streamEnd()
if(m_job != 0)
{
TQObject::disconnect(m_job, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(slotData(TDEIO::Job *, const TQByteArray &)));
TQObject::disconnect(m_job, TQT_SIGNAL(result(TDEIO::Job *)),
this, TQT_SLOT(slotResult(TDEIO::Job *)));
TQObject::disconnect(m_job, TQT_SIGNAL(mimetype(TDEIO::Job *, const TQString &)),
this, TQT_SLOT(slotScanMimeType(TDEIO::Job *, const TQString &)));
TQObject::disconnect(m_job, TQT_SIGNAL(totalSize( TDEIO::Job *, TDEIO::filesize_t)),
this, TQT_SLOT(slotTotalSize(TDEIO::Job *, TDEIO::filesize_t)));
TQObject::disconnect(m_job, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(slotData(TDEIO::Job *, const TQByteArray &)));
TQObject::disconnect(m_job, TQ_SIGNAL(result(TDEIO::Job *)),
this, TQ_SLOT(slotResult(TDEIO::Job *)));
TQObject::disconnect(m_job, TQ_SIGNAL(mimetype(TDEIO::Job *, const TQString &)),
this, TQ_SLOT(slotScanMimeType(TDEIO::Job *, const TQString &)));
TQObject::disconnect(m_job, TQ_SIGNAL(totalSize( TDEIO::Job *, TDEIO::filesize_t)),
this, TQ_SLOT(slotTotalSize(TDEIO::Job *, TDEIO::filesize_t)));
if ( m_streamPulled )
outdata.endPull();

@ -179,7 +179,7 @@ void KDE::PlayObject::play()
if ( d->creator )
delete d->creator;
d->creator = new KDE::PlayObjectCreator( d->server );
d->creator->create( d->url, d->createBUS, this, TQT_SLOT( attachPlayObject( Arts::PlayObject ) ) );
d->creator->create( d->url, d->createBUS, this, TQ_SLOT( attachPlayObject( Arts::PlayObject ) ) );
kdDebug( 400 ) << "KDE::PlayObject::play(): creator called" << endl;
d->internalState = Arts::posPlaying;
}

@ -44,7 +44,7 @@ bool KDE::PlayObjectCreator::create(const KURL& url, bool createBUS, const TQObj
if (m_server.isNull() || url.isEmpty() )
return false;
connect( this, TQT_SIGNAL( playObjectCreated( Arts::PlayObject ) ),
connect( this, TQ_SIGNAL( playObjectCreated( Arts::PlayObject ) ),
receiver, slot );
// check if the URL is a local file
@ -57,8 +57,8 @@ bool KDE::PlayObjectCreator::create(const KURL& url, bool createBUS, const TQObj
m_instream = Arts::TDEIOInputStream::_from_base(instream_impl);
// signal will be called once the ioslave knows the mime-type of the stream
connect(instream_impl, TQT_SIGNAL(mimeTypeFound(const TQString &)),
this, TQT_SLOT(slotMimeType(const TQString &)));
connect(instream_impl, TQ_SIGNAL(mimeTypeFound(const TQString &)),
this, TQ_SLOT(slotMimeType(const TQString &)));
// GO!
m_instream.openURL(url.url().latin1());

@ -179,7 +179,7 @@ KDE::PlayObject *KDE::PlayObjectFactory::createPlayObject(const KURL& _url, cons
d->helper->po = d->playObj;
d->helper->ap = d->amanPlay;
if( d->playObj->object().isNull() && d->amanPlay )
TQObject::connect( d->playObj, TQT_SIGNAL( playObjectCreated() ), d->helper, TQT_SLOT( connectAmanPlay() ) );
TQObject::connect( d->playObj, TQ_SIGNAL( playObjectCreated() ), d->helper, TQ_SLOT( connectAmanPlay() ) );
else
d->helper->connectAmanPlay();
}

@ -102,16 +102,16 @@ void KVideoWidget::init(void)
// Setup actions
new TDEToggleAction( i18n("Fullscreen &Mode"), "view-fullscreen",
CTRL+SHIFT+Key_F, this, TQT_SLOT(fullscreenActivated()),
CTRL+SHIFT+Key_F, this, TQ_SLOT(fullscreenActivated()),
actionCollection(), "fullscreen_mode" );
new TDERadioAction( i18n("&Half Size"), ALT+Key_0,
this, TQT_SLOT(halfSizeActivated()),
this, TQ_SLOT(halfSizeActivated()),
actionCollection(), "half_size" );
new TDERadioAction( i18n("&Normal Size"), ALT+Key_1,
this, TQT_SLOT(normalSizeActivated()),
this, TQ_SLOT(normalSizeActivated()),
actionCollection(), "normal_size" );
new TDERadioAction( i18n("&Double Size"), ALT+Key_2,
this, TQT_SLOT(doubleSizeActivated()),
this, TQ_SLOT(doubleSizeActivated()),
actionCollection(), "double_size" );
((TDEToggleAction *)action( "half_size" ))->setExclusiveGroup( "KVideoWidget::zoom" );
@ -379,20 +379,20 @@ void KVideoWidget::fullscreenActivated()
fullscreenWidget = new KFullscreenVideoWidget( this );
// Interconnect mouse button signals
connect( fullscreenWidget, TQT_SIGNAL(mouseButtonPressed( int, const TQPoint &, int )),
this, TQT_SIGNAL(mouseButtonPressed( int, const TQPoint &, int)) );
connect( fullscreenWidget, TQ_SIGNAL(mouseButtonPressed( int, const TQPoint &, int )),
this, TQ_SIGNAL(mouseButtonPressed( int, const TQPoint &, int)) );
connect( fullscreenWidget, TQT_SIGNAL(mouseButtonDoubleClick( const TQPoint &, int )),
this, TQT_SIGNAL(mouseButtonDoubleClick( const TQPoint &, int )) );
connect( fullscreenWidget, TQ_SIGNAL(mouseButtonDoubleClick( const TQPoint &, int )),
this, TQ_SIGNAL(mouseButtonDoubleClick( const TQPoint &, int )) );
// ### Remove in KDE4
connect( fullscreenWidget, TQT_SIGNAL(rightButtonPressed(const TQPoint &)),
this, TQT_SIGNAL(rightButtonPressed(const TQPoint &)) );
connect( fullscreenWidget, TQ_SIGNAL(rightButtonPressed(const TQPoint &)),
this, TQ_SIGNAL(rightButtonPressed(const TQPoint &)) );
// Leave fullscreen mode with <Escape> key
TQAccel *a = new TQAccel( fullscreenWidget );
a->connectItem( a->insertItem( Key_Escape ),
this, TQT_SLOT(setWindowed()) );
this, TQ_SLOT(setWindowed()) );
fullscreenWidget->setFocus();
fullscreenWidget->showFullScreen();

@ -247,7 +247,7 @@ KNotify::KNotify( bool useArts )
d->playObjects.setAutoDelete(true);
d->audioManager = 0;
if( useArts ) {
connect( soundServer, TQT_SIGNAL( restartedServer() ), this, TQT_SLOT( restartedArtsd() ) );
connect( soundServer, TQ_SIGNAL( restartedServer() ), this, TQ_SLOT( restartedArtsd() ) );
restartedArtsd(); //started allready need to initialize d->audioManager
}
#endif
@ -530,7 +530,7 @@ bool KNotify::notifyBySound( const TQString &sound, const TQString &appname, int
if ( !d->playTimer ) {
d->playTimer = new TQTimer( this );
connect( d->playTimer, TQT_SIGNAL( timeout() ), TQT_SLOT( playTimeout() ) );
connect( d->playTimer, TQ_SIGNAL( timeout() ), TQ_SLOT( playTimeout() ) );
}
if ( !d->playTimer->isActive() ) {
d->playTimer->start( 1000 );
@ -543,7 +543,7 @@ bool KNotify::notifyBySound( const TQString &sound, const TQString &appname, int
TDEProcess *proc = d->externalPlayerProc;
if (!proc) {
proc = d->externalPlayerProc = new TDEProcess;
connect( proc, TQT_SIGNAL( processExited( TDEProcess * )), TQT_SLOT( slotPlayerProcessExited( TDEProcess * )));
connect( proc, TQ_SIGNAL( processExited( TDEProcess * )), TQ_SLOT( slotPlayerProcessExited( TDEProcess * )));
}
if (proc->isRunning()) {
soundFinished( eventId, PlayerBusy );

@ -33,7 +33,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
MyDCOPObject::MyDCOPObject(const TQCString &name, const TQCString &remoteName)
: TQObject(0, name), DCOPObject(name), m_remoteName(remoteName)
{
connect(&m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotTimeout()));
connect(&m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotTimeout()));
}
bool MyDCOPObject::process(const TQCString &fun, const TQByteArray &data,

@ -334,10 +334,10 @@ void DCOPClient::handleAsyncReply(ReplyStruct *replyStruct)
{
if (replyStruct->replyObject)
{
TQObject::connect(this, TQT_SIGNAL(callBack(int, const TQCString&, const TQByteArray &)),
TQObject::connect(this, TQ_SIGNAL(callBack(int, const TQCString&, const TQByteArray &)),
replyStruct->replyObject, replyStruct->replySlot);
emit callBack(replyStruct->replyId, *(replyStruct->replyType), *(replyStruct->replyData));
TQObject::disconnect(this, TQT_SIGNAL(callBack(int, const TQCString&, const TQByteArray &)),
TQObject::disconnect(this, TQ_SIGNAL(callBack(int, const TQCString&, const TQByteArray &)),
replyStruct->replyObject, replyStruct->replySlot);
}
delete replyStruct;
@ -625,8 +625,8 @@ DCOPClient::DCOPClient()
d->qt_bridge_enabled = true;
d->transactionList = 0L;
d->transactionId = 0;
TQObject::connect( &d->postMessageTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( processPostedMessagesInternal() ) );
TQObject::connect( &d->eventLoopTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( eventLoopTimeout() ) );
TQObject::connect( &d->postMessageTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( processPostedMessagesInternal() ) );
TQObject::connect( &d->eventLoopTimer, TQ_SIGNAL( timeout() ), this, TQ_SLOT( eventLoopTimeout() ) );
if ( !mainClient() )
setMainClient( this );
@ -693,8 +693,8 @@ void DCOPClient::bindToApp()
delete d->notifier;
d->notifier = new TQSocketNotifier(socket(),
TQSocketNotifier::Read, 0, 0);
TQObject::connect(d->notifier, TQT_SIGNAL(activated(int)),
TQT_SLOT(processSocketData(int)));
TQObject::connect(d->notifier, TQ_SIGNAL(activated(int)),
TQ_SLOT(processSocketData(int)));
}
}
@ -1856,7 +1856,7 @@ int DCOPClient::callAsync(const TQCString &remApp, const TQCString &remObjId,
if (replyStruct->transactionId == 0)
{
// Call is finished already
TQTimer::singleShot(0, this, TQT_SLOT(asyncReplyReady()));
TQTimer::singleShot(0, this, TQ_SLOT(asyncReplyReady()));
d->asyncReplyQueue.append(replyStruct);
}

@ -306,8 +306,8 @@ tqWarning("[dcopserver] waitForOutputReady fd = %d datasize = %d start = %d", so
if (!outputBufferNotifier)
{
outputBufferNotifier = new TQSocketNotifier(socket(), Write);
connect(outputBufferNotifier, TQT_SIGNAL(activated(int)),
the_server, TQT_SLOT(slotOutputReady(int)));
connect(outputBufferNotifier, TQ_SIGNAL(activated(int)),
the_server, TQ_SLOT(slotOutputReady(int)));
}
outputBufferNotifier->setEnabled(true);
return;
@ -1055,16 +1055,16 @@ DCOPServer::DCOPServer(bool _suicide)
for ( int i = 0; i < numTransports; i++) {
con = new DCOPListener( listenObjs[i] );
listener.append( con );
connect( con, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( newClient(int) ) );
connect( con, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( newClient(int) ) );
}
char c = 0;
write(ready[1], &c, 1); // dcopserver is started
close(ready[1]);
m_timer = new TQTimer(this);
connect( m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotTerminate()) );
connect( m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotTerminate()) );
m_deadConnectionTimer = new TQTimer(this);
connect( m_deadConnectionTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotCleanDeadConnections()) );
connect( m_deadConnectionTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotCleanDeadConnections()) );
#ifdef Q_OS_WIN
char szEventName[256];
@ -1183,7 +1183,7 @@ void DCOPServer::newClient( int /*socket*/ )
void* DCOPServer::watchConnection( IceConn iceConn )
{
DCOPConnection* con = new DCOPConnection( iceConn );
connect( con, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( processData(int) ) );
connect( con, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( processData(int) ) );
clients.insert(iceConn, con );
fd_clients.insert( IceConnectionNumber(iceConn), con);
@ -1293,8 +1293,8 @@ void DCOPServer::slotTerminate()
#endif
TQByteArray data;
dcopSignals->emitSignal(0L /* dcopserver */, "terminateTDE()", data, false);
disconnect( m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotTerminate()) );
connect( m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotSuicide()) );
disconnect( m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotTerminate()) );
connect( m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotSuicide()) );
system(findDcopserverShutdown()+" --nokill");
}
@ -1321,8 +1321,8 @@ void DCOPServer::slotShutdown()
TQByteArray data;
dcopSignals->emitSignal(0L /* dcopserver */, "terminateTDE()", data, false);
m_timer->start( 10000 ); // if within 10 seconds nothing happens, we'll terminate
disconnect( m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotTerminate()) );
connect( m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotExit()) );
disconnect( m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotTerminate()) );
connect( m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotExit()) );
if (appIds.isEmpty())
slotExit(); // Exit now
}
@ -1779,7 +1779,7 @@ extern "C" DCOP_EXPORT int kdemain( int argc, char* argv[] )
SetConsoleCtrlHandler(DCOPServer::dcopServerConsoleProc,TRUE);
#else
TQSocketNotifier DEATH(pipeOfDeath[0], TQSocketNotifier::Read, 0, 0);
server->connect(&DEATH, TQT_SIGNAL(activated(int)), TQT_SLOT(slotShutdown()));
server->connect(&DEATH, TQ_SIGNAL(activated(int)), TQ_SLOT(slotShutdown()));
#endif
int ret = a.exec();

@ -84,13 +84,13 @@ tqDebug("countDown() countDownAction = %p", countDownAction);
{
countDownCount = 10;
countDownAction = client->beginTransaction();
TQTimer::singleShot(1000, this, TQT_SLOT(slotTimeout()));
TQTimer::singleShot(1000, this, TQ_SLOT(slotTimeout()));
}
else
{
countDownCount2 = 10;
countDownAction2 = client->beginTransaction();
TQTimer::singleShot(1000, this, TQT_SLOT(slotTimeout2()));
TQTimer::singleShot(1000, this, TQ_SLOT(slotTimeout2()));
}
return true;
}
@ -113,7 +113,7 @@ void MyDCOPObject::slotTimeout()
}
else
{
TQTimer::singleShot(1000, this, TQT_SLOT(slotTimeout()));
TQTimer::singleShot(1000, this, TQ_SLOT(slotTimeout()));
}
}
@ -132,7 +132,7 @@ void MyDCOPObject::slotTimeout2()
}
else
{
TQTimer::singleShot(1000, this, TQT_SLOT(slotTimeout2()));
TQTimer::singleShot(1000, this, TQ_SLOT(slotTimeout2()));
}
}
@ -146,7 +146,7 @@ QCStringList MyDCOPObject::functions()
TestObject::TestObject(const TQCString& app)
: m_app(app)
{
TQTimer::singleShot(2500, this, TQT_SLOT(slotTimeout()));
TQTimer::singleShot(2500, this, TQ_SLOT(slotTimeout()));
}
void TestObject::slotTimeout()
@ -191,10 +191,10 @@ int main(int argc, char **argv)
TQCString appId = argv[1];
TestObject obj(appId);
tqWarning("#1 Calling countDown");
int result = client->callAsync(appId, "object1", "countDown()", data, &obj, TQT_SLOT(slotCallBack(int, const TQCString&, const TQByteArray&)));
int result = client->callAsync(appId, "object1", "countDown()", data, &obj, TQ_SLOT(slotCallBack(int, const TQCString&, const TQByteArray&)));
tqDebug("#1 countDown() call id = %d", result);
tqWarning("#2 Calling countDown");
result = client->callAsync(appId, "object1", "countDown()", data, &obj, TQT_SLOT(slotCallBack(int, const TQCString&, const TQByteArray&)));
result = client->callAsync(appId, "object1", "countDown()", data, &obj, TQ_SLOT(slotCallBack(int, const TQCString&, const TQByteArray&)));
tqDebug("#2 countDown() call id = %d", result);
app.exec();
@ -234,11 +234,11 @@ int main(int argc, char **argv)
int n = client->registeredApplications().count();
tqDebug("number of attached applications = %d", n );
TQObject::connect( client, TQT_SIGNAL( applicationRegistered( const TQCString&)),
obj1, TQT_SLOT( registered( const TQCString& )));
TQObject::connect( client, TQ_SIGNAL( applicationRegistered( const TQCString&)),
obj1, TQ_SLOT( registered( const TQCString& )));
TQObject::connect( client, TQT_SIGNAL( applicationRemoved( const TQCString&)),
obj1, TQT_SLOT( unregistered( const TQCString& )));
TQObject::connect( client, TQ_SIGNAL( applicationRemoved( const TQCString&)),
obj1, TQ_SLOT( unregistered( const TQCString& )));
// Enable the above signals
client->setNotifications( true );

@ -39,7 +39,7 @@ void Driver::test()
}
++count;
TQTimer::singleShot( 100, this, TQT_SLOT( test() ) );
TQTimer::singleShot( 100, this, TQ_SLOT( test() ) );
}
#include "driver.moc"
@ -58,7 +58,7 @@ int main(int argc, char** argv)
app.dcopClient()->attach( );
app.dcopClient()->registerAs( "TestAppDriver" );
Driver * object = new Driver( appname );
TQTimer::singleShot( 10, object, TQT_SLOT( test() ) );
TQTimer::singleShot( 10, object, TQ_SLOT( test() ) );
return app.exec();
}

@ -86,8 +86,8 @@ DomainBrowser::DomainBrowser(TQObject *parent) : TQObject(parent)
d->m_domains+="local.";
d->m_browseLAN=true;
}
connect(TDEApplication::kApplication(),TQT_SIGNAL(kipcMessage(int,int)),this,
TQT_SLOT(domainListChanged(int,int)));
connect(TDEApplication::kApplication(),TQ_SIGNAL(kipcMessage(int,int)),this,
TQ_SLOT(domainListChanged(int,int)));
}
DomainBrowser::DomainBrowser(const TQStringList& domains, bool recursive, TQObject *parent) : TQObject(parent)

@ -82,7 +82,7 @@ PublicService::PublicService(const TQString& name, const TQString& type, unsigne
#ifdef HAVE_DNSSD
if (Responder::self().client()) {
d->m_group = avahi_entry_group_new(Responder::self().client(), publish_callback,this);
connect(&Responder::self(),TQT_SIGNAL(stateChanged(AvahiClientState)),this,TQT_SLOT(clientState(AvahiClientState)));
connect(&Responder::self(),TQ_SIGNAL(stateChanged(AvahiClientState)),this,TQ_SLOT(clientState(AvahiClientState)));
}
#endif
if (domain.isNull())

@ -49,7 +49,7 @@ Asynchronous publishing is better for responsiveness. Example:
\code
DNSSD::PublicService *service = new DNSSD::PublicService("My files","_http._tcp",80);
connect(service,TQT_SIGNAL(published(bool)),this,TQT_SLOT(wasPublished(bool)));
connect(service,TQ_SIGNAL(published(bool)),this,TQ_SLOT(wasPublished(bool)));
service->publishAsync();
\endcode

@ -74,7 +74,7 @@ public:
Query::Query(const TQString& type, const TQString& domain)
{
d = new QueryPrivate(type,domain);
connect(&d->timeout,TQT_SIGNAL(timeout()),this,TQT_SLOT(timeout()));
connect(&d->timeout,TQ_SIGNAL(timeout()),this,TQ_SLOT(timeout()));
}

@ -69,9 +69,9 @@ void ServiceBrowser::init(const TQStringList& type,DomainBrowser* domains,int fl
d->m_types=type;
d->m_flags=flags;
d->m_domains = domains;
connect(d->m_domains,TQT_SIGNAL(domainAdded(const TQString& )),this,TQT_SLOT(addDomain(const TQString& )));
connect(d->m_domains,TQT_SIGNAL(domainRemoved(const TQString& )),this,
TQT_SLOT(removeDomain(const TQString& )));
connect(d->m_domains,TQ_SIGNAL(domainAdded(const TQString& )),this,TQ_SLOT(addDomain(const TQString& )));
connect(d->m_domains,TQ_SIGNAL(domainRemoved(const TQString& )),this,
TQ_SLOT(removeDomain(const TQString& )));
}
ServiceBrowser::ServiceBrowser(const TQString& type,const TQString& domain,bool autoResolve)
{
@ -110,7 +110,7 @@ void ServiceBrowser::serviceResolved(bool success)
{
TQObject* sender_obj = const_cast<TQObject*>(sender());
RemoteService* svr = static_cast<RemoteService*>(sender_obj);
disconnect(svr,TQT_SIGNAL(resolved(bool)),this,TQT_SLOT(serviceResolved(bool)));
disconnect(svr,TQ_SIGNAL(resolved(bool)),this,TQ_SLOT(serviceResolved(bool)));
TQValueList<RemoteService::Ptr>::Iterator it = d->m_duringResolve.begin();
TQValueList<RemoteService::Ptr>::Iterator itEnd = d->m_duringResolve.end();
while ( it!= itEnd && svr!= (*it)) ++it;
@ -140,7 +140,7 @@ void ServiceBrowser::gotNewService(RemoteService::Ptr svr)
{
if (findDuplicate(svr)==(d->m_services.end())) {
if (d->m_flags & AutoResolve) {
connect(svr,TQT_SIGNAL(resolved(bool )),this,TQT_SLOT(serviceResolved(bool )));
connect(svr,TQ_SIGNAL(resolved(bool )),this,TQ_SLOT(serviceResolved(bool )));
d->m_duringResolve+=svr;
svr->resolveAsync();
} else {
@ -179,11 +179,11 @@ void ServiceBrowser::addDomain(const TQString& domain)
TQStringList::ConstIterator itEnd = d->m_types.end();
for (TQStringList::ConstIterator it=d->m_types.begin(); it!=itEnd; ++it) {
Query* b = new Query((*it),domain);
connect(b,TQT_SIGNAL(serviceAdded(DNSSD::RemoteService::Ptr)),this,
TQT_SLOT(gotNewService(DNSSD::RemoteService::Ptr)));
connect(b,TQT_SIGNAL(serviceRemoved(DNSSD::RemoteService::Ptr )),this,
TQT_SLOT(gotRemoveService(DNSSD::RemoteService::Ptr)));
connect(b,TQT_SIGNAL(finished()),this,TQT_SLOT(queryFinished()));
connect(b,TQ_SIGNAL(serviceAdded(DNSSD::RemoteService::Ptr)),this,
TQ_SLOT(gotNewService(DNSSD::RemoteService::Ptr)));
connect(b,TQ_SIGNAL(serviceRemoved(DNSSD::RemoteService::Ptr )),this,
TQ_SLOT(gotRemoveService(DNSSD::RemoteService::Ptr)));
connect(b,TQ_SIGNAL(finished()),this,TQ_SLOT(queryFinished()));
b->startQuery();
d->resolvers.insert(domain,b);
}

@ -38,8 +38,8 @@ Suppose that you need list of web servers running. Example:
\code
DNSSD::ServiceBrowser* browser = new DNSSD::ServiceBrowser("_http._tcp");
connect(browser,TQT_SIGNAL(serviceAdded(RemoteService::Ptr)),this,TQT_SLOT(addService(RemoteService::Ptr)));
connect(browser,TQT_SIGNAL(serviceRemoved(RemoteService::Ptr)),this,TQT_SLOT(delService(RemoteService::Ptr)));
connect(browser,TQ_SIGNAL(serviceAdded(RemoteService::Ptr)),this,TQ_SLOT(addService(RemoteService::Ptr)));
connect(browser,TQ_SIGNAL(serviceRemoved(RemoteService::Ptr)),this,TQ_SLOT(delService(RemoteService::Ptr)));
browser->startBrowse();
\endcode

@ -206,7 +206,7 @@ inline BytesEditInterface *bytesEditInterface( T *t )
* <EFBFBD> if( Clipboard )
* <EFBFBD> {
* <EFBFBD> <EFBFBD> // Yes, use BytesEditWidget, not Clipboard, because that's the TQObject, indeed hacky...
* <EFBFBD> <EFBFBD> connect( BytesEditWidget, TQT_SIGNAL(copyAvailable(bool)), this, TQT_SLOT(offerCopy(bool)) );
* <EFBFBD> <EFBFBD> connect( BytesEditWidget, TQ_SIGNAL(copyAvailable(bool)), this, TQ_SLOT(offerCopy(bool)) );
* <EFBFBD> }
* }
* \endcode

@ -35,7 +35,7 @@ namespace KHE
* if( Clipboard )
* {
* <EFBFBD> // Yes, use BytesEditWidget, not Clipboard, because that's the TQObject, indeed hacky...
* <EFBFBD> connect( BytesEditWidget, TQT_SIGNAL(copyAvailable(bool)), this, TQT_SLOT(offerCopy(bool)) );
* <EFBFBD> connect( BytesEditWidget, TQ_SIGNAL(copyAvailable(bool)), this, TQ_SLOT(offerCopy(bool)) );
* }
* \endcode
*

@ -41,7 +41,7 @@
*
* Note: signals and slots must be connected to the editorDialog object, not to the editor object:
* \code
* connect( editorDialog, TQT_SIGNAL( canUndo( bool ) ), undoBut, TQT_SLOT( setEnabled( bool ) ) );
* connect( editorDialog, TQ_SIGNAL( canUndo( bool ) ), undoBut, TQ_SLOT( setEnabled( bool ) ) );
* \endcode
*
* If you want to create an instance of the editor widget, i.e. not the

@ -181,8 +181,8 @@ KIMProxy::KIMProxy( DCOPClient* dc ) : DCOPObject( "KIMProxyIface" ), TQObject()
d->dc = dc;
m_initialized = false;
connect( d->dc, TQT_SIGNAL( applicationRemoved( const TQCString& ) ) , this, TQT_SLOT( unregisteredFromDCOP( const TQCString& ) ) );
connect( d->dc, TQT_SIGNAL( applicationRegistered( const TQCString& ) ) , this, TQT_SLOT( registeredToDCOP( const TQCString& ) ) );
connect( d->dc, TQ_SIGNAL( applicationRemoved( const TQCString& ) ) , this, TQ_SLOT( unregisteredFromDCOP( const TQCString& ) ) );
connect( d->dc, TQ_SIGNAL( applicationRegistered( const TQCString& ) ) , this, TQ_SLOT( registeredToDCOP( const TQCString& ) ) );
d->dc->setNotifications( true );
d->presence_strings.append( "Unknown" );

@ -93,7 +93,7 @@ KFileAudioPreview::KFileAudioPreview( TQWidget *parent, const char *name )
m_autoPlay = new TQCheckBox( i18n("Play &automatically"), box );
TDEConfigGroup config( TDEGlobal::config(), ConfigGroup );
m_autoPlay->setChecked( config.readBoolEntry( "Autoplay sounds", true ) );
connect( m_autoPlay, TQT_SIGNAL(toggled(bool)), TQT_SLOT(toggleAuto(bool)) );
connect( m_autoPlay, TQ_SIGNAL(toggled(bool)), TQ_SLOT(toggleAuto(bool)) );
}
KFileAudioPreview::~KFileAudioPreview()

@ -31,9 +31,9 @@ K_EXPORT_COMPONENT_FACTORY( libshellscript, ShellScriptFactory( "ShellScript" )
ShellScript::ShellScript(KScriptClientInterface *parent, const char *, const TQStringList & ) : ScriptClientInterface(parent)
{
m_script = new TDEProcess();
connect ( m_script, TQT_SIGNAL(processExited(TDEProcess *)), TQT_SLOT(Exit(TDEProcess *)));
connect ( m_script, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)), TQT_SLOT(stdOut(TDEProcess *, char *, int )));
connect ( m_script, TQT_SIGNAL(receivedStderr(TDEProcess *, char *, int)), TQT_SLOT(stdErr(TDEProcess *, char *, int )));
connect ( m_script, TQ_SIGNAL(processExited(TDEProcess *)), TQ_SLOT(Exit(TDEProcess *)));
connect ( m_script, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)), TQ_SLOT(stdOut(TDEProcess *, char *, int )));
connect ( m_script, TQ_SIGNAL(receivedStderr(TDEProcess *, char *, int)), TQ_SLOT(stdErr(TDEProcess *, char *, int )));
// Connect feedback signals and slots
//kdDebug() << "Building new script engine" << endl;
}

@ -40,7 +40,7 @@ ScriptLoader::ScriptLoader(TDEMainWindow *parent) : TQObject (parent)
m_theAction = new TDESelectAction ( i18n("TDE Scripts"),
0,
this,
TQT_SLOT(runAction()),
TQ_SLOT(runAction()),
m_parent->actionCollection(),
"scripts");
}

@ -78,8 +78,8 @@ class TQStrList;
* // or connect to one of the signals. Connect to the Part object,
* // not to the TerminalInterface, since the latter is no TQObject,
* // and as such cannot have signals..:
* // connect( p, TQT_SIGNAL( processExited( int ) ),
* // this, TQT_SLOT( shellExited( int ) ) );
* // connect( p, TQ_SIGNAL( processExited( int ) ),
* // this, TQ_SLOT( shellExited( int ) ) );
* // etc.
*
* \endcode

@ -26,8 +26,8 @@ Win::Win()
// l.append( "python" );
// t->startProgram( TQString::fromUtf8( "/usr/bin/python" ), l );
connect( p, TQT_SIGNAL( processExited( int ) ),
this, TQT_SLOT( pythonExited( int ) ) );
connect( p, TQ_SIGNAL( processExited( int ) ),
this, TQ_SLOT( pythonExited( int ) ) );
}
@ -48,8 +48,8 @@ void Win::pythonExited()
std::cerr << "hee, " << p << std::endl;
std::cerr << ( ::tqt_cast<TerminalInterface>(p) ) << std::endl;
// KMessageBox::sorry( this, TQString::fromUtf8( "Exited, status was %1" ).arg( status ) );
disconnect(p, TQT_SIGNAL( processExited() ),
this, TQT_SLOT( pythonExited() ));
disconnect(p, TQ_SIGNAL( processExited() ),
this, TQ_SLOT( pythonExited() ));
TerminalInterface* t = ::tqt_cast<TerminalInterface*>( p );
TQStrList l;
l.append( "echo" );

@ -420,10 +420,10 @@ AddressBook::AddressBook(TQWidget* parent, const char* name, bool loadit)
i18n("Out of Memory"));
kapp->quit(); // It is critical, but will possibly never happen.
}
connect(data, TQT_SIGNAL(fileChanged()), TQT_SLOT(dataFileChanged()));
connect(data, TQT_SIGNAL(changed(QConfigDB*)),
TQT_SLOT(reloaded(QConfigDB*)));
connect(config, TQT_SIGNAL(fileChanged()), TQT_SLOT(configFileChanged()));
connect(data, TQ_SIGNAL(fileChanged()), TQ_SLOT(dataFileChanged()));
connect(data, TQ_SIGNAL(changed(QConfigDB*)),
TQ_SLOT(reloaded(QConfigDB*)));
connect(config, TQ_SIGNAL(fileChanged()), TQ_SLOT(configFileChanged()));
// ----- set style:
filename = locate( "data", STD_CONFIGFILENAME);

@ -43,8 +43,8 @@ KabAPI::KabAPI(TQWidget* parent, const char* name)
setMainWidget(listbox);
showButtonApply(false);
enableButtonSeparator(true);
connect(listbox, TQT_SIGNAL(highlighted(int)), TQT_SLOT(entrySelected(int)));
connect(listbox, TQT_SIGNAL(doubleClicked ( TQListBoxItem * )),TQT_SLOT(slotDoubleClicked ( TQListBoxItem * )));
connect(listbox, TQ_SIGNAL(highlighted(int)), TQ_SLOT(entrySelected(int)));
connect(listbox, TQ_SIGNAL(doubleClicked ( TQListBoxItem * )),TQ_SLOT(slotDoubleClicked ( TQListBoxItem * )));
}
@ -90,8 +90,8 @@ AddressBook::ErrorCode KabAPI::init()
book=new AddressBook(0, "KABAPI::book", true); //change parent from "this" to "0" //dsweet
if(book->getState()==AddressBook::NoError)
{
connect(book, TQT_SIGNAL(setStatus(const TQString&)),
TQT_SLOT(setStatusSlot(const TQString&)));
connect(book, TQ_SIGNAL(setStatus(const TQString&)),
TQ_SLOT(setStatusSlot(const TQString&)));
return AddressBook::NoError;
} else {
return AddressBook::InternError;

@ -2221,7 +2221,7 @@ QConfigDB::watch(bool state)
if(timer==0)
{
timer=new TQTimer(this);
connect(timer, TQT_SIGNAL(timeout()), TQT_SLOT(checkFileChanged()));
connect(timer, TQ_SIGNAL(timeout()), TQ_SLOT(checkFileChanged()));
}
timer->start(1000);
} else { // stop timer

@ -156,8 +156,8 @@
<item> Q_SIGNALS </item>
<item> Q_SLOTS </item>
<item> Q_UNUSED </item>
<item> SIGNAL </item>
<item> SLOT </item>
<item> Q_SIGNAL </item>
<item> Q_SLOT </item>
<item> TRUE </item>
<item> FALSE </item>
<item> TQ_ARG </item>
@ -202,8 +202,6 @@
<item> TQ_SLOT </item>
<item> TQ_SLOTS </item>
<item> TQ_UNUSED </item>
<item> TQT_SIGNAL </item>
<item> TQT_SLOT </item>
<item> connect </item>
<item> disconnect </item>
<item> emit </item>

@ -79,8 +79,8 @@
<item> Q_SIGNALS </item>
<item> Q_SLOTS </item>
<item> Q_UNUSED </item>
<item> SIGNAL </item>
<item> SLOT </item>
<item> Q_SIGNAL </item>
<item> Q_SLOT </item>
<item> TRUE </item>
<item> FALSE </item>
<item> TQ_ARG </item>
@ -125,8 +125,6 @@
<item> TQ_SLOT </item>
<item> TQ_SLOTS </item>
<item> TQ_UNUSED </item>
<item> TQT_SIGNAL </item>
<item> TQT_SLOT </item>
<item> connect </item>
<item> disconnect </item>
<item> emit </item>

@ -124,8 +124,8 @@
<item> Q_SIGNALS </item>
<item> Q_SLOTS </item>
<item> Q_UNUSED </item>
<item> SIGNAL </item>
<item> SLOT </item>
<item> Q_SIGNAL </item>
<item> Q_SLOT </item>
<item> TRUE </item>
<item> FALSE </item>
<item> TQ_ARG </item>
@ -170,8 +170,6 @@
<item> TQ_SLOT </item>
<item> TQ_SLOTS </item>
<item> TQ_UNUSED </item>
<item> TQT_SIGNAL </item>
<item> TQT_SLOT </item>
<item> connect </item>
<item> disconnect </item>
<item> emit </item>

@ -34,8 +34,8 @@
<item> slots </item>
<item> foreach </item>
<item> forever </item>
<item> SIGNAL </item>
<item> SLOT </item>
<item> Q_SIGNAL </item>
<item> Q_SLOT </item>
<!-- http://qt-project.org/doc/qt-4.8/QApplication.html#macros -->
<item> qApp </item>
<!-- http://qt-project.org/doc/qt-4.8/qcoreapplication.html#macros -->

@ -73,8 +73,8 @@ KateAttribute KateArbitraryHighlightRange::merge(TQPtrList<KateSuperRange> range
void KateArbitraryHighlight::addHighlightToDocument(KateSuperRangeList* list)
{
m_docHLs.append(list);
connect(list, TQT_SIGNAL(rangeEliminated(KateSuperRange*)), TQT_SLOT(slotRangeEliminated(KateSuperRange*)));
connect(list, TQT_SIGNAL(destroyed(TQObject*)),TQT_SLOT(slotRangeListDeleted(TQObject*)));
connect(list, TQ_SIGNAL(rangeEliminated(KateSuperRange*)), TQ_SLOT(slotRangeEliminated(KateSuperRange*)));
connect(list, TQ_SIGNAL(destroyed(TQObject*)),TQ_SLOT(slotRangeListDeleted(TQObject*)));
}
void KateArbitraryHighlight::addHighlightToView(KateSuperRangeList* list, KateView* view)
@ -84,9 +84,9 @@ void KateArbitraryHighlight::addHighlightToView(KateSuperRangeList* list, KateVi
m_viewHLs[view]->append(list);
connect(list, TQT_SIGNAL(rangeEliminated(KateSuperRange*)), TQT_SLOT(slotTagRange(KateSuperRange*)));
connect(list, TQT_SIGNAL(tagRange(KateSuperRange*)), TQT_SLOT(slotTagRange(KateSuperRange*)));
connect(list, TQT_SIGNAL(destroyed(TQObject*)),TQT_SLOT(slotRangeListDeleted(TQObject*)));
connect(list, TQ_SIGNAL(rangeEliminated(KateSuperRange*)), TQ_SLOT(slotTagRange(KateSuperRange*)));
connect(list, TQ_SIGNAL(tagRange(KateSuperRange*)), TQ_SLOT(slotTagRange(KateSuperRange*)));
connect(list, TQ_SIGNAL(destroyed(TQObject*)),TQ_SLOT(slotRangeListDeleted(TQObject*)));
}
void KateArbitraryHighlight::slotRangeListDeleted(TQObject* obj) {

@ -161,7 +161,7 @@ KateAutoIndent::~KateAutoIndent ()
KateViewIndentationAction::KateViewIndentationAction(KateDocument *_doc, const TQString& text, TQObject* parent, const char* name)
: TDEActionMenu (text, parent, name), doc(_doc)
{
connect(popupMenu(),TQT_SIGNAL(aboutToShow()),this,TQT_SLOT(slotAboutToShow()));
connect(popupMenu(),TQ_SIGNAL(aboutToShow()),this,TQ_SLOT(slotAboutToShow()));
}
void KateViewIndentationAction::slotAboutToShow()
@ -170,7 +170,7 @@ void KateViewIndentationAction::slotAboutToShow()
popupMenu()->clear ();
for (uint z=0; z<modes.size(); ++z)
popupMenu()->insertItem ( '&' + KateAutoIndent::modeDescription(z).replace('&', "&&"), this, TQT_SLOT(setMode(int)), 0, z);
popupMenu()->insertItem ( '&' + KateAutoIndent::modeDescription(z).replace('&', "&&"), this, TQ_SLOT(setMode(int)), 0, z);
popupMenu()->setItemChecked (doc->config()->indentationMode(), true);
}
@ -187,7 +187,7 @@ KateNormalIndent::KateNormalIndent (KateDocument *_doc)
: KateAutoIndent (_doc)
{
// if highlighting changes, update attributes
connect(_doc, TQT_SIGNAL(hlChanged()), this, TQT_SLOT(updateConfig()));
connect(_doc, TQ_SIGNAL(hlChanged()), this, TQ_SLOT(updateConfig()));
}
KateNormalIndent::~KateNormalIndent ()
@ -2174,8 +2174,8 @@ KateVarIndent::KateVarIndent( KateDocument *doc )
slotVariableChanged( "var-indent-handle-couples", doc->variable( "var-indent-handle-couples" ) );
// update if a setting is changed
connect( doc, TQT_SIGNAL(variableChanged( const TQString&, const TQString&) ),
this, TQT_SLOT(slotVariableChanged( const TQString&, const TQString& )) );
connect( doc, TQ_SIGNAL(variableChanged( const TQString&, const TQString&) ),
this, TQ_SLOT(slotVariableChanged( const TQString&, const TQString& )) );
}
KateVarIndent::~KateVarIndent()

@ -62,7 +62,7 @@ KateBookmarks::KateBookmarks( KateView* view, Sorting sort )
, m_view( view )
, m_sorting( sort )
{
connect (view->getDoc(), TQT_SIGNAL(marksChanged()), this, TQT_SLOT(marksChanged()));
connect (view->getDoc(), TQ_SIGNAL(marksChanged()), this, TQ_SLOT(marksChanged()));
_tries=0;
m_bookmarksMenu = 0L;
}
@ -75,26 +75,26 @@ void KateBookmarks::createActions( TDEActionCollection* ac )
{
m_bookmarkToggle = new TDEToggleAction(
i18n("Set &Bookmark"), "bookmark", CTRL+Key_B,
this, TQT_SLOT(toggleBookmark()),
this, TQ_SLOT(toggleBookmark()),
ac, "bookmarks_toggle" );
m_bookmarkToggle->setWhatsThis(i18n("If a line has no bookmark then add one, otherwise remove it."));
m_bookmarkToggle->setCheckedState( i18n("Clear &Bookmark") );
m_bookmarkClear = new TDEAction(
i18n("Clear &All Bookmarks"), 0,
this, TQT_SLOT(clearBookmarks()),
this, TQ_SLOT(clearBookmarks()),
ac, "bookmarks_clear");
m_bookmarkClear->setWhatsThis(i18n("Remove all bookmarks of the current document."));
m_goNext = new TDEAction(
i18n("Next Bookmark"), "go-next", ALT + Key_PageDown,
this, TQT_SLOT(goNext()),
this, TQ_SLOT(goNext()),
ac, "bookmarks_next");
m_goNext->setWhatsThis(i18n("Go to the next bookmark."));
m_goPrevious = new TDEAction(
i18n("Previous Bookmark"), "go-previous", ALT + Key_PageUp,
this, TQT_SLOT(goPrevious()),
this, TQ_SLOT(goPrevious()),
ac, "bookmarks_previous");
m_goPrevious->setWhatsThis(i18n("Go to the previous bookmark."));
@ -102,14 +102,14 @@ void KateBookmarks::createActions( TDEActionCollection* ac )
//connect the aboutToShow() and aboutToHide() signals with
//the bookmarkMenuAboutToShow() and bookmarkMenuAboutToHide() slots
connect( m_bookmarksMenu, TQT_SIGNAL(aboutToShow()), this, TQT_SLOT(bookmarkMenuAboutToShow()));
connect( m_bookmarksMenu, TQT_SIGNAL(aboutToHide()), this, TQT_SLOT(bookmarkMenuAboutToHide()) );
connect( m_bookmarksMenu, TQ_SIGNAL(aboutToShow()), this, TQ_SLOT(bookmarkMenuAboutToShow()));
connect( m_bookmarksMenu, TQ_SIGNAL(aboutToHide()), this, TQ_SLOT(bookmarkMenuAboutToHide()) );
marksChanged ();
bookmarkMenuAboutToHide();
connect( m_view, TQT_SIGNAL( gotFocus( Kate::View * ) ), this, TQT_SLOT( slotViewGotFocus( Kate::View * ) ) );
connect( m_view, TQT_SIGNAL( lostFocus( Kate::View * ) ), this, TQT_SLOT( slotViewLostFocus( Kate::View * ) ) );
connect( m_view, TQ_SIGNAL( gotFocus( Kate::View * ) ), this, TQ_SLOT( slotViewGotFocus( Kate::View * ) ) );
connect( m_view, TQ_SIGNAL( lostFocus( Kate::View * ) ), this, TQ_SLOT( slotViewLostFocus( Kate::View * ) ) );
}
void KateBookmarks::toggleBookmark ()
@ -181,7 +181,7 @@ void KateBookmarks::insertBookmarks( TQPopupMenu& menu )
menu.insertItem(
TQString("%1 - \"%2\"").arg( (*it)->line+1 ).arg( bText ),
m_view, TQT_SLOT(gotoLineNumber(int)), 0, (*it)->line, idx );
m_view, TQ_SLOT(gotoLineNumber(int)), 0, (*it)->line, idx );
if ( (*it)->line < line )
{

@ -129,11 +129,11 @@ KateCodeCompletion::KateCodeCompletion( KateView* view )
m_completionPopup->setFocusProxy( m_view->m_viewInternal );
m_pArgHint = new KateArgHint( m_view );
connect( m_pArgHint, TQT_SIGNAL(argHintHidden()),
this, TQT_SIGNAL(argHintHidden()) );
connect( m_pArgHint, TQ_SIGNAL(argHintHidden()),
this, TQ_SIGNAL(argHintHidden()) );
connect( m_view, TQT_SIGNAL(cursorPositionChanged()),
this, TQT_SLOT(slotCursorPosChanged()) );
connect( m_view, TQ_SIGNAL(cursorPositionChanged()),
this, TQ_SLOT(slotCursorPosChanged()) );
}
KateCodeCompletion::~KateCodeCompletion()
@ -185,7 +185,7 @@ bool KateCodeCompletion::eventFilter( TQObject *o, TQEvent *e )
}
if ( e->type() == TQEvent::MouseButtonPress ) {
TQTimer::singleShot(0, this, TQT_SLOT(showComment()));
TQTimer::singleShot(0, this, TQ_SLOT(showComment()));
return false;
}
@ -207,7 +207,7 @@ void KateCodeCompletion::handleKey (TQKeyEvent *e)
(e->key() == Key_Home ) || (e->key() == Key_End) ||
(e->key() == Key_Prior) || (e->key() == Key_Next ))
{
TQTimer::singleShot(0,this,TQT_SLOT(showComment()));
TQTimer::singleShot(0,this,TQ_SLOT(showComment()));
TQApplication::sendEvent( m_completionListBox, (TQEvent*)e );
return;
}
@ -324,7 +324,7 @@ void KateCodeCompletion::updateBox( bool )
m_completionListBox->setFocus();
m_completionPopup->show();
TQTimer::singleShot(0,this,TQT_SLOT(showComment()));
TQTimer::singleShot(0,this,TQ_SLOT(showComment()));
}
void KateCodeCompletion::showArgHint ( TQStringList functionList, const TQString& strWrapping, const TQString& strDelimiter )

@ -117,7 +117,7 @@ KateConfigPage::KateConfigPage ( TQWidget *parent, const char *name )
: Kate::ConfigPage (parent, name)
, m_changed (false)
{
connect (this, TQT_SIGNAL(changed()), this, TQT_SLOT(somethingHasChanged ()));
connect (this, TQ_SIGNAL(changed()), this, TQ_SLOT(somethingHasChanged ()));
}
KateConfigPage::~KateConfigPage ()
@ -235,27 +235,27 @@ KateIndentConfigTab::KateIndentConfigTab(TQWidget *parent)
// after initial reload, connect the stuff for the changed () signal
//
connect(m_indentMode, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotChanged()));
connect(m_indentMode, TQT_SIGNAL(activated(int)), this, TQT_SLOT(indenterSelected(int)));
connect(m_indentMode, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotChanged()));
connect(m_indentMode, TQ_SIGNAL(activated(int)), this, TQ_SLOT(indenterSelected(int)));
connect( opt[0], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(somethingToggled()));
connect( opt[0], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(somethingToggled()));
connect( opt[0], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[1], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[2], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[3], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[4], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[5], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[6], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[7], TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( opt[0], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( opt[1], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( opt[2], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( opt[3], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( opt[4], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( opt[5], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( opt[6], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( opt[7], TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect(indentationWidth, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect(indentationWidth, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
connect(rb1, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(rb2, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(rb3, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(rb1, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(rb2, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(rb3, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(m_configPage, TQT_SIGNAL(clicked()), this, TQT_SLOT(configPage()));
connect(m_configPage, TQ_SIGNAL(clicked()), this, TQ_SLOT(configPage()));
}
void KateIndentConfigTab::somethingToggled() {
@ -292,7 +292,7 @@ void KateIndentConfigTab::configPage()
if (!page) return;
box->setStretchFactor(page, 1);
connect( &dlg, TQT_SIGNAL(okClicked()), page, TQT_SLOT(apply()) );
connect( &dlg, TQ_SIGNAL(okClicked()), page, TQ_SLOT(apply()) );
dlg.resize(400, 300);
dlg.exec();
@ -357,20 +357,20 @@ KateSelectConfigTab::KateSelectConfigTab(TQWidget *parent)
opt[0] = new TQCheckBox(i18n("Smart ho&me and smart end"), gbCursor);
opt[0]->setChecked(configFlags & KateDocumentConfig::cfSmartHome);
connect(opt[0], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(opt[0], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
opt[1] = new TQCheckBox(i18n("Wrap c&ursor"), gbCursor);
opt[1]->setChecked(configFlags & KateDocumentConfig::cfWrapCursor);
connect(opt[1], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(opt[1], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
e6 = new TQCheckBox(i18n("&PageUp/PageDown moves cursor"), gbCursor);
e6->setChecked(KateDocumentConfig::global()->pageUpDownMovesCursor());
connect(e6, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(e6, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
e4 = new KIntNumInput(KateViewConfig::global()->autoCenterLines(), gbCursor);
e4->setRange(0, 1000000, 1, false);
e4->setLabel(i18n("Autocenter cursor (lines):"), AlignVCenter);
connect(e4, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect(e4, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
layout->addWidget(gbCursor);
@ -416,8 +416,8 @@ KateSelectConfigTab::KateSelectConfigTab(TQWidget *parent)
// after initial reload, connect the stuff for the changed () signal
//
connect(rb1, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(rb2, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(rb1, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(rb2, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
}
void KateSelectConfigTab::apply ()
@ -473,16 +473,16 @@ KateEditConfigTab::KateEditConfigTab(TQWidget *parent)
opt[3] = new TQCheckBox( i18n("&Insert spaces instead of tabulators"), gbWhiteSpace );
opt[3]->setChecked( configFlags & KateDocumentConfig::cfReplaceTabsDyn );
connect( opt[3], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()) );
connect( opt[3], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()) );
opt[2] = new TQCheckBox(i18n("&Show tabulators"), gbWhiteSpace);
opt[2]->setChecked(configFlags & flags[2]);
connect(opt[2], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(opt[2], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
e2 = new KIntNumInput(KateDocumentConfig::global()->tabWidth(), gbWhiteSpace);
e2->setRange(1, 16, 1, false);
e2->setLabel(i18n("Tab width:"), AlignVCenter);
connect(e2, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect(e2, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
mainLayout->addWidget(gbWhiteSpace);
@ -490,35 +490,35 @@ KateEditConfigTab::KateEditConfigTab(TQWidget *parent)
opt[0] = new TQCheckBox(i18n("Enable static &word wrap"), gbWordWrap);
opt[0]->setChecked(KateDocumentConfig::global()->wordWrap());
connect(opt[0], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(opt[0], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
m_wwmarker = new TQCheckBox( i18n("&Show static word wrap marker (if applicable)"), gbWordWrap );
m_wwmarker->setChecked( KateRendererConfig::global()->wordWrapMarker() );
connect(m_wwmarker, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_wwmarker, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
e1 = new KIntNumInput(KateDocumentConfig::global()->wordWrapAt(), gbWordWrap);
e1->setRange(20, 200, 1, false);
e1->setLabel(i18n("Wrap words at:"), AlignVCenter);
connect(e1, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect(e1, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
mainLayout->addWidget(gbWordWrap);
opt[4] = new TQCheckBox( i18n("Remove &trailing spaces"), this );
mainLayout->addWidget( opt[4] );
opt[4]->setChecked( configFlags & KateDocumentConfig::cfRemoveTrailingDyn );
connect( opt[4], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()) );
connect( opt[4], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()) );
opt[1] = new TQCheckBox(i18n("Auto &brackets"), this);
mainLayout->addWidget(opt[1]);
opt[1]->setChecked(configFlags & flags[1]);
connect(opt[1], TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(opt[1], TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
e3 = new KIntNumInput(e2, KateDocumentConfig::global()->undoSteps(), this);
e3->setRange(0, 1000000, 1, false);
e3->setSpecialValueText( i18n("Unlimited") );
e3->setLabel(i18n("Maximum undo steps:"), AlignVCenter);
mainLayout->addWidget(e3);
connect(e3, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect(e3, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
TQHBoxLayout *e5Layout = new TQHBoxLayout(mainLayout);
TQLabel *e5Label = new TQLabel(i18n("Smart search t&ext from:"), this);
@ -532,7 +532,7 @@ KateEditConfigTab::KateEditConfigTab(TQWidget *parent)
e5->setCurrentItem(KateViewConfig::global()->textToSearchMode());
e5Layout->addWidget(e5);
e5Label->setBuddy(e5);
connect(e5, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotChanged()));
connect(e5, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotChanged()));
mainLayout->addStretch();
@ -744,17 +744,17 @@ KateViewDefaultsConfig::KateViewDefaultsConfig(TQWidget *parent)
// after initial reload, connect the stuff for the changed () signal
//
connect(m_dynwrap, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_dynwrapIndicatorsCombo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotChanged()));
connect(m_dynwrapAlignLevel, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect(m_icons, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_scrollBarMarks, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_line, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_folding, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_collapseTopLevel, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()) );
connect(rb1, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(rb2, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_showIndentLines, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect(m_dynwrap, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(m_dynwrapIndicatorsCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotChanged()));
connect(m_dynwrapAlignLevel, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
connect(m_icons, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(m_scrollBarMarks, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(m_line, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(m_folding, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(m_collapseTopLevel, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()) );
connect(rb1, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(rb2, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect(m_showIndentLines, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
}
KateViewDefaultsConfig::~KateViewDefaultsConfig()
@ -821,7 +821,7 @@ void KateEditKeyConfiguration::showEvent ( TQShowEvent * )
KateView* view = (KateView*)m_doc->views().at(0);
m_ac = view->editActionCollection();
m_keyChooser = new KKeyChooser( m_ac, this, false );
connect( m_keyChooser, TQT_SIGNAL( keyChange() ), this, TQT_SLOT( slotChanged() ) );
connect( m_keyChooser, TQ_SIGNAL( keyChange() ), this, TQ_SLOT( slotChanged() ) );
m_keyChooser->show ();
m_ready = true;
@ -947,16 +947,16 @@ KateSaveConfigTab::KateSaveConfigTab( TQWidget *parent )
// after initial reload, connect the stuff for the changed () signal
//
connect(m_encoding, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotChanged()));
connect(m_eol, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotChanged()));
connect( allowEolDetection, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect(blockCount, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect(removeSpaces, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotChanged()));
connect( cbLocalFiles, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect( cbRemoteFiles, TQT_SIGNAL( toggled(bool) ), this, TQT_SLOT( slotChanged() ) );
connect(dirSearchDepth, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotChanged()));
connect( leBuPrefix, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( leBuSuffix, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect(m_encoding, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotChanged()));
connect(m_eol, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotChanged()));
connect( allowEolDetection, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect(blockCount, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
connect(removeSpaces, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(slotChanged()));
connect( cbLocalFiles, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect( cbRemoteFiles, TQ_SIGNAL( toggled(bool) ), this, TQ_SLOT( slotChanged() ) );
connect(dirSearchDepth, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotChanged()));
connect( leBuPrefix, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( leBuSuffix, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
}
void KateSaveConfigTab::apply()
@ -1131,12 +1131,12 @@ KatePartPluginConfigPage::KatePartPluginConfigPage (TQWidget *parent) : KateConf
btnConfigure = new TQPushButton( i18n("Configure..."), this );
btnConfigure->setEnabled( false );
grid->addWidget( btnConfigure, 1, 0, TQt::AlignRight );
connect( btnConfigure, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotConfigure()) );
connect( btnConfigure, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotConfigure()) );
connect( listView, TQT_SIGNAL(selectionChanged(TQListViewItem*)), this, TQT_SLOT(slotCurrentChanged(TQListViewItem*)) );
connect( listView, TQT_SIGNAL(stateChange(KatePartPluginListItem *, bool)),
this, TQT_SLOT(slotStateChanged(KatePartPluginListItem *, bool)));
connect(listView, TQT_SIGNAL(stateChange(KatePartPluginListItem *, bool)), this, TQT_SLOT(slotChanged()));
connect( listView, TQ_SIGNAL(selectionChanged(TQListViewItem*)), this, TQ_SLOT(slotCurrentChanged(TQListViewItem*)) );
connect( listView, TQ_SIGNAL(stateChange(KatePartPluginListItem *, bool)),
this, TQ_SLOT(slotStateChanged(KatePartPluginListItem *, bool)));
connect(listView, TQ_SIGNAL(stateChange(KatePartPluginListItem *, bool)), this, TQ_SLOT(slotChanged()));
}
KatePartPluginConfigPage::~KatePartPluginConfigPage ()
@ -1266,8 +1266,8 @@ KateHlConfigPage::KateHlConfigPage (TQWidget *parent, KateDocument *doc)
TQLabel *lHl = new TQLabel( i18n("H&ighlight:"), hbHl );
hlCombo = new TQComboBox( false, hbHl );
lHl->setBuddy( hlCombo );
connect( hlCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(hlChanged(int)) );
connect( hlCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(hlChanged(int)) );
for( int i = 0; i < KateHlManager::self()->highlights(); i++) {
if (KateHlManager::self()->hlSection(i).length() > 0)
@ -1312,7 +1312,7 @@ KateHlConfigPage::KateHlConfigPage (TQWidget *parent, KateDocument *doc)
TQToolButton *btnMTW = new TQToolButton(hbMT);
btnMTW->setIconSet(TQIconSet(SmallIcon("wizard")));
connect(btnMTW, TQT_SIGNAL(clicked()), this, TQT_SLOT(showMTDlg()));
connect(btnMTW, TQ_SIGNAL(clicked()), this, TQ_SLOT(showMTDlg()));
// download/new buttons
TQHBox *hbBtns = new TQHBox( this );
@ -1321,7 +1321,7 @@ KateHlConfigPage::KateHlConfigPage (TQWidget *parent, KateDocument *doc)
((TQBoxLayout*)hbBtns->layout())->addStretch(1); // hmm.
hbBtns->setSpacing( KDialog::spacingHint() );
TQPushButton *btnDl = new TQPushButton(i18n("Do&wnload..."), hbBtns);
connect( btnDl, TQT_SIGNAL(clicked()), this, TQT_SLOT(hlDownload()) );
connect( btnDl, TQ_SIGNAL(clicked()), this, TQ_SLOT(hlDownload()) );
int currentHl = m_doc ? m_doc->hlMode() : 0;
hlCombo->setCurrentItem( currentHl );
@ -1347,9 +1347,9 @@ KateHlConfigPage::KateHlConfigPage (TQWidget *parent, KateDocument *doc)
layout->addStretch ();
connect( wildcards, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( mimetypes, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( priority, TQT_SIGNAL( valueChanged ( int ) ), this, TQT_SLOT( slotChanged() ) );
connect( wildcards, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( mimetypes, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( priority, TQ_SIGNAL( valueChanged ( int ) ), this, TQ_SLOT( slotChanged() ) );
}
KateHlConfigPage::~KateHlConfigPage ()
@ -1453,8 +1453,8 @@ KateHlDownloadDialog::KateHlDownloadDialog(TQWidget *parent, const char *name, b
actionButton (User1)->setIconSet(SmallIconSet("ok"));
transferJob = TDEIO::get(KURL(TQString(HLDOWNLOADPATH)), true, true);
connect(transferJob, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQT_SLOT(listDataReceived(TDEIO::Job *, const TQByteArray &)));
connect(transferJob, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)),
this, TQ_SLOT(listDataReceived(TDEIO::Job *, const TQByteArray &)));
// void data( TDEIO::Job *, const TQByteArray &data);
resize(450, 400);
}
@ -1616,7 +1616,7 @@ KateModOnHdPrompt::KateModOnHdPrompt( KateDocument *doc,
TQPushButton *btnDiff = new TQPushButton( i18n("&View Difference"), w );
lo2->addStretch( 1 );
lo2->addWidget( btnDiff );
connect( btnDiff, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDiff()) );
connect( btnDiff, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDiff()) );
TQWhatsThis::add( btnDiff, i18n(
"Calculates the difference between the editor contents and the disk "
"file using diff(1) and opens the diff file with the default application "
@ -1639,8 +1639,8 @@ void KateModOnHdPrompt::slotDiff()
KProcIO *p = new KProcIO();
p->setComm( TDEProcess::All );
*p << "diff" << "-u" << "-" << m_doc->url().path();
connect( p, TQT_SIGNAL(processExited(TDEProcess*)), this, TQT_SLOT(slotPDone(TDEProcess*)) );
connect( p, TQT_SIGNAL(readReady(KProcIO*)), this, TQT_SLOT(slotPRead(KProcIO*)) );
connect( p, TQ_SIGNAL(processExited(TDEProcess*)), this, TQ_SLOT(slotPDone(TDEProcess*)) );
connect( p, TQ_SIGNAL(readReady(KProcIO*)), this, TQ_SLOT(slotPRead(KProcIO*)) );
setCursor( WaitCursor );

@ -171,7 +171,7 @@ KateDocument::KateDocument ( bool bSingleViewMode, bool bBrowserView,
setMarksUserChangable( markType01 );
m_undoMergeTimer = new TQTimer(this);
connect(m_undoMergeTimer, TQT_SIGNAL(timeout()), TQT_SLOT(undoCancel()));
connect(m_undoMergeTimer, TQ_SIGNAL(timeout()), TQ_SLOT(undoCancel()));
clearMarks ();
clearUndo ();
@ -189,24 +189,24 @@ KateDocument::KateDocument ( bool bSingleViewMode, bool bBrowserView,
m_indenter->updateConfig ();
// some nice signals from the buffer
connect(m_buffer, TQT_SIGNAL(tagLines(int,int)), this, TQT_SLOT(tagLines(int,int)));
connect(m_buffer, TQT_SIGNAL(codeFoldingUpdated()),this,TQT_SIGNAL(codeFoldingUpdated()));
connect(m_buffer, TQ_SIGNAL(tagLines(int,int)), this, TQ_SLOT(tagLines(int,int)));
connect(m_buffer, TQ_SIGNAL(codeFoldingUpdated()),this,TQ_SIGNAL(codeFoldingUpdated()));
// if the user changes the highlight with the dialog, notify the doc
connect(KateHlManager::self(),TQT_SIGNAL(changed()),TQT_SLOT(internalHlChanged()));
connect(KateHlManager::self(),TQ_SIGNAL(changed()),TQ_SLOT(internalHlChanged()));
// signal for the arbitrary HL
connect(m_arbitraryHL, TQT_SIGNAL(tagLines(KateView*, KateSuperRange*)), TQT_SLOT(tagArbitraryLines(KateView*, KateSuperRange*)));
connect(m_arbitraryHL, TQ_SIGNAL(tagLines(KateView*, KateSuperRange*)), TQ_SLOT(tagArbitraryLines(KateView*, KateSuperRange*)));
// signals for mod on hd
connect( KateFactory::self()->dirWatch(), TQT_SIGNAL(dirty (const TQString &)),
this, TQT_SLOT(slotModOnHdDirty (const TQString &)) );
connect( KateFactory::self()->dirWatch(), TQ_SIGNAL(dirty (const TQString &)),
this, TQ_SLOT(slotModOnHdDirty (const TQString &)) );
connect( KateFactory::self()->dirWatch(), TQT_SIGNAL(created (const TQString &)),
this, TQT_SLOT(slotModOnHdCreated (const TQString &)) );
connect( KateFactory::self()->dirWatch(), TQ_SIGNAL(created (const TQString &)),
this, TQ_SLOT(slotModOnHdCreated (const TQString &)) );
connect( KateFactory::self()->dirWatch(), TQT_SIGNAL(deleted (const TQString &)),
this, TQT_SLOT(slotModOnHdDeleted (const TQString &)) );
connect( KateFactory::self()->dirWatch(), TQ_SIGNAL(deleted (const TQString &)),
this, TQ_SLOT(slotModOnHdDeleted (const TQString &)) );
// update doc name
setDocName ("");
@ -220,7 +220,7 @@ KateDocument::KateDocument ( bool bSingleViewMode, bool bBrowserView,
setWidget( view );
}
connect(this,TQT_SIGNAL(sigQueryClose(bool *, bool*)),this,TQT_SLOT(slotQueryClose_save(bool *, bool*)));
connect(this,TQ_SIGNAL(sigQueryClose(bool *, bool*)),this,TQ_SLOT(slotQueryClose_save(bool *, bool*)));
m_isasking = 0;
@ -356,9 +356,9 @@ void KateDocument::disablePluginGUI (KTextEditor::Plugin *plugin)
KTextEditor::View *KateDocument::createView( TQWidget *parent, const char *name )
{
KateView* newView = new KateView( this, parent, name);
connect(newView, TQT_SIGNAL(cursorPositionChanged()), TQT_SLOT(undoCancel()));
connect(newView, TQ_SIGNAL(cursorPositionChanged()), TQ_SLOT(undoCancel()));
if ( s_fileChangedDialogsActivated )
connect( newView, TQT_SIGNAL(gotFocus( Kate::View * )), this, TQT_SLOT(slotModifiedOnDisk()) );
connect( newView, TQ_SIGNAL(gotFocus( Kate::View * )), this, TQ_SLOT(slotModifiedOnDisk()) );
return newView;
}
@ -2305,11 +2305,11 @@ bool KateDocument::openURL( const KURL &url )
m_job = TDEIO::get ( url, false, isProgressInfoEnabled() );
// connect to slots
connect( m_job, TQT_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
TQT_SLOT( slotDataKate( TDEIO::Job*, const TQByteArray& ) ) );
connect( m_job, TQ_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
TQ_SLOT( slotDataKate( TDEIO::Job*, const TQByteArray& ) ) );
connect( m_job, TQT_SIGNAL( result( TDEIO::Job* ) ),
TQT_SLOT( slotFinishedKate( TDEIO::Job* ) ) );
connect( m_job, TQ_SIGNAL( result( TDEIO::Job* ) ),
TQ_SLOT( slotFinishedKate( TDEIO::Job* ) ) );
TQWidget *w = widget ();
if (!w && !m_views.isEmpty ())

@ -31,8 +31,8 @@ KateBrowserExtension::KateBrowserExtension( KateDocument* doc )
: KParts::BrowserExtension( doc, "katepartbrowserextension" ),
m_doc (doc)
{
connect( doc, TQT_SIGNAL( selectionChanged() ),
this, TQT_SLOT( slotSelectionChanged() ) );
connect( doc, TQ_SIGNAL( selectionChanged() ),
this, TQ_SLOT( slotSelectionChanged() ) );
emit enableAction( "print", true );
}

@ -273,14 +273,14 @@ KateFileTypeConfigTab::KateFileTypeConfigTab( TQWidget *parent )
TQLabel *lHl = new TQLabel( i18n("&Filetype:"), hbHl );
typeCombo = new TQComboBox( false, hbHl );
lHl->setBuddy( typeCombo );
connect( typeCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(typeChanged(int)) );
connect( typeCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(typeChanged(int)) );
TQPushButton *btnnew = new TQPushButton( i18n("&New"), hbHl );
connect( btnnew, TQT_SIGNAL(clicked()), this, TQT_SLOT(newType()) );
connect( btnnew, TQ_SIGNAL(clicked()), this, TQ_SLOT(newType()) );
btndel = new TQPushButton( i18n("&Delete"), hbHl );
connect( btndel, TQT_SIGNAL(clicked()), this, TQT_SLOT(deleteType()) );
connect( btndel, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteType()) );
gbProps = new TQGroupBox( 2, TQt::Horizontal, i18n("Properties"), this );
layout->add (gbProps);
@ -312,7 +312,7 @@ KateFileTypeConfigTab::KateFileTypeConfigTab( TQWidget *parent )
TQToolButton *btnMTW = new TQToolButton(hbMT);
btnMTW->setIconSet(TQIconSet(SmallIcon("wizard")));
connect(btnMTW, TQT_SIGNAL(clicked()), this, TQT_SLOT(showMTDlg()));
connect(btnMTW, TQ_SIGNAL(clicked()), this, TQ_SLOT(showMTDlg()));
TQLabel *lprio = new TQLabel( i18n("Prio&rity:"), gbProps);
priority = new KIntNumInput( gbProps );
@ -322,12 +322,12 @@ KateFileTypeConfigTab::KateFileTypeConfigTab( TQWidget *parent )
reload();
connect( name, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( section, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( varLine, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( wildcards, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( mimetypes, TQT_SIGNAL( textChanged ( const TQString & ) ), this, TQT_SLOT( slotChanged() ) );
connect( priority, TQT_SIGNAL( valueChanged ( int ) ), this, TQT_SLOT( slotChanged() ) );
connect( name, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( section, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( varLine, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( wildcards, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( mimetypes, TQ_SIGNAL( textChanged ( const TQString & ) ), this, TQ_SLOT( slotChanged() ) );
connect( priority, TQ_SIGNAL( valueChanged ( int ) ), this, TQ_SLOT( slotChanged() ) );
TQWhatsThis::add( btnnew, i18n("Create a new file type.") );
TQWhatsThis::add( btndel, i18n("Delete the current file type.") );
@ -519,9 +519,9 @@ void KateViewFileTypeAction::init()
m_doc = 0;
subMenus.setAutoDelete( true );
popupMenu()->insertItem ( i18n("None"), this, TQT_SLOT(setType(int)), 0, 0);
popupMenu()->insertItem ( i18n("None"), this, TQ_SLOT(setType(int)), 0, 0);
connect(popupMenu(),TQT_SIGNAL(aboutToShow()),this,TQT_SLOT(slotAboutToShow()));
connect(popupMenu(),TQ_SIGNAL(aboutToShow()),this,TQ_SLOT(slotAboutToShow()));
}
void KateViewFileTypeAction::updateMenu (Kate::Document *doc)
@ -551,12 +551,12 @@ void KateViewFileTypeAction::slotAboutToShow()
int m = subMenusName.findIndex (hlSection);
names << hlName;
subMenus.at(m)->insertItem ( hlName, this, TQT_SLOT(setType(int)), 0, z+1);
subMenus.at(m)->insertItem ( hlName, this, TQ_SLOT(setType(int)), 0, z+1);
}
else if (names.contains(hlName) < 1)
{
names << hlName;
popupMenu()->insertItem ( hlName, this, TQT_SLOT(setType(int)), 0, z+1);
popupMenu()->insertItem ( hlName, this, TQ_SLOT(setType(int)), 0, z+1);
}
}

@ -3405,7 +3405,7 @@ void KateViewHighlightAction::init()
m_doc = 0;
subMenus.setAutoDelete( true );
connect(popupMenu(),TQT_SIGNAL(aboutToShow()),this,TQT_SLOT(slotAboutToShow()));
connect(popupMenu(),TQ_SIGNAL(aboutToShow()),this,TQ_SLOT(slotAboutToShow()));
}
void KateViewHighlightAction::updateMenu (Kate::Document *doc)
@ -3437,12 +3437,12 @@ void KateViewHighlightAction::slotAboutToShow()
int m = subMenusName.findIndex (hlSection);
names << hlName;
subMenus.at(m)->insertItem ( '&' + hlName, this, TQT_SLOT(setHl(int)), 0, z);
subMenus.at(m)->insertItem ( '&' + hlName, this, TQ_SLOT(setHl(int)), 0, z);
}
else if (names.contains(hlName) < 1)
{
names << hlName;
popupMenu()->insertItem ( '&' + hlName, this, TQT_SLOT(setHl(int)), 0, z);
popupMenu()->insertItem ( '&' + hlName, this, TQ_SLOT(setHl(int)), 0, z);
}
}
}

@ -719,7 +719,7 @@ KatePrintHeaderFooter::KatePrintHeaderFooter( KPrinter * /*printer*/, TQWidget *
lo2->setStretchFactor( lFontPreview, 1 );
TQPushButton *btnChooseFont = new TQPushButton( i18n("Choo&se Font..."), this );
lo2->addWidget( btnChooseFont );
connect( btnChooseFont, TQT_SIGNAL(clicked()), this, TQT_SLOT(setHFFont()) );
connect( btnChooseFont, TQ_SIGNAL(clicked()), this, TQ_SLOT(setHFFont()) );
// header
gbHeader = new TQGroupBox( 2, TQt::Horizontal, i18n("Header Properties"), this );
lo->addWidget( gbHeader );
@ -764,10 +764,10 @@ KatePrintHeaderFooter::KatePrintHeaderFooter( KPrinter * /*printer*/, TQWidget *
lo->addStretch( 1 );
// user friendly
connect( cbEnableHeader, TQT_SIGNAL(toggled(bool)), gbHeader, TQT_SLOT(setEnabled(bool)) );
connect( cbEnableFooter, TQT_SIGNAL(toggled(bool)), gbFooter, TQT_SLOT(setEnabled(bool)) );
connect( cbHeaderEnableBgColor, TQT_SIGNAL(toggled(bool)), kcbtnHeaderBg, TQT_SLOT(setEnabled(bool)) );
connect( cbFooterEnableBgColor, TQT_SIGNAL(toggled(bool)), kcbtnFooterBg, TQT_SLOT(setEnabled(bool)) );
connect( cbEnableHeader, TQ_SIGNAL(toggled(bool)), gbHeader, TQ_SLOT(setEnabled(bool)) );
connect( cbEnableFooter, TQ_SIGNAL(toggled(bool)), gbFooter, TQ_SLOT(setEnabled(bool)) );
connect( cbHeaderEnableBgColor, TQ_SIGNAL(toggled(bool)), kcbtnHeaderBg, TQ_SLOT(setEnabled(bool)) );
connect( cbFooterEnableBgColor, TQ_SIGNAL(toggled(bool)), kcbtnFooterBg, TQ_SLOT(setEnabled(bool)) );
// set defaults
cbEnableHeader->setChecked( true );
@ -937,7 +937,7 @@ KatePrintLayout::KatePrintLayout( KPrinter * /*printer*/, TQWidget *parent, cons
kcbtnBoxColor = new KColorButton( gbBoxProps );
lBoxColor->setBuddy( kcbtnBoxColor );
connect( cbEnableBox, TQT_SIGNAL(toggled(bool)), gbBoxProps, TQT_SLOT(setEnabled(bool)) );
connect( cbEnableBox, TQ_SIGNAL(toggled(bool)), gbBoxProps, TQ_SLOT(setEnabled(bool)) );
lo->addStretch( 1 );
// set defaults:

@ -310,7 +310,7 @@ KateSchemaConfigColorTab::KateSchemaConfigColorTab( TQWidget *parent, const char
m_combobox->insertItem(i18n("Error")); // markType07
m_combobox->setCurrentItem(0);
m_markers = new KColorButton(b, "marker_color_button");
connect( m_combobox, TQT_SIGNAL( activated( int ) ), TQT_SLOT( slotComboBoxChanged( int ) ) );
connect( m_combobox, TQ_SIGNAL( activated( int ) ), TQ_SLOT( slotComboBoxChanged( int ) ) );
blay->addWidget(gbTextArea);
@ -351,7 +351,7 @@ KateSchemaConfigColorTab::KateSchemaConfigColorTab( TQWidget *parent, const char
blay->addStretch();
// connect signal changed(); changed is emitted by a ColorButton change!
connect( this, TQT_SIGNAL( changed() ), parent->parentWidget(), TQT_SLOT( slotChanged() ) );
connect( this, TQ_SIGNAL( changed() ), parent->parentWidget(), TQ_SLOT( slotChanged() ) );
// TQWhatsThis help
TQWhatsThis::add(m_back, i18n("<p>Sets the background color of the editing area.</p>"));
@ -405,15 +405,15 @@ void KateSchemaConfigColorTab::schemaChanged ( int newSchema )
m_schema = newSchema;
// first disconnect all signals otherwise setColor emits changed
m_back ->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_selected ->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_current ->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_bracket ->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_wwmarker ->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_iconborder->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_tmarker ->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_markers ->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_linenumber->disconnect( TQT_SIGNAL( changed( const TQColor & ) ) );
m_back ->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_selected ->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_current ->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_bracket ->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_wwmarker ->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_iconborder->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_tmarker ->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_markers ->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
m_linenumber->disconnect( TQ_SIGNAL( changed( const TQColor & ) ) );
// If we havent this schema, read in from config file
if ( ! m_schemas.contains( newSchema ) )
@ -475,15 +475,15 @@ void KateSchemaConfigColorTab::schemaChanged ( int newSchema )
}
m_markers->setColor( m_schemas [ newSchema ].markerColors[ m_combobox->currentItem() ] );
connect( m_back , TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_selected , TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_current , TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_bracket , TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_wwmarker , TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_iconborder, TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_tmarker , TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_linenumber, TQT_SIGNAL( changed( const TQColor& ) ), TQT_SIGNAL( changed() ) );
connect( m_markers , TQT_SIGNAL( changed( const TQColor& ) ), TQT_SLOT( slotMarkerColorChanged( const TQColor& ) ) );
connect( m_back , TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_selected , TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_current , TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_bracket , TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_wwmarker , TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_iconborder, TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_tmarker , TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_linenumber, TQ_SIGNAL( changed( const TQColor& ) ), TQ_SIGNAL( changed() ) );
connect( m_markers , TQ_SIGNAL( changed( const TQColor& ) ), TQ_SLOT( slotMarkerColorChanged( const TQColor& ) ) );
}
void KateSchemaConfigColorTab::apply ()
@ -527,9 +527,9 @@ void KateSchemaConfigColorTab::slotMarkerColorChanged( const TQColor& color)
void KateSchemaConfigColorTab::slotComboBoxChanged(int index)
{
// temporarily disconnect the changed-signal because setColor emits changed as well
m_markers->disconnect( TQT_SIGNAL( changed( const TQColor& ) ) );
m_markers->disconnect( TQ_SIGNAL( changed( const TQColor& ) ) );
m_markers->setColor( m_schemas[m_schema].markerColors[index] );
connect( m_markers, TQT_SIGNAL( changed( const TQColor& ) ), TQT_SLOT( slotMarkerColorChanged( const TQColor& ) ) );
connect( m_markers, TQ_SIGNAL( changed( const TQColor& ) ), TQ_SLOT( slotMarkerColorChanged( const TQColor& ) ) );
}
//END KateSchemaConfigColorTab
@ -544,7 +544,7 @@ KateSchemaConfigFontTab::KateSchemaConfigFontTab( TQWidget *parent, const char *
m_fontchooser = new TDEFontChooser ( this, 0L, false, TQStringList(), false );
grid->addWidget( m_fontchooser, 0, 0);
connect (this, TQT_SIGNAL( changed()), parent->parentWidget(), TQT_SLOT (slotChanged()));
connect (this, TQ_SIGNAL( changed()), parent->parentWidget(), TQ_SLOT (slotChanged()));
m_schema = -1;
}
@ -582,7 +582,7 @@ void KateSchemaConfigFontTab::schemaChanged( int newSchema )
m_fontchooser->disconnect ( this );
m_fontchooser->setFont ( KateFactory::self()->schemaManager()->schema( newSchema )->readFontEntry("Font", &f) );
m_fonts[ newSchema ] = m_fontchooser->font();
connect (m_fontchooser, TQT_SIGNAL (fontSelected( const TQFont & )), this, TQT_SLOT (slotFontSelected( const TQFont & )));
connect (m_fontchooser, TQ_SIGNAL (fontSelected( const TQFont & )), this, TQ_SLOT (slotFontSelected( const TQFont & )));
}
//END FontConfig
@ -598,7 +598,7 @@ KateSchemaConfigFontColorTab::KateSchemaConfigFontColorTab( TQWidget *parent, co
m_defaultStyles = new KateStyleListView( this, false );
grid->addWidget( m_defaultStyles, 0, 0);
connect (m_defaultStyles, TQT_SIGNAL (changed()), parent->parentWidget(), TQT_SLOT (slotChanged()));
connect (m_defaultStyles, TQ_SIGNAL (changed()), parent->parentWidget(), TQ_SLOT (slotChanged()));
TQWhatsThis::add( m_defaultStyles, i18n(
"This list displays the default styles for the current schema and "
@ -688,8 +688,8 @@ KateSchemaConfigHighlightTab::KateSchemaConfigHighlightTab( TQWidget *parent, co
TQLabel *lHl = new TQLabel( i18n("H&ighlight:"), hbHl );
hlCombo = new TQComboBox( false, hbHl );
lHl->setBuddy( hlCombo );
connect( hlCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(hlChanged(int)) );
connect( hlCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(hlChanged(int)) );
for( int i = 0; i < KateHlManager::self()->highlights(); i++) {
if (KateHlManager::self()->hlSection(i).length() > 0)
@ -715,7 +715,7 @@ KateSchemaConfigHighlightTab::KateSchemaConfigHighlightTab( TQWidget *parent, co
"to edit from the popup menu.<p>You can unset the Background and Selected "
"Background colors from the context menu when appropriate.") );
connect (m_styles, TQT_SIGNAL (changed()), parent->parentWidget(), TQT_SLOT (slotChanged()));
connect (m_styles, TQ_SIGNAL (changed()), parent->parentWidget(), TQ_SLOT (slotChanged()));
}
KateSchemaConfigHighlightTab::~KateSchemaConfigHighlightTab()
@ -833,20 +833,20 @@ KateSchemaConfigPage::KateSchemaConfigPage( TQWidget *parent, KateDocument *doc
TQLabel *lHl = new TQLabel( i18n("&Schema:"), hbHl );
schemaCombo = new TQComboBox( false, hbHl );
lHl->setBuddy( schemaCombo );
connect( schemaCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(schemaChanged(int)) );
connect( schemaCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(schemaChanged(int)) );
TQPushButton *btnnew = new TQPushButton( i18n("&New..."), hbHl );
connect( btnnew, TQT_SIGNAL(clicked()), this, TQT_SLOT(newSchema()) );
connect( btnnew, TQ_SIGNAL(clicked()), this, TQ_SLOT(newSchema()) );
btndel = new TQPushButton( i18n("&Delete"), hbHl );
connect( btndel, TQT_SIGNAL(clicked()), this, TQT_SLOT(deleteSchema()) );
connect( btndel, TQ_SIGNAL(clicked()), this, TQ_SLOT(deleteSchema()) );
m_tabWidget = new TQTabWidget ( this );
m_tabWidget->setMargin (KDialog::marginHint());
layout->add (m_tabWidget);
connect (m_tabWidget, TQT_SIGNAL (currentChanged (TQWidget *)), this, TQT_SLOT (newCurrentPage (TQWidget *)));
connect (m_tabWidget, TQ_SIGNAL (currentChanged (TQWidget *)), this, TQ_SLOT (newCurrentPage (TQWidget *)));
m_colorTab = new KateSchemaConfigColorTab (m_tabWidget);
m_tabWidget->addTab (m_colorTab, i18n("Colors"));
@ -873,8 +873,8 @@ KateSchemaConfigPage::KateSchemaConfigPage( TQWidget *parent, KateDocument *doc
reload();
connect( defaultSchemaCombo, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotChanged()) );
connect( defaultSchemaCombo, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotChanged()) );
}
KateSchemaConfigPage::~KateSchemaConfigPage ()
@ -1003,7 +1003,7 @@ void KateViewSchemaAction::init()
m_view = 0;
last = 0;
connect(popupMenu(),TQT_SIGNAL(aboutToShow()),this,TQT_SLOT(slotAboutToShow()));
connect(popupMenu(),TQ_SIGNAL(aboutToShow()),this,TQ_SLOT(slotAboutToShow()));
}
void KateViewSchemaAction::updateMenu (KateView *view)
@ -1023,7 +1023,7 @@ void KateViewSchemaAction::slotAboutToShow()
if (names.contains(hlName) < 1)
{
names << hlName;
popupMenu()->insertItem ( hlName, this, TQT_SLOT(setSchema(int)), 0, z+1);
popupMenu()->insertItem ( hlName, this, TQ_SLOT(setSchema(int)), 0, z+1);
}
}
@ -1060,10 +1060,10 @@ KateStyleListView::KateStyleListView( TQWidget *parent, bool showUseDefaults )
addColumn( i18n("Background Selected") );
if ( showUseDefaults )
addColumn( i18n("Use Default Style") );
connect( this, TQT_SIGNAL(mouseButtonPressed(int, TQListViewItem*, const TQPoint&, int)),
this, TQT_SLOT(slotMousePressed(int, TQListViewItem*, const TQPoint&, int)) );
connect( this, TQT_SIGNAL(contextMenuRequested(TQListViewItem*,const TQPoint&, int)),
this, TQT_SLOT(showPopupMenu(TQListViewItem*, const TQPoint&)) );
connect( this, TQ_SIGNAL(mouseButtonPressed(int, TQListViewItem*, const TQPoint&, int)),
this, TQ_SLOT(slotMousePressed(int, TQListViewItem*, const TQPoint&, int)) );
connect( this, TQ_SIGNAL(contextMenuRequested(TQListViewItem*,const TQPoint&, int)),
this, TQ_SLOT(showPopupMenu(TQListViewItem*, const TQPoint&)) );
// grap the bg color, selected color and default font
normalcol = TDEGlobalSettings::textColor();
bgcol = KateRendererConfig::global()->backgroundColor();
@ -1093,21 +1093,21 @@ void KateStyleListView::showPopupMenu( KateStyleListItem *i, const TQPoint &glob
if ( showtitle )
m.insertTitle( i->contextName(), KateStyleListItem::ContextName );
id = m.insertItem( i18n("&Bold"), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Bold );
id = m.insertItem( i18n("&Bold"), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Bold );
m.setItemChecked( id, is->bold() );
id = m.insertItem( i18n("&Italic"), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Italic );
id = m.insertItem( i18n("&Italic"), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Italic );
m.setItemChecked( id, is->italic() );
id = m.insertItem( i18n("&Underline"), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Underline );
id = m.insertItem( i18n("&Underline"), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Underline );
m.setItemChecked( id, is->underline() );
id = m.insertItem( i18n("S&trikeout"), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Strikeout );
id = m.insertItem( i18n("S&trikeout"), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Strikeout );
m.setItemChecked( id, is->strikeOut() );
m.insertSeparator();
m.insertItem( TQIconSet(cl), i18n("Normal &Color..."), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Color );
m.insertItem( TQIconSet(scl), i18n("&Selected Color..."), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::SelColor );
m.insertItem( TQIconSet(bgcl), i18n("&Background Color..."), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::BgColor );
m.insertItem( TQIconSet(sbgcl), i18n("S&elected Background Color..."), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::SelBgColor );
m.insertItem( TQIconSet(cl), i18n("Normal &Color..."), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::Color );
m.insertItem( TQIconSet(scl), i18n("&Selected Color..."), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::SelColor );
m.insertItem( TQIconSet(bgcl), i18n("&Background Color..."), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::BgColor );
m.insertItem( TQIconSet(sbgcl), i18n("S&elected Background Color..."), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::SelBgColor );
// Unset [some] colors. I could show one only if that button was clicked, but that
// would disable setting this with the keyboard (how many aren't doing just
@ -1118,14 +1118,14 @@ void KateStyleListView::showPopupMenu( KateStyleListItem *i, const TQPoint &glob
{
m.insertSeparator();
if ( style->itemSet( KateAttribute::BGColor) )
m.insertItem( i18n("Unset Background Color"), this, TQT_SLOT(unsetColor(int)), 0, 100 );
m.insertItem( i18n("Unset Background Color"), this, TQ_SLOT(unsetColor(int)), 0, 100 );
if ( style->itemSet( KateAttribute::SelectedBGColor ) )
m.insertItem( i18n("Unset Selected Background Color"), this, TQT_SLOT(unsetColor(int)), 0, 101 );
m.insertItem( i18n("Unset Selected Background Color"), this, TQ_SLOT(unsetColor(int)), 0, 101 );
}
if ( ! i->isDefault() && ! i->defStyle() ) {
m.insertSeparator();
id = m.insertItem( i18n("Use &Default Style"), this, TQT_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::UseDefStyle );
id = m.insertItem( i18n("Use &Default Style"), this, TQ_SLOT(mSlotPopupHandler(int)), 0, KateStyleListItem::UseDefStyle );
m.setItemChecked( id, i->defStyle() );
}
m.exec( globalPos );

@ -198,7 +198,7 @@ class KateSchemaConfigColorTab : public TQWidget
void schemaChanged( int newSchema );
signals:
void changed(); // connected to parentWidget()->parentWidget() TQT_SLOT(slotChanged)
void changed(); // connected to parentWidget()->parentWidget() TQ_SLOT(slotChanged)
protected slots:
void slotMarkerColorChanged(const TQColor&);
@ -223,7 +223,7 @@ class KateSchemaConfigFontTab : public TQWidget
void schemaChanged( int newSchema );
signals:
void changed(); // connected to parentWidget()->parentWidget() TQT_SLOT(slotChanged)
void changed(); // connected to parentWidget()->parentWidget() TQ_SLOT(slotChanged)
private:
class TDEFontChooser *m_fontchooser;

@ -58,7 +58,7 @@ KateSearch::KateSearch( KateView* view )
m_arbitraryHLList = new KateSuperRangeList();
if (arbitraryHLExample) m_doc->arbitraryHL()->addHighlightToView(m_arbitraryHLList, m_view);
connect(replacePrompt,TQT_SIGNAL(clicked()),this,TQT_SLOT(replaceSlot()));
connect(replacePrompt,TQ_SIGNAL(clicked()),this,TQ_SLOT(replaceSlot()));
}
KateSearch::~KateSearch()
@ -68,13 +68,13 @@ KateSearch::~KateSearch()
void KateSearch::createActions( TDEActionCollection* ac )
{
KStdAction::find( this, TQT_SLOT(find()), ac )->setWhatsThis(
KStdAction::find( this, TQ_SLOT(find()), ac )->setWhatsThis(
i18n("Look up the first occurrence of a piece of text or regular expression."));
KStdAction::findNext( this, TQT_SLOT(slotFindNext()), ac )->setWhatsThis(
KStdAction::findNext( this, TQ_SLOT(slotFindNext()), ac )->setWhatsThis(
i18n("Look up the next occurrence of the search phrase."));
KStdAction::findPrev( this, TQT_SLOT(slotFindPrev()), ac, "edit_find_prev" )->setWhatsThis(
KStdAction::findPrev( this, TQ_SLOT(slotFindPrev()), ac, "edit_find_prev" )->setWhatsThis(
i18n("Look up the previous occurrence of the search phrase."));
KStdAction::replace( this, TQT_SLOT(replace()), ac )->setWhatsThis(
KStdAction::replace( this, TQ_SLOT(replace()), ac )->setWhatsThis(
i18n("Look up a piece of text or regular expression and replace the result with some given text."));
}
@ -732,7 +732,7 @@ bool KateSearch::doSearch( const TQString& text )
hl->setTextColor(TQt::white);
hl->setBGColor(TQt::black);
// destroy the highlight upon change
connect(hl, TQT_SIGNAL(contentsChanged()), hl, TQT_SIGNAL(eliminated()));
connect(hl, TQ_SIGNAL(contentsChanged()), hl, TQ_SIGNAL(eliminated()));
m_arbitraryHLList->append(hl);
}

@ -53,11 +53,11 @@ KateSpell::~KateSpell()
void KateSpell::createActions( TDEActionCollection* ac )
{
KStdAction::spelling( this, TQT_SLOT(spellcheck()), ac );
TDEAction *a = new TDEAction( i18n("Spelling (from cursor)..."), "tools-check-spelling", 0, this, TQT_SLOT(spellcheckFromCursor()), ac, "tools_spelling_from_cursor" );
KStdAction::spelling( this, TQ_SLOT(spellcheck()), ac );
TDEAction *a = new TDEAction( i18n("Spelling (from cursor)..."), "tools-check-spelling", 0, this, TQ_SLOT(spellcheckFromCursor()), ac, "tools_spelling_from_cursor" );
a->setWhatsThis(i18n("Check the document's spelling from the cursor and forward"));
m_spellcheckSelection = new TDEAction( i18n("Spellcheck Selection..."), "tools-check-spelling", 0, this, TQT_SLOT(spellcheckSelection()), ac, "tools_spelling_selection" );
m_spellcheckSelection = new TDEAction( i18n("Spellcheck Selection..."), "tools-check-spelling", 0, this, TQ_SLOT(spellcheckSelection()), ac, "tools_spelling_selection" );
m_spellcheckSelection->setWhatsThis(i18n("Check spelling of the selected text"));
}
@ -123,17 +123,17 @@ void KateSpell::spellcheck( const KateTextCursor &from, const KateTextCursor &to
kdDebug(13020)<<"KateSpell::spellCheck(): using encoding: "<<enc<<" and KSpell::Type "<<type<<" (for '"<<mt<<"')"<<endl;
m_tdespell = new KSpell( m_view, i18n("Spellcheck"),
this, TQT_SLOT(ready(KSpell *)), ksc, true, true, type );
this, TQ_SLOT(ready(KSpell *)), ksc, true, true, type );
connect( m_tdespell, TQT_SIGNAL(death()),
this, TQT_SLOT(spellCleanDone()) );
connect( m_tdespell, TQ_SIGNAL(death()),
this, TQ_SLOT(spellCleanDone()) );
connect( m_tdespell, TQT_SIGNAL(misspelling(const TQString&, const TQStringList&, unsigned int)),
this, TQT_SLOT(misspelling(const TQString&, const TQStringList&, unsigned int)) );
connect( m_tdespell, TQT_SIGNAL(corrected(const TQString&, const TQString&, unsigned int)),
this, TQT_SLOT(corrected(const TQString&, const TQString&, unsigned int)) );
connect( m_tdespell, TQT_SIGNAL(done(const TQString&)),
this, TQT_SLOT(spellResult(const TQString&)) );
connect( m_tdespell, TQ_SIGNAL(misspelling(const TQString&, const TQStringList&, unsigned int)),
this, TQ_SLOT(misspelling(const TQString&, const TQStringList&, unsigned int)) );
connect( m_tdespell, TQ_SIGNAL(corrected(const TQString&, const TQString&, unsigned int)),
this, TQ_SLOT(corrected(const TQString&, const TQString&, unsigned int)) );
connect( m_tdespell, TQ_SIGNAL(done(const TQString&)),
this, TQ_SLOT(spellResult(const TQString&)) );
}
void KateSpell::ready(KSpell *)

@ -328,15 +328,15 @@ void KateSuperRange::init()
setBehaviour(DoNotExpand);
// Not necessarily the best implementation
connect(m_start, TQT_SIGNAL(positionDirectlyChanged()), TQT_SIGNAL(contentsChanged()));
connect(m_end, TQT_SIGNAL(positionDirectlyChanged()), TQT_SIGNAL(contentsChanged()));
connect(m_start, TQ_SIGNAL(positionDirectlyChanged()), TQ_SIGNAL(contentsChanged()));
connect(m_end, TQ_SIGNAL(positionDirectlyChanged()), TQ_SIGNAL(contentsChanged()));
connect(m_start, TQT_SIGNAL(positionChanged()), TQT_SLOT(slotEvaluateChanged()));
connect(m_end, TQT_SIGNAL(positionChanged()), TQT_SLOT(slotEvaluateChanged()));
connect(m_start, TQT_SIGNAL(positionUnChanged()), TQT_SLOT(slotEvaluateUnChanged()));
connect(m_end, TQT_SIGNAL(positionUnChanged()), TQT_SLOT(slotEvaluateUnChanged()));
connect(m_start, TQT_SIGNAL(positionDeleted()), TQT_SIGNAL(boundaryDeleted()));
connect(m_end, TQT_SIGNAL(positionDeleted()), TQT_SIGNAL(boundaryDeleted()));
connect(m_start, TQ_SIGNAL(positionChanged()), TQ_SLOT(slotEvaluateChanged()));
connect(m_end, TQ_SIGNAL(positionChanged()), TQ_SLOT(slotEvaluateChanged()));
connect(m_start, TQ_SIGNAL(positionUnChanged()), TQ_SLOT(slotEvaluateUnChanged()));
connect(m_end, TQ_SIGNAL(positionUnChanged()), TQ_SLOT(slotEvaluateUnChanged()));
connect(m_start, TQ_SIGNAL(positionDeleted()), TQ_SIGNAL(boundaryDeleted()));
connect(m_end, TQ_SIGNAL(positionDeleted()), TQ_SIGNAL(boundaryDeleted()));
}
KateSuperRange::~KateSuperRange()
@ -581,8 +581,8 @@ void KateSuperRangeList::connectAll()
if (!m_connect) {
m_connect = true;
for (KateSuperRange* range = first(); range; range = next()) {
connect(range, TQT_SIGNAL(destroyed(TQObject*)), TQT_SLOT(slotDeleted(TQObject*)));
connect(range, TQT_SIGNAL(eliminated()), TQT_SLOT(slotEliminated()));
connect(range, TQ_SIGNAL(destroyed(TQObject*)), TQ_SLOT(slotDeleted(TQObject*)));
connect(range, TQ_SIGNAL(eliminated()), TQ_SLOT(slotEliminated()));
}
}
}
@ -727,9 +727,9 @@ int KateSuperRangeList::compareItems(TQPtrCollection::Item item1, TQPtrCollectio
TQPtrCollection::Item KateSuperRangeList::newItem(TQPtrCollection::Item d)
{
if (m_connect) {
connect(static_cast<KateSuperRange*>(d), TQT_SIGNAL(destroyed(TQObject*)), TQT_SLOT(slotDeleted(TQObject*)));
connect(static_cast<KateSuperRange*>(d), TQT_SIGNAL(eliminated()), TQT_SLOT(slotEliminated()));
connect(static_cast<KateSuperRange*>(d), TQT_SIGNAL(tagRange(KateSuperRange*)), TQT_SIGNAL(tagRange(KateSuperRange*)));
connect(static_cast<KateSuperRange*>(d), TQ_SIGNAL(destroyed(TQObject*)), TQ_SLOT(slotDeleted(TQObject*)));
connect(static_cast<KateSuperRange*>(d), TQ_SIGNAL(eliminated()), TQ_SLOT(slotEliminated()));
connect(static_cast<KateSuperRange*>(d), TQ_SIGNAL(tagRange(KateSuperRange*)), TQ_SIGNAL(tagRange(KateSuperRange*)));
// HACK HACK
static_cast<KateSuperRange*>(d)->slotTagRange();

@ -38,7 +38,7 @@ KateTemplateHandler::KateTemplateHandler(
, m_initOk( false )
, m_recursion( false )
{
connect( m_doc, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( slotDocumentDestroyed() ) );
connect( m_doc, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( slotDocumentDestroyed() ) );
m_ranges = new KateSuperRangeList( false, this ); //false/*,this*/);
if ( !m_doc->setTabInterceptor( this ) )
@ -116,13 +116,13 @@ KateTemplateHandler::KateTemplateHandler(
m_doc->tagLines( ( *it ) ->start().line(), ( *it ) ->end().line() );
}
/* connect(doc,TQT_SIGNAL(charactersInteractivelyInserted(int ,int ,const TQString&)),this,
TQT_SLOT(slotCharactersInteractivlyInserted(int,int,const TQString&)));
connect(doc,TQT_SIGNAL(charactersSemiInteractivelyInserted(int ,int ,const TQString&)),this,
TQT_SLOT(slotCharactersInteractivlyInserted(int,int,const TQString&)));*/
connect( doc, TQT_SIGNAL( textInserted( int, int ) ), this, TQT_SLOT( slotTextInserted( int, int ) ) );
connect( doc, TQT_SIGNAL( aboutToRemoveText( const KateTextRange& ) ), this, TQT_SLOT( slotAboutToRemoveText( const KateTextRange& ) ) );
connect( doc, TQT_SIGNAL( textRemoved() ), this, TQT_SLOT( slotTextRemoved() ) );
/* connect(doc,TQ_SIGNAL(charactersInteractivelyInserted(int ,int ,const TQString&)),this,
TQ_SLOT(slotCharactersInteractivlyInserted(int,int,const TQString&)));
connect(doc,TQ_SIGNAL(charactersSemiInteractivelyInserted(int ,int ,const TQString&)),this,
TQ_SLOT(slotCharactersInteractivlyInserted(int,int,const TQString&)));*/
connect( doc, TQ_SIGNAL( textInserted( int, int ) ), this, TQ_SLOT( slotTextInserted( int, int ) ) );
connect( doc, TQ_SIGNAL( aboutToRemoveText( const KateTextRange& ) ), this, TQ_SLOT( slotAboutToRemoveText( const KateTextRange& ) ) );
connect( doc, TQ_SIGNAL( textRemoved() ), this, TQ_SLOT( slotTextRemoved() ) );
( *this ) ( TQt::Key_Tab );
}
@ -324,9 +324,9 @@ void KateTemplateHandler::slotAboutToRemoveText( const KateTextRange &range )
if ( m_doc )
{
disconnect( m_doc, TQT_SIGNAL( textInserted( int, int ) ), this, TQT_SLOT( slotTextInserted( int, int ) ) );
disconnect( m_doc, TQT_SIGNAL( aboutToRemoveText( const KateTextRange& ) ), this, TQT_SLOT( slotAboutToRemoveText( const KateTextRange& ) ) );
disconnect( m_doc, TQT_SIGNAL( textRemoved() ), this, TQT_SLOT( slotTextRemoved() ) );
disconnect( m_doc, TQ_SIGNAL( textInserted( int, int ) ), this, TQ_SLOT( slotTextInserted( int, int ) ) );
disconnect( m_doc, TQ_SIGNAL( aboutToRemoveText( const KateTextRange& ) ), this, TQ_SLOT( slotAboutToRemoveText( const KateTextRange& ) ) );
disconnect( m_doc, TQ_SIGNAL( textRemoved() ), this, TQ_SLOT( slotTextRemoved() ) );
}
deleteLater();

@ -159,8 +159,8 @@ KateView::KateView( KateDocument *doc, TQWidget *parent, const char * name )
slotHlChanged();
/*test texthint
connect(this,TQT_SIGNAL(needTextHint(int, int, TQString &)),
this,TQT_SLOT(slotNeedTextHint(int, int, TQString &)));
connect(this,TQ_SIGNAL(needTextHint(int, int, TQString &)),
this,TQ_SLOT(slotNeedTextHint(int, int, TQString &)));
enableTextHints(1000);
test texthint*/
}
@ -186,22 +186,22 @@ KateView::~KateView()
void KateView::setupConnections()
{
connect( m_doc, TQT_SIGNAL(undoChanged()),
this, TQT_SLOT(slotNewUndo()) );
connect( m_doc, TQT_SIGNAL(hlChanged()),
this, TQT_SLOT(slotHlChanged()) );
connect( m_doc, TQT_SIGNAL(canceled(const TQString&)),
this, TQT_SLOT(slotSaveCanceled(const TQString&)) );
connect( m_viewInternal, TQT_SIGNAL(dropEventPass(TQDropEvent*)),
this, TQT_SIGNAL(dropEventPass(TQDropEvent*)) );
connect(this,TQT_SIGNAL(cursorPositionChanged()),this,TQT_SLOT(slotStatusMsg()));
connect(this,TQT_SIGNAL(newStatus()),this,TQT_SLOT(slotStatusMsg()));
connect(m_doc, TQT_SIGNAL(undoChanged()), this, TQT_SLOT(slotStatusMsg()));
connect( m_doc, TQ_SIGNAL(undoChanged()),
this, TQ_SLOT(slotNewUndo()) );
connect( m_doc, TQ_SIGNAL(hlChanged()),
this, TQ_SLOT(slotHlChanged()) );
connect( m_doc, TQ_SIGNAL(canceled(const TQString&)),
this, TQ_SLOT(slotSaveCanceled(const TQString&)) );
connect( m_viewInternal, TQ_SIGNAL(dropEventPass(TQDropEvent*)),
this, TQ_SIGNAL(dropEventPass(TQDropEvent*)) );
connect(this,TQ_SIGNAL(cursorPositionChanged()),this,TQ_SLOT(slotStatusMsg()));
connect(this,TQ_SIGNAL(newStatus()),this,TQ_SLOT(slotStatusMsg()));
connect(m_doc, TQ_SIGNAL(undoChanged()), this, TQ_SLOT(slotStatusMsg()));
if ( m_doc->browserView() )
{
connect( this, TQT_SIGNAL(dropEventPass(TQDropEvent*)),
this, TQT_SLOT(slotDropEventPass(TQDropEvent*)) );
connect( this, TQ_SIGNAL(dropEventPass(TQDropEvent*)),
this, TQ_SLOT(slotDropEventPass(TQDropEvent*)) );
}
}
@ -212,84 +212,84 @@ void KateView::setupActions()
m_toggleWriteLock = 0;
m_cut = a=KStdAction::cut(this, TQT_SLOT(cut()), ac);
m_cut = a=KStdAction::cut(this, TQ_SLOT(cut()), ac);
a->setWhatsThis(i18n("Cut the selected text and move it to the clipboard"));
m_paste = a=KStdAction::pasteText(this, TQT_SLOT(paste()), ac);
m_paste = a=KStdAction::pasteText(this, TQ_SLOT(paste()), ac);
a->setWhatsThis(i18n("Paste previously copied or cut clipboard contents"));
m_copy = a=KStdAction::copy(this, TQT_SLOT(copy()), ac);
m_copy = a=KStdAction::copy(this, TQ_SLOT(copy()), ac);
a->setWhatsThis(i18n( "Use this command to copy the currently selected text to the system clipboard."));
m_copyHTML = a = new TDEAction(i18n("Copy as &HTML"), "edit-copy", 0, this, TQT_SLOT(copyHTML()), ac, "edit_copy_html");
m_copyHTML = a = new TDEAction(i18n("Copy as &HTML"), "edit-copy", 0, this, TQ_SLOT(copyHTML()), ac, "edit_copy_html");
a->setWhatsThis(i18n( "Use this command to copy the currently selected text as HTML to the system clipboard."));
if (!m_doc->readOnly())
{
a=KStdAction::save(this, TQT_SLOT(save()), ac);
a=KStdAction::save(this, TQ_SLOT(save()), ac);
a->setWhatsThis(i18n("Save the current document"));
a=m_editUndo = KStdAction::undo(m_doc, TQT_SLOT(undo()), ac);
a=m_editUndo = KStdAction::undo(m_doc, TQ_SLOT(undo()), ac);
a->setWhatsThis(i18n("Revert the most recent editing actions"));
a=m_editRedo = KStdAction::redo(m_doc, TQT_SLOT(redo()), ac);
a=m_editRedo = KStdAction::redo(m_doc, TQ_SLOT(redo()), ac);
a->setWhatsThis(i18n("Revert the most recent undo operation"));
(new TDEAction(i18n("&Word Wrap Document"), "", 0, this, TQT_SLOT(applyWordWrap()), ac, "tools_apply_wordwrap"))->setWhatsThis(
(new TDEAction(i18n("&Word Wrap Document"), "", 0, this, TQ_SLOT(applyWordWrap()), ac, "tools_apply_wordwrap"))->setWhatsThis(
i18n("Use this command to wrap all lines of the current document which are longer than the width of the"
" current view, to fit into this view.<br><br> This is a static word wrap, meaning it is not updated"
" when the view is resized."));
// setup Tools menu
a=new TDEAction(i18n("&Indent"), "format-indent-more", TQt::CTRL+TQt::Key_I, this, TQT_SLOT(indent()), ac, "tools_indent");
a=new TDEAction(i18n("&Indent"), "format-indent-more", TQt::CTRL+TQt::Key_I, this, TQ_SLOT(indent()), ac, "tools_indent");
a->setWhatsThis(i18n("Use this to indent a selected block of text.<br><br>"
"You can configure whether tabs should be honored and used or replaced with spaces, in the configuration dialog."));
a=new TDEAction(i18n("&Unindent"), "format-indent-less", TQt::CTRL+TQt::SHIFT+TQt::Key_I, this, TQT_SLOT(unIndent()), ac, "tools_unindent");
a=new TDEAction(i18n("&Unindent"), "format-indent-less", TQt::CTRL+TQt::SHIFT+TQt::Key_I, this, TQ_SLOT(unIndent()), ac, "tools_unindent");
a->setWhatsThis(i18n("Use this to unindent a selected block of text."));
a=new TDEAction(i18n("&Clean Indentation"), 0, this, TQT_SLOT(cleanIndent()), ac, "tools_cleanIndent");
a=new TDEAction(i18n("&Clean Indentation"), 0, this, TQ_SLOT(cleanIndent()), ac, "tools_cleanIndent");
a->setWhatsThis(i18n("Use this to clean the indentation of a selected block of text (only tabs/only spaces)<br><br>"
"You can configure whether tabs should be honored and used or replaced with spaces, in the configuration dialog."));
a=new TDEAction(i18n("&Align"), 0, this, TQT_SLOT(align()), ac, "tools_align");
a=new TDEAction(i18n("&Align"), 0, this, TQ_SLOT(align()), ac, "tools_align");
a->setWhatsThis(i18n("Use this to align the current line or block of text to its proper indent level."));
a=new TDEAction(i18n("C&omment"), CTRL+TQt::Key_D, this, TQT_SLOT(comment()),
a=new TDEAction(i18n("C&omment"), CTRL+TQt::Key_D, this, TQ_SLOT(comment()),
ac, "tools_comment");
a->setWhatsThis(i18n("This command comments out the current line or a selected block of text.<BR><BR>"
"The characters for single/multiple line comments are defined within the language's highlighting."));
a=new TDEAction(i18n("Unco&mment"), CTRL+SHIFT+TQt::Key_D, this, TQT_SLOT(uncomment()),
a=new TDEAction(i18n("Unco&mment"), CTRL+SHIFT+TQt::Key_D, this, TQ_SLOT(uncomment()),
ac, "tools_uncomment");
a->setWhatsThis(i18n("This command removes comments from the current line or a selected block of text.<BR><BR>"
"The characters for single/multiple line comments are defined within the language's highlighting."));
a = m_toggleWriteLock = new TDEToggleAction(
i18n("&Read Only Mode"), 0, 0,
this, TQT_SLOT( toggleWriteLock() ),
this, TQ_SLOT( toggleWriteLock() ),
ac, "tools_toggle_write_lock" );
a->setWhatsThis( i18n("Lock/unlock the document for writing") );
a = new TDEAction( i18n("Uppercase"), CTRL + TQt::Key_U, this,
TQT_SLOT(uppercase()), ac, "tools_uppercase" );
TQ_SLOT(uppercase()), ac, "tools_uppercase" );
a->setWhatsThis( i18n("Convert the selection to uppercase, or the character to the "
"right of the cursor if no text is selected.") );
a = new TDEAction( i18n("Lowercase"), CTRL + SHIFT + TQt::Key_U, this,
TQT_SLOT(lowercase()), ac, "tools_lowercase" );
TQ_SLOT(lowercase()), ac, "tools_lowercase" );
a->setWhatsThis( i18n("Convert the selection to lowercase, or the character to the "
"right of the cursor if no text is selected.") );
a = new TDEAction( i18n("Capitalize"), CTRL + ALT + TQt::Key_U, this,
TQT_SLOT(capitalize()), ac, "tools_capitalize" );
TQ_SLOT(capitalize()), ac, "tools_capitalize" );
a->setWhatsThis( i18n("Capitalize the selection, or the word under the "
"cursor if no text is selected.") );
a = new TDEAction( i18n("Delete Line"), 0, this,
TQT_SLOT( killLine() ), ac, "tools_delete_line");
TQ_SLOT( killLine() ), ac, "tools_delete_line");
a->setWhatsThis(i18n("Use this to delete the current line."));
a = new TDEAction( i18n("Join Lines"), CTRL + TQt::Key_J, this,
TQT_SLOT( joinLines() ), ac, "tools_join_lines" );
TQ_SLOT( joinLines() ), ac, "tools_join_lines" );
a->setWhatsThis(i18n("Use this to join lines together."));
}
else
@ -300,19 +300,19 @@ void KateView::setupActions()
m_editRedo = 0;
}
a=KStdAction::print( m_doc, TQT_SLOT(print()), ac );
a=KStdAction::print( m_doc, TQ_SLOT(print()), ac );
a->setWhatsThis(i18n("Print the current document."));
a=new TDEAction(i18n("Reloa&d"), "reload", TDEStdAccel::reload(), this, TQT_SLOT(reloadFile()), ac, "file_reload");
a=new TDEAction(i18n("Reloa&d"), "reload", TDEStdAccel::reload(), this, TQ_SLOT(reloadFile()), ac, "file_reload");
a->setWhatsThis(i18n("Reload the current document from disk."));
a=KStdAction::saveAs(this, TQT_SLOT(saveAs()), ac);
a=KStdAction::saveAs(this, TQ_SLOT(saveAs()), ac);
a->setWhatsThis(i18n("Save the current document to disk, with a name of your choice."));
a=KStdAction::gotoLine(this, TQT_SLOT(gotoLine()), ac);
a=KStdAction::gotoLine(this, TQ_SLOT(gotoLine()), ac);
a->setWhatsThis(i18n("This command opens a dialog and lets you choose a line that you want the cursor to move to."));
a=new TDEAction(i18n("&Configure Editor..."), 0, m_doc, TQT_SLOT(configDialog()),ac, "set_confdlg");
a=new TDEAction(i18n("&Configure Editor..."), 0, m_doc, TQ_SLOT(configDialog()),ac, "set_confdlg");
a->setWhatsThis(i18n("Configure various aspects of this editor."));
KateViewHighlightAction *menu = new KateViewHighlightAction (i18n("&Highlighting"), ac, "set_highlight");
@ -329,45 +329,45 @@ void KateView::setupActions()
new KateViewIndentationAction (m_doc, i18n("&Indentation"),ac,"tools_indentation");
// html export
a = new TDEAction(i18n("E&xport as HTML..."), 0, 0, this, TQT_SLOT(exportAsHTML()), ac, "file_export_html");
a = new TDEAction(i18n("E&xport as HTML..."), 0, 0, this, TQ_SLOT(exportAsHTML()), ac, "file_export_html");
a->setWhatsThis(i18n("This command allows you to export the current document"
" with all highlighting information into a HTML document."));
m_selectAll = a=KStdAction::selectAll(this, TQT_SLOT(selectAll()), ac);
m_selectAll = a=KStdAction::selectAll(this, TQ_SLOT(selectAll()), ac);
a->setWhatsThis(i18n("Select the entire text of the current document."));
m_deSelect = a=KStdAction::deselect(this, TQT_SLOT(clearSelection()), ac);
m_deSelect = a=KStdAction::deselect(this, TQ_SLOT(clearSelection()), ac);
a->setWhatsThis(i18n("If you have selected something within the current document, this will no longer be selected."));
a=new TDEAction(i18n("Enlarge Font"), "zoom-in", 0, m_viewInternal, TQT_SLOT(slotIncFontSizes()), ac, "incFontSizes");
a=new TDEAction(i18n("Enlarge Font"), "zoom-in", 0, m_viewInternal, TQ_SLOT(slotIncFontSizes()), ac, "incFontSizes");
a->setWhatsThis(i18n("This increases the display font size."));
a=new TDEAction(i18n("Shrink Font"), "zoom-out", 0, m_viewInternal, TQT_SLOT(slotDecFontSizes()), ac, "decFontSizes");
a=new TDEAction(i18n("Shrink Font"), "zoom-out", 0, m_viewInternal, TQ_SLOT(slotDecFontSizes()), ac, "decFontSizes");
a->setWhatsThis(i18n("This decreases the display font size."));
a= m_toggleBlockSelection = new TDEToggleAction(
i18n("Bl&ock Selection Mode"), CTRL + SHIFT + Key_B,
this, TQT_SLOT(toggleBlockSelectionMode()),
this, TQ_SLOT(toggleBlockSelectionMode()),
ac, "set_verticalSelect");
a->setWhatsThis(i18n("This command allows switching between the normal (line based) selection mode and the block selection mode."));
a= m_toggleInsert = new TDEToggleAction(
i18n("Overwr&ite Mode"), Key_Insert,
this, TQT_SLOT(toggleInsert()),
this, TQ_SLOT(toggleInsert()),
ac, "set_insert" );
a->setWhatsThis(i18n("Choose whether you want the text you type to be inserted or to overwrite existing text."));
TDEToggleAction *toggleAction;
a= m_toggleDynWrap = toggleAction = new TDEToggleAction(
i18n("&Dynamic Word Wrap"), Key_F10,
this, TQT_SLOT(toggleDynWordWrap()),
this, TQ_SLOT(toggleDynWordWrap()),
ac, "view_dynamic_word_wrap" );
a->setWhatsThis(i18n("If this option is checked, the text lines will be wrapped at the view border on the screen."));
a= m_setDynWrapIndicators = new TDESelectAction(i18n("Dynamic Word Wrap Indicators"), 0, ac, "dynamic_word_wrap_indicators");
a->setWhatsThis(i18n("Choose when the Dynamic Word Wrap Indicators should be displayed"));
connect(m_setDynWrapIndicators, TQT_SIGNAL(activated(int)), this, TQT_SLOT(setDynWrapIndicators(int)));
connect(m_setDynWrapIndicators, TQ_SIGNAL(activated(int)), this, TQ_SLOT(setDynWrapIndicators(int)));
TQStringList list2;
list2.append(i18n("&Off"));
list2.append(i18n("Follow &Line Numbers"));
@ -376,14 +376,14 @@ void KateView::setupActions()
a= toggleAction=m_toggleFoldingMarkers = new TDEToggleAction(
i18n("Show Folding &Markers"), Key_F9,
this, TQT_SLOT(toggleFoldingMarkers()),
this, TQ_SLOT(toggleFoldingMarkers()),
ac, "view_folding_markers" );
a->setWhatsThis(i18n("You can choose if the codefolding marks should be shown, if codefolding is possible."));
toggleAction->setCheckedState(i18n("Hide Folding &Markers"));
a= m_toggleIconBar = toggleAction = new TDEToggleAction(
i18n("Show &Icon Border"), Key_F6,
this, TQT_SLOT(toggleIconBorder()),
this, TQ_SLOT(toggleIconBorder()),
ac, "view_border");
a=toggleAction;
a->setWhatsThis(i18n("Show/hide the icon border.<BR><BR> The icon border shows bookmark symbols, for instance."));
@ -391,21 +391,21 @@ void KateView::setupActions()
a= toggleAction=m_toggleLineNumbers = new TDEToggleAction(
i18n("Show &Line Numbers"), Key_F11,
this, TQT_SLOT(toggleLineNumbersOn()),
this, TQ_SLOT(toggleLineNumbersOn()),
ac, "view_line_numbers" );
a->setWhatsThis(i18n("Show/hide the line numbers on the left hand side of the view."));
toggleAction->setCheckedState(i18n("Hide &Line Numbers"));
a= m_toggleScrollBarMarks = toggleAction = new TDEToggleAction(
i18n("Show Scroll&bar Marks"), 0,
this, TQT_SLOT(toggleScrollBarMarks()),
this, TQ_SLOT(toggleScrollBarMarks()),
ac, "view_scrollbar_marks");
a->setWhatsThis(i18n("Show/hide the marks on the vertical scrollbar.<BR><BR>The marks, for instance, show bookmarks."));
toggleAction->setCheckedState(i18n("Hide Scroll&bar Marks"));
a = toggleAction = m_toggleWWMarker = new TDEToggleAction(
i18n("Show Static &Word Wrap Marker"), 0,
this, TQT_SLOT( toggleWWMarker() ),
this, TQ_SLOT( toggleWWMarker() ),
ac, "view_word_wrap_marker" );
a->setWhatsThis( i18n(
"Show/hide the Word Wrap Marker, a vertical line drawn at the word "
@ -414,7 +414,7 @@ void KateView::setupActions()
a= m_switchCmdLine = new TDEAction(
i18n("Switch to Command Line"), Key_F7,
this, TQT_SLOT(switchToCmdLine()),
this, TQ_SLOT(switchToCmdLine()),
ac, "switch_to_cmd_line" );
a->setWhatsThis(i18n("Show/hide the command line on the bottom of the view."));
@ -426,7 +426,7 @@ void KateView::setupActions()
list.append("&Macintosh");
m_setEndOfLine->setItems(list);
m_setEndOfLine->setCurrentItem (m_doc->config()->eol());
connect(m_setEndOfLine, TQT_SIGNAL(activated(int)), this, TQT_SLOT(setEol(int)));
connect(m_setEndOfLine, TQ_SIGNAL(activated(int)), this, TQ_SLOT(setEol(int)));
// encoding menu
new KateViewEncodingAction (m_doc, this, i18n("E&ncoding"), ac, "set_encoding");
@ -437,7 +437,7 @@ void KateView::setupActions()
slotSelectionChanged ();
connect (this, TQT_SIGNAL(selectionChanged()), this, TQT_SLOT(slotSelectionChanged()));
connect (this, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(slotSelectionChanged()));
}
void KateView::setupEditActions()
@ -447,134 +447,134 @@ void KateView::setupEditActions()
new TDEAction(
i18n("Move Word Left"), CTRL + Key_Left,
this,TQT_SLOT(wordLeft()),
this,TQ_SLOT(wordLeft()),
ac, "word_left" );
new TDEAction(
i18n("Select Character Left"), SHIFT + Key_Left,
this,TQT_SLOT(shiftCursorLeft()),
this,TQ_SLOT(shiftCursorLeft()),
ac, "select_char_left" );
new TDEAction(
i18n("Select Word Left"), SHIFT + CTRL + Key_Left,
this, TQT_SLOT(shiftWordLeft()),
this, TQ_SLOT(shiftWordLeft()),
ac, "select_word_left" );
new TDEAction(
i18n("Move Word Right"), CTRL + Key_Right,
this, TQT_SLOT(wordRight()),
this, TQ_SLOT(wordRight()),
ac, "word_right" );
new TDEAction(
i18n("Select Character Right"), SHIFT + Key_Right,
this, TQT_SLOT(shiftCursorRight()),
this, TQ_SLOT(shiftCursorRight()),
ac, "select_char_right" );
new TDEAction(
i18n("Select Word Right"), SHIFT + CTRL + Key_Right,
this,TQT_SLOT(shiftWordRight()),
this,TQ_SLOT(shiftWordRight()),
ac, "select_word_right" );
new TDEAction(
i18n("Move to Beginning of Line"), Key_Home,
this, TQT_SLOT(home()),
this, TQ_SLOT(home()),
ac, "beginning_of_line" );
new TDEAction(
i18n("Move to Beginning of Document"), TDEStdAccel::home(),
this, TQT_SLOT(top()),
this, TQ_SLOT(top()),
ac, "beginning_of_document" );
new TDEAction(
i18n("Select to Beginning of Line"), SHIFT + Key_Home,
this, TQT_SLOT(shiftHome()),
this, TQ_SLOT(shiftHome()),
ac, "select_beginning_of_line" );
new TDEAction(
i18n("Select to Beginning of Document"), SHIFT + CTRL + Key_Home,
this, TQT_SLOT(shiftTop()),
this, TQ_SLOT(shiftTop()),
ac, "select_beginning_of_document" );
new TDEAction(
i18n("Move to End of Line"), Key_End,
this, TQT_SLOT(end()),
this, TQ_SLOT(end()),
ac, "end_of_line" );
new TDEAction(
i18n("Move to End of Document"), TDEStdAccel::end(),
this, TQT_SLOT(bottom()),
this, TQ_SLOT(bottom()),
ac, "end_of_document" );
new TDEAction(
i18n("Select to End of Line"), SHIFT + Key_End,
this, TQT_SLOT(shiftEnd()),
this, TQ_SLOT(shiftEnd()),
ac, "select_end_of_line" );
new TDEAction(
i18n("Select to End of Document"), SHIFT + CTRL + Key_End,
this, TQT_SLOT(shiftBottom()),
this, TQ_SLOT(shiftBottom()),
ac, "select_end_of_document" );
new TDEAction(
i18n("Select to Previous Line"), SHIFT + Key_Up,
this, TQT_SLOT(shiftUp()),
this, TQ_SLOT(shiftUp()),
ac, "select_line_up" );
new TDEAction(
i18n("Scroll Line Up"),"", CTRL + Key_Up,
this, TQT_SLOT(scrollUp()),
this, TQ_SLOT(scrollUp()),
ac, "scroll_line_up" );
new TDEAction(i18n("Move to Next Line"), Key_Down, this, TQT_SLOT(down()),
new TDEAction(i18n("Move to Next Line"), Key_Down, this, TQ_SLOT(down()),
ac, "move_line_down");
new TDEAction(i18n("Move to Previous Line"), Key_Up, this, TQT_SLOT(up()),
new TDEAction(i18n("Move to Previous Line"), Key_Up, this, TQ_SLOT(up()),
ac, "move_line_up");
new TDEAction(i18n("Move Character Right"), Key_Right, this,
TQT_SLOT(cursorRight()), ac, "move_cursor_right");
TQ_SLOT(cursorRight()), ac, "move_cursor_right");
new TDEAction(i18n("Move Character Left"), Key_Left, this, TQT_SLOT(cursorLeft()),
new TDEAction(i18n("Move Character Left"), Key_Left, this, TQ_SLOT(cursorLeft()),
ac, "move_cusor_left");
new TDEAction(
i18n("Select to Next Line"), SHIFT + Key_Down,
this, TQT_SLOT(shiftDown()),
this, TQ_SLOT(shiftDown()),
ac, "select_line_down" );
new TDEAction(
i18n("Scroll Line Down"), CTRL + Key_Down,
this, TQT_SLOT(scrollDown()),
this, TQ_SLOT(scrollDown()),
ac, "scroll_line_down" );
new TDEAction(
i18n("Scroll Page Up"), TDEStdAccel::prior(),
this, TQT_SLOT(pageUp()),
this, TQ_SLOT(pageUp()),
ac, "scroll_page_up" );
new TDEAction(
i18n("Select Page Up"), SHIFT + Key_PageUp,
this, TQT_SLOT(shiftPageUp()),
this, TQ_SLOT(shiftPageUp()),
ac, "select_page_up" );
new TDEAction(
i18n("Move to Top of View"), CTRL + Key_PageUp,
this, TQT_SLOT(topOfView()),
this, TQ_SLOT(topOfView()),
ac, "move_top_of_view" );
new TDEAction(
i18n("Select to Top of View"), CTRL + SHIFT + Key_PageUp,
this, TQT_SLOT(shiftTopOfView()),
this, TQ_SLOT(shiftTopOfView()),
ac, "select_top_of_view" );
new TDEAction(
i18n("Scroll Page Down"), TDEStdAccel::next(),
this, TQT_SLOT(pageDown()),
this, TQ_SLOT(pageDown()),
ac, "scroll_page_down" );
new TDEAction(
i18n("Select Page Down"), SHIFT + Key_PageDown,
this, TQT_SLOT(shiftPageDown()),
this, TQ_SLOT(shiftPageDown()),
ac, "select_page_down" );
new TDEAction(
i18n("Move to Bottom of View"), CTRL + Key_PageDown,
this, TQT_SLOT(bottomOfView()),
this, TQ_SLOT(bottomOfView()),
ac, "move_bottom_of_view" );
new TDEAction(
i18n("Select to Bottom of View"), CTRL + SHIFT + Key_PageDown,
this, TQT_SLOT(shiftBottomOfView()),
this, TQ_SLOT(shiftBottomOfView()),
ac, "select_bottom_of_view" );
new TDEAction(
i18n("Move to Matching Bracket"), CTRL + Key_6,
this, TQT_SLOT(toMatchingBracket()),
this, TQ_SLOT(toMatchingBracket()),
ac, "to_matching_bracket" );
new TDEAction(
i18n("Select to Matching Bracket"), SHIFT + CTRL + Key_6,
this, TQT_SLOT(shiftToMatchingBracket()),
this, TQ_SLOT(shiftToMatchingBracket()),
ac, "select_matching_bracket" );
// anders: shortcuts doing any changes should not be created in browserextension
@ -582,40 +582,40 @@ void KateView::setupEditActions()
{
new TDEAction(
i18n("Transpose Characters"), CTRL + Key_T,
this, TQT_SLOT(transpose()),
this, TQ_SLOT(transpose()),
ac, "transpose_char" );
new TDEAction(
i18n("Delete Line"), CTRL + Key_K,
this, TQT_SLOT(killLine()),
this, TQ_SLOT(killLine()),
ac, "delete_line" );
new TDEAction(
i18n("Delete Word Left"), TDEStdAccel::deleteWordBack(),
this, TQT_SLOT(deleteWordLeft()),
this, TQ_SLOT(deleteWordLeft()),
ac, "delete_word_left" );
new TDEAction(
i18n("Delete Word Right"), TDEStdAccel::deleteWordForward(),
this, TQT_SLOT(deleteWordRight()),
this, TQ_SLOT(deleteWordRight()),
ac, "delete_word_right" );
new TDEAction(i18n("Delete Next Character"), Key_Delete,
this, TQT_SLOT(keyDelete()),
this, TQ_SLOT(keyDelete()),
ac, "delete_next_character");
TDEAction *a = new TDEAction(i18n("Backspace"), Key_Backspace,
this, TQT_SLOT(backspace()),
this, TQ_SLOT(backspace()),
ac, "backspace");
TDEShortcut cut = a->shortcut();
cut.append( KKey( SHIFT + Key_Backspace ) );
a->setShortcut( cut );
}
connect( this, TQT_SIGNAL(gotFocus(Kate::View*)),
this, TQT_SLOT(slotGotFocus()) );
connect( this, TQT_SIGNAL(lostFocus(Kate::View*)),
this, TQT_SLOT(slotLostFocus()) );
connect( this, TQ_SIGNAL(gotFocus(Kate::View*)),
this, TQ_SLOT(slotGotFocus()) );
connect( this, TQ_SIGNAL(lostFocus(Kate::View*)),
this, TQ_SLOT(slotLostFocus()) );
m_editActions->readShortcutSettings( "Katepart Shortcuts" );
@ -631,18 +631,18 @@ void KateView::setupCodeFolding()
{
TDEActionCollection *ac=this->actionCollection();
new TDEAction( i18n("Collapse Toplevel"), CTRL+SHIFT+Key_Minus,
m_doc->foldingTree(),TQT_SLOT(collapseToplevelNodes()),ac,"folding_toplevel");
m_doc->foldingTree(),TQ_SLOT(collapseToplevelNodes()),ac,"folding_toplevel");
new TDEAction( i18n("Expand Toplevel"), CTRL+SHIFT+Key_Plus,
this,TQT_SLOT(slotExpandToplevel()),ac,"folding_expandtoplevel");
this,TQ_SLOT(slotExpandToplevel()),ac,"folding_expandtoplevel");
new TDEAction( i18n("Collapse One Local Level"), CTRL+Key_Minus,
this,TQT_SLOT(slotCollapseLocal()),ac,"folding_collapselocal");
this,TQ_SLOT(slotCollapseLocal()),ac,"folding_collapselocal");
new TDEAction( i18n("Expand One Local Level"), CTRL+Key_Plus,
this,TQT_SLOT(slotExpandLocal()),ac,"folding_expandlocal");
this,TQ_SLOT(slotExpandLocal()),ac,"folding_expandlocal");
#ifdef DEBUGACCELS
TDEAccel* debugAccels = new TDEAccel(this,this);
debugAccels->insert("KATE_DUMP_REGION_TREE",i18n("Show the code folding region tree"),"","Ctrl+Shift+Alt+D",m_doc,TQT_SLOT(dumpRegionTree()));
debugAccels->insert("KATE_TEMPLATE_TEST",i18n("Basic template code test"),"","Ctrl+Shift+Alt+T",m_doc,TQT_SLOT(testTemplateCode()));
debugAccels->insert("KATE_DUMP_REGION_TREE",i18n("Show the code folding region tree"),"","Ctrl+Shift+Alt+D",m_doc,TQ_SLOT(dumpRegionTree()));
debugAccels->insert("KATE_TEMPLATE_TEST",i18n("Basic template code test"),"","Ctrl+Shift+Alt+T",m_doc,TQ_SLOT(testTemplateCode()));
debugAccels->setEnabled(true);
#endif
}
@ -669,16 +669,16 @@ void KateView::slotExpandLocal()
void KateView::setupCodeCompletion()
{
m_codeCompletion = new KateCodeCompletion(this);
connect( m_codeCompletion, TQT_SIGNAL(completionAborted()),
this, TQT_SIGNAL(completionAborted()));
connect( m_codeCompletion, TQT_SIGNAL(completionDone()),
this, TQT_SIGNAL(completionDone()));
connect( m_codeCompletion, TQT_SIGNAL(argHintHidden()),
this, TQT_SIGNAL(argHintHidden()));
connect( m_codeCompletion, TQT_SIGNAL(completionDone(KTextEditor::CompletionEntry)),
this, TQT_SIGNAL(completionDone(KTextEditor::CompletionEntry)));
connect( m_codeCompletion, TQT_SIGNAL(filterInsertString(KTextEditor::CompletionEntry*,TQString*)),
this, TQT_SIGNAL(filterInsertString(KTextEditor::CompletionEntry*,TQString*)));
connect( m_codeCompletion, TQ_SIGNAL(completionAborted()),
this, TQ_SIGNAL(completionAborted()));
connect( m_codeCompletion, TQ_SIGNAL(completionDone()),
this, TQ_SIGNAL(completionDone()));
connect( m_codeCompletion, TQ_SIGNAL(argHintHidden()),
this, TQ_SIGNAL(argHintHidden()));
connect( m_codeCompletion, TQ_SIGNAL(completionDone(KTextEditor::CompletionEntry)),
this, TQ_SIGNAL(completionDone(KTextEditor::CompletionEntry)));
connect( m_codeCompletion, TQ_SIGNAL(filterInsertString(KTextEditor::CompletionEntry*,TQString*)),
this, TQ_SIGNAL(filterInsertString(KTextEditor::CompletionEntry*,TQString*)));
}
void KateView::slotGotFocus()

@ -65,8 +65,8 @@ KateScrollBar::KateScrollBar (Orientation orientation, KateViewInternal* parent,
, m_savVisibleLines(0)
, m_showMarks(false)
{
connect(this, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(sliderMaybeMoved(int)));
connect(m_doc, TQT_SIGNAL(marksChanged()), this, TQT_SLOT(marksChanged()));
connect(this, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(sliderMaybeMoved(int)));
connect(m_doc, TQ_SIGNAL(marksChanged()), this, TQ_SLOT(marksChanged()));
m_lines.setAutoDelete(true);
}
@ -295,8 +295,8 @@ KateCmdLine::KateCmdLine (KateView *view)
, m_command( 0L )
, m_oldCompletionObject( 0L )
{
connect (this, TQT_SIGNAL(returnPressed(const TQString &)),
this, TQT_SLOT(slotReturnPressed(const TQString &)));
connect (this, TQ_SIGNAL(returnPressed(const TQString &)),
this, TQ_SLOT(slotReturnPressed(const TQString &)));
completionObject()->insertItems (KateCmd::self()->cmds());
setAutoDeleteCompletionObject( false );
@ -375,7 +375,7 @@ void KateCmdLine::slotReturnPressed ( const TQString& text )
m_cmdend = 0;
m_view->setFocus ();
TQTimer::singleShot( 4000, this, TQT_SLOT(hideMe()) );
TQTimer::singleShot( 4000, this, TQ_SLOT(hideMe()) );
}
void KateCmdLine::hideMe () // unless i have focus ;)
@ -716,7 +716,7 @@ void KateIconBorder::setIconBorderOn( bool enable )
updateGeometry();
TQTimer::singleShot( 0, this, TQT_SLOT(update()) );
TQTimer::singleShot( 0, this, TQ_SLOT(update()) );
}
void KateIconBorder::setLineNumbersOn( bool enable )
@ -729,7 +729,7 @@ void KateIconBorder::setLineNumbersOn( bool enable )
updateGeometry();
TQTimer::singleShot( 0, this, TQT_SLOT(update()) );
TQTimer::singleShot( 0, this, TQ_SLOT(update()) );
}
void KateIconBorder::setDynWrapIndicators( int state )
@ -742,7 +742,7 @@ void KateIconBorder::setDynWrapIndicators( int state )
updateGeometry ();
TQTimer::singleShot( 0, this, TQT_SLOT(update()) );
TQTimer::singleShot( 0, this, TQ_SLOT(update()) );
}
void KateIconBorder::setFoldingMarkersOn( bool enable )
@ -754,7 +754,7 @@ void KateIconBorder::setFoldingMarkersOn( bool enable )
updateGeometry();
TQTimer::singleShot( 0, this, TQT_SLOT(update()) );
TQTimer::singleShot( 0, this, TQ_SLOT(update()) );
}
TQSize KateIconBorder::sizeHint() const
@ -1170,7 +1170,7 @@ void KateIconBorder::showMarkMenu( uint line, const TQPoint& pos )
KateViewEncodingAction::KateViewEncodingAction(KateDocument *_doc, KateView *_view, const TQString& text, TQObject* parent, const char* name)
: TDEActionMenu (text, parent, name), doc(_doc), view (_view)
{
connect(popupMenu(),TQT_SIGNAL(aboutToShow()),this,TQT_SLOT(slotAboutToShow()));
connect(popupMenu(),TQ_SIGNAL(aboutToShow()),this,TQ_SLOT(slotAboutToShow()));
}
void KateViewEncodingAction::slotAboutToShow()
@ -1180,7 +1180,7 @@ void KateViewEncodingAction::slotAboutToShow()
popupMenu()->clear ();
for (uint z=0; z<modes.size(); ++z)
{
popupMenu()->insertItem ( modes[z], this, TQT_SLOT(setMode(int)), 0, z);
popupMenu()->insertItem ( modes[z], this, TQ_SLOT(setMode(int)), 0, z);
bool found = false;
TQTextCodec *codecForEnc = TDEGlobal::charsets()->codecForName(TDEGlobal::charsets()->encodingForName(modes[z]), found);

@ -116,14 +116,14 @@ KateViewInternal::KateViewInternal(KateView *view, KateDocument *doc)
m_lineLayout->addWidget(m_dummy);
// Hijack the line scroller's controls, so we can scroll nicely for word-wrap
connect(m_lineScroll, TQT_SIGNAL(prevPage()), TQT_SLOT(scrollPrevPage()));
connect(m_lineScroll, TQT_SIGNAL(nextPage()), TQT_SLOT(scrollNextPage()));
connect(m_lineScroll, TQ_SIGNAL(prevPage()), TQ_SLOT(scrollPrevPage()));
connect(m_lineScroll, TQ_SIGNAL(nextPage()), TQ_SLOT(scrollNextPage()));
connect(m_lineScroll, TQT_SIGNAL(prevLine()), TQT_SLOT(scrollPrevLine()));
connect(m_lineScroll, TQT_SIGNAL(nextLine()), TQT_SLOT(scrollNextLine()));
connect(m_lineScroll, TQ_SIGNAL(prevLine()), TQ_SLOT(scrollPrevLine()));
connect(m_lineScroll, TQ_SIGNAL(nextLine()), TQ_SLOT(scrollNextLine()));
connect(m_lineScroll, TQT_SIGNAL(sliderMoved(int)), TQT_SLOT(scrollLines(int)));
connect(m_lineScroll, TQT_SIGNAL(sliderMMBMoved(int)), TQT_SLOT(scrollLines(int)));
connect(m_lineScroll, TQ_SIGNAL(sliderMoved(int)), TQ_SLOT(scrollLines(int)));
connect(m_lineScroll, TQ_SIGNAL(sliderMMBMoved(int)), TQ_SLOT(scrollLines(int)));
// catch wheel events, completing the hijack
m_lineScroll->installEventFilter(this);
@ -142,8 +142,8 @@ KateViewInternal::KateViewInternal(KateView *view, KateDocument *doc)
m_columnScroll->setTracking(true);
m_startX = 0;
connect( m_columnScroll, TQT_SIGNAL( valueChanged (int) ),
this, TQT_SLOT( scrollColumns (int) ) );
connect( m_columnScroll, TQ_SIGNAL( valueChanged (int) ),
this, TQ_SLOT( scrollColumns (int) ) );
//
// iconborder ;)
@ -151,13 +151,13 @@ KateViewInternal::KateViewInternal(KateView *view, KateDocument *doc)
leftBorder = new KateIconBorder( this, m_view );
leftBorder->show ();
connect( leftBorder, TQT_SIGNAL(toggleRegionVisibility(unsigned int)),
m_doc->foldingTree(), TQT_SLOT(toggleRegionVisibility(unsigned int)));
connect( leftBorder, TQ_SIGNAL(toggleRegionVisibility(unsigned int)),
m_doc->foldingTree(), TQ_SLOT(toggleRegionVisibility(unsigned int)));
connect( doc->foldingTree(), TQT_SIGNAL(regionVisibilityChangedAt(unsigned int)),
this, TQT_SLOT(slotRegionVisibilityChangedAt(unsigned int)));
connect( doc, TQT_SIGNAL(codeFoldingUpdated()),
this, TQT_SLOT(slotCodeFoldingChanged()) );
connect( doc->foldingTree(), TQ_SIGNAL(regionVisibilityChangedAt(unsigned int)),
this, TQ_SLOT(slotRegionVisibilityChangedAt(unsigned int)));
connect( doc, TQ_SIGNAL(codeFoldingUpdated()),
this, TQ_SLOT(slotCodeFoldingChanged()) );
displayCursor.setPos(0, 0);
cursor.setPos(0, 0);
@ -182,21 +182,21 @@ KateViewInternal::KateViewInternal(KateView *view, KateDocument *doc)
dragInfo.state = diNone;
// timers
connect( &m_dragScrollTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( doDragScroll() ) );
connect( &m_dragScrollTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( doDragScroll() ) );
connect( &m_scrollTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( scrollTimeout() ) );
connect( &m_scrollTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( scrollTimeout() ) );
connect( &m_cursorTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( cursorTimeout() ) );
connect( &m_cursorTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( cursorTimeout() ) );
connect( &m_textHintTimer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( textHintTimeout() ) );
connect( &m_textHintTimer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( textHintTimeout() ) );
// selection changed to set anchor
connect( m_view, TQT_SIGNAL( selectionChanged() ),
this, TQT_SLOT( viewSelectionChanged() ) );
connect( m_view, TQ_SIGNAL( selectionChanged() ),
this, TQ_SLOT( viewSelectionChanged() ) );
// this is a work arround for RTL desktops
@ -2902,7 +2902,7 @@ void KateViewInternal::mouseDoubleClickEvent(TQMouseEvent *e)
}
possibleTripleClick = true;
TQTimer::singleShot ( TQApplication::doubleClickInterval(), this, TQT_SLOT(tripleClickTimeout()) );
TQTimer::singleShot ( TQApplication::doubleClickInterval(), this, TQ_SLOT(tripleClickTimeout()) );
scrollX = 0;
scrollY = 0;

@ -549,10 +549,10 @@ int main(int argc, char *argv[])
baseDir,
args->getOption("output"),
args->isSet("genoutput"));
TQObject::connect(part->browserExtension(), TQT_SIGNAL(openURLRequest(const KURL &, const KParts::URLArgs &)),
regressionTest, TQT_SLOT(slotOpenURL(const KURL&, const KParts::URLArgs &)));
TQObject::connect(part->browserExtension(), TQT_SIGNAL(resizeTopLevelWidget( int, int )),
regressionTest, TQT_SLOT(resizeTopLevelWidget( int, int )));
TQObject::connect(part->browserExtension(), TQ_SIGNAL(openURLRequest(const KURL &, const KParts::URLArgs &)),
regressionTest, TQ_SLOT(slotOpenURL(const KURL&, const KParts::URLArgs &)));
TQObject::connect(part->browserExtension(), TQ_SIGNAL(resizeTopLevelWidget( int, int )),
regressionTest, TQ_SLOT(resizeTopLevelWidget( int, int )));
regressionTest->m_keepOutput = args->isSet("keep-output");
regressionTest->m_showGui = args->isSet("show");

@ -66,7 +66,7 @@ AutoBookmarker::AutoBookmarker( TQObject *parent,
KTextEditor::ConfigInterfaceExtension()
{
if ( parent )
connect( parent, TQT_SIGNAL( completed() ), this, TQT_SLOT( slotCompleted() ) );
connect( parent, TQ_SIGNAL( completed() ), this, TQ_SLOT( slotCompleted() ) );
}
void AutoBookmarker::addView(KTextEditor::View */*view*/)
@ -292,7 +292,7 @@ AutoBookmarkerEntEditor::AutoBookmarkerEntEditor( TQWidget *parent, AutoBookmark
TQWhatsThis::add( lePattern, i18n(
"<p>A regular expression. Matching lines will be bookmarked.</p>" ) );
connect( lePattern, TQT_SIGNAL(textChanged ( const TQString & ) ),this, TQT_SLOT( slotPatternChanged( const TQString& ) ) );
connect( lePattern, TQ_SIGNAL(textChanged ( const TQString & ) ),this, TQ_SLOT( slotPatternChanged( const TQString& ) ) );
cbCS = new TQCheckBox( i18n("Case &sensitive"), w );
lo->addMultiCellWidget( cbCS, 1, 1, 0, 2 );
@ -334,7 +334,7 @@ AutoBookmarkerEntEditor::AutoBookmarkerEntEditor( TQWidget *parent, AutoBookmark
TQToolButton *btnMTW = new TQToolButton(w);
lo->addWidget( btnMTW, 4, 2 );
btnMTW->setIconSet(TQIconSet(SmallIcon("wizard")));
connect(btnMTW, TQT_SIGNAL(clicked()), this, TQT_SLOT(showMTDlg()));
connect(btnMTW, TQ_SIGNAL(clicked()), this, TQ_SLOT(showMTDlg()));
TQWhatsThis::add( btnMTW, i18n(
"<p>Click this button to display a checkable list of mimetypes available "
"on your system. When used, the file masks entry above will be filled in "
@ -419,10 +419,10 @@ AutoBookmarkerConfigPage::AutoBookmarkerConfigPage( TQWidget *parent, const char
lo1->addStretch( 1 );
connect( btnNew, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNew()) );
connect( btnDel, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotDel()) );
connect( btnEdit, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotEdit()) );
connect( lvPatterns, TQT_SIGNAL(doubleClicked(TQListViewItem *)), this, TQT_SLOT(slotEdit()) );
connect( btnNew, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNew()) );
connect( btnDel, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotDel()) );
connect( btnEdit, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEdit()) );
connect( lvPatterns, TQ_SIGNAL(doubleClicked(TQListViewItem *)), this, TQ_SLOT(slotEdit()) );
m_ents = new ABEntityList();
m_ents->setAutoDelete( true );

@ -76,7 +76,7 @@ InsertFilePluginView::InsertFilePluginView( KTextEditor::View *view, const char
view->insertChildClient( this );
setInstance( KGenericFactory<InsertFilePlugin>::instance() );
_job = 0;
(void) new TDEAction( i18n("Insert File..."), 0, this, TQT_SLOT(slotInsertFile()), actionCollection(), "tools_insert_file" );
(void) new TDEAction( i18n("Insert File..."), 0, this, TQ_SLOT(slotInsertFile()), actionCollection(), "tools_insert_file" );
setXMLFile( "tdetexteditor_insertfileui.rc" );
}
@ -104,7 +104,7 @@ void InsertFilePluginView::slotInsertFile()
KURL destURL;
destURL.setPath( _tmpfile );
_job = TDEIO::file_copy( _file, destURL, 0600, true, false, true );
connect( _job, TQT_SIGNAL( result( TDEIO::Job * ) ), this, TQT_SLOT( slotFinished ( TDEIO::Job * ) ) );
connect( _job, TQ_SIGNAL( result( TDEIO::Job * ) ), this, TQ_SLOT( slotFinished ( TDEIO::Job * ) ) );
}
}

@ -66,11 +66,11 @@ ISearchPluginView::ISearchPluginView( KTextEditor::View *view )
m_searchForwardAction = new TDEAction(
i18n("Search Incrementally"), CTRL+ALT+Key_F,
this, TQT_SLOT(slotSearchForwardAction()),
this, TQ_SLOT(slotSearchForwardAction()),
actionCollection(), "edit_isearch" );
m_searchBackwardAction = new TDEAction(
i18n("Search Incrementally Backwards"), CTRL+ALT+SHIFT+Key_F,
this, TQT_SLOT(slotSearchBackwardAction()),
this, TQ_SLOT(slotSearchBackwardAction()),
actionCollection(), "edit_isearch_reverse" );
m_label = new TQLabel( i18n("I-Search:"), 0L, "tde toolbar widget" );
@ -84,12 +84,12 @@ ISearchPluginView::ISearchPluginView( KTextEditor::View *view )
m_combo->setDuplicatesEnabled( false );
m_combo->setMaximumWidth( 300 );
m_combo->lineEdit()->installEventFilter( this );
connect( m_combo, TQT_SIGNAL(textChanged(const TQString&)),
this, TQT_SLOT(slotTextChanged(const TQString&)) );
connect( m_combo, TQT_SIGNAL(returnPressed(const TQString&)),
this, TQT_SLOT(slotReturnPressed(const TQString&)) );
connect( m_combo, TQT_SIGNAL(aboutToShowContextMenu(TQPopupMenu*)),
this, TQT_SLOT(slotAddContextMenuItems(TQPopupMenu*)) );
connect( m_combo, TQ_SIGNAL(textChanged(const TQString&)),
this, TQ_SLOT(slotTextChanged(const TQString&)) );
connect( m_combo, TQ_SIGNAL(returnPressed(const TQString&)),
this, TQ_SLOT(slotReturnPressed(const TQString&)) );
connect( m_combo, TQ_SIGNAL(aboutToShowContextMenu(TQPopupMenu*)),
this, TQ_SLOT(slotAddContextMenuItems(TQPopupMenu*)) );
m_comboAction = new KWidgetAction(
m_combo,
i18n("Search"), 0, 0, 0,
@ -106,8 +106,8 @@ ISearchPluginView::ISearchPluginView( KTextEditor::View *view )
i18n("Case Sensitive"), TDEShortcut(),
actionCollection(), "isearch_case_sensitive" );
action->setShortcutConfigurable( false );
connect( action, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(setCaseSensitive(bool)) );
connect( action, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(setCaseSensitive(bool)) );
action->setChecked( m_caseSensitive );
optionMenu->insert( action );
@ -115,8 +115,8 @@ ISearchPluginView::ISearchPluginView( KTextEditor::View *view )
i18n("From Beginning"), TDEShortcut(),
actionCollection(), "isearch_from_beginning" );
action->setShortcutConfigurable( false );
connect( action, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(setFromBeginning(bool)) );
connect( action, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(setFromBeginning(bool)) );
action->setChecked( m_fromBeginning );
optionMenu->insert( action );
@ -124,8 +124,8 @@ ISearchPluginView::ISearchPluginView( KTextEditor::View *view )
i18n("Regular Expression"), TDEShortcut(),
actionCollection(), "isearch_reg_exp" );
action->setShortcutConfigurable( false );
connect( action, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(setRegExp(bool)) );
connect( action, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(setRegExp(bool)) );
action->setChecked( m_regExp );
optionMenu->insert( action );
@ -134,8 +134,8 @@ ISearchPluginView::ISearchPluginView( KTextEditor::View *view )
// action = new TDEToggleAction(
// i18n("Auto-Wrap Search"), TDEShortcut(),
// actionCollection(), "isearch_auto_wrap" );
// connect( action, TQT_SIGNAL(toggled(bool)),
// this, TQT_SLOT(setAutoWrap(bool)) );
// connect( action, TQ_SIGNAL(toggled(bool)),
// this, TQ_SLOT(setAutoWrap(bool)) );
// action->setChecked( m_autoWrap );
// optionMenu->insert( action );
@ -410,13 +410,13 @@ void ISearchPluginView::slotAddContextMenuItems( TQPopupMenu *menu )
if( menu ) {
menu->insertSeparator();
menu->insertItem( i18n("Case Sensitive"), this,
TQT_SLOT(setCaseSensitive(bool)));
TQ_SLOT(setCaseSensitive(bool)));
menu->insertItem( i18n("From Beginning"), this,
TQT_SLOT(setFromBeginning(bool)));
TQ_SLOT(setFromBeginning(bool)));
menu->insertItem( i18n("Regular Expression"), this,
TQT_SLOT(setRegExp(bool)));
TQ_SLOT(setRegExp(bool)));
//menu->insertItem( i18n("Auto-Wrap Search"), this,
// TQT_SLOT(setAutoWrap(bool)));
// TQ_SLOT(setAutoWrap(bool)));
}
}

@ -76,7 +76,7 @@ KDataToolPluginView::KDataToolPluginView( KTextEditor::View *view )
setInstance( KGenericFactory<KDataToolPlugin>::instance() );
m_menu = new TDEActionMenu(i18n("Data Tools"), actionCollection(), "popup_dataTool");
connect(m_menu->popupMenu(), TQT_SIGNAL(aboutToShow()), this, TQT_SLOT(aboutToShow()));
connect(m_menu->popupMenu(), TQ_SIGNAL(aboutToShow()), this, TQ_SLOT(aboutToShow()));
setXMLFile("tdetexteditor_kdatatoolui.rc");
m_view = view;
@ -151,7 +151,7 @@ void KDataToolPluginView::aboutToShow()
m_singleWord_line = line;
} else {
m_notAvailable = new TDEAction(i18n("(not available)"), TQString::null, 0, this,
TQT_SLOT(slotNotAvailable()), actionCollection(),"dt_n_av");
TQ_SLOT(slotNotAvailable()), actionCollection(),"dt_n_av");
m_menu->insert(m_notAvailable);
return;
}
@ -165,7 +165,7 @@ void KDataToolPluginView::aboutToShow()
tools += KDataToolInfo::query( "TQString", "application/x-singleword", inst );
m_actionList = KDataToolAction::dataToolActionList( tools, this,
TQT_SLOT( slotToolActivated( const KDataToolInfo &, const TQString & ) ) );
TQ_SLOT( slotToolActivated( const KDataToolInfo &, const TQString & ) ) );
for ( ac = m_actionList.first(); ac; ac = m_actionList.next() ) {
m_menu->insert(ac);
@ -173,7 +173,7 @@ void KDataToolPluginView::aboutToShow()
if( m_actionList.isEmpty() ) {
m_notAvailable = new TDEAction(i18n("(not available)"), TQString::null, 0, this,
TQT_SLOT(slotNotAvailable()), actionCollection(),"dt_n_av");
TQ_SLOT(slotNotAvailable()), actionCollection(),"dt_n_av");
m_menu->insert(m_notAvailable);
}
}

@ -146,15 +146,15 @@ DocWordCompletionPluginView::DocWordCompletionPluginView( uint treshold, bool au
setInstance( KGenericFactory<DocWordCompletionPlugin>::instance() );
(void) new TDEAction( i18n("Reuse Word Above"), CTRL+Key_8, this,
TQT_SLOT(completeBackwards()), actionCollection(), "doccomplete_bw" );
TQ_SLOT(completeBackwards()), actionCollection(), "doccomplete_bw" );
(void) new TDEAction( i18n("Reuse Word Below"), CTRL+Key_9, this,
TQT_SLOT(completeForwards()), actionCollection(), "doccomplete_fw" );
TQ_SLOT(completeForwards()), actionCollection(), "doccomplete_fw" );
(void) new TDEAction( i18n("Pop Up Completion List"), 0, this,
TQT_SLOT(popupCompletionList()), actionCollection(), "doccomplete_pu" );
TQ_SLOT(popupCompletionList()), actionCollection(), "doccomplete_pu" );
(void) new TDEAction( i18n("Shell Completion"), 0, this,
TQT_SLOT(shellComplete()), actionCollection(), "doccomplete_sh" );
TQ_SLOT(shellComplete()), actionCollection(), "doccomplete_sh" );
d->autopopup = new TDEToggleAction( i18n("Automatic Completion Popup"), 0, this,
TQT_SLOT(toggleAutoPopup()), actionCollection(), "enable_autopopup" );
TQ_SLOT(toggleAutoPopup()), actionCollection(), "enable_autopopup" );
d->autopopup->setChecked( autopopup );
toggleAutoPopup();
@ -168,8 +168,8 @@ DocWordCompletionPluginView::DocWordCompletionPluginView( uint treshold, bool au
if ( ! e.isEmpty() )
d->autopopup->setEnabled( e == "true" );
connect( view->document(), TQT_SIGNAL(variableChanged(const TQString &, const TQString &)),
this, TQT_SLOT(slotVariableChanged(const TQString &, const TQString &)) );
connect( view->document(), TQ_SIGNAL(variableChanged(const TQString &, const TQString &)),
this, TQ_SLOT(slotVariableChanged(const TQString &, const TQString &)) );
}
}
@ -203,15 +203,15 @@ void DocWordCompletionPluginView::popupCompletionList( TQString w )
void DocWordCompletionPluginView::toggleAutoPopup()
{
if ( d->autopopup->isChecked() ) {
if ( ! connect( m_view->document(), TQT_SIGNAL(charactersInteractivelyInserted(int ,int ,const TQString&)),
this, TQT_SLOT(autoPopupCompletionList()) ))
if ( ! connect( m_view->document(), TQ_SIGNAL(charactersInteractivelyInserted(int ,int ,const TQString&)),
this, TQ_SLOT(autoPopupCompletionList()) ))
{
connect( m_view->document(), TQT_SIGNAL(textChanged()), this, TQT_SLOT(autoPopupCompletionList()) );
connect( m_view->document(), TQ_SIGNAL(textChanged()), this, TQ_SLOT(autoPopupCompletionList()) );
}
} else {
disconnect( m_view->document(), TQT_SIGNAL(textChanged()), this, TQT_SLOT(autoPopupCompletionList()) );
disconnect( m_view->document(), TQT_SIGNAL(charactersInteractivelyInserted(int ,int ,const TQString&)),
this, TQT_SLOT(autoPopupCompletionList()) );
disconnect( m_view->document(), TQ_SIGNAL(textChanged()), this, TQ_SLOT(autoPopupCompletionList()) );
disconnect( m_view->document(), TQ_SIGNAL(charactersInteractivelyInserted(int ,int ,const TQString&)),
this, TQ_SLOT(autoPopupCompletionList()) );
}
}

@ -110,9 +110,9 @@ Kded::Kded(bool checkUpdates, bool new_startup)
else
cPath = tdesycoca_env;
m_pTimer = new TQTimer(this);
connect(m_pTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(recreate()));
connect(m_pTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(recreate()));
TQTimer::singleShot(100, this, TQT_SLOT(installCrashHandler()));
TQTimer::singleShot(100, this, TQ_SLOT(installCrashHandler()));
m_pDirWatch = 0;
@ -316,7 +316,7 @@ KDEDModule *Kded::loadModule(const KService *s, bool onDemand)
{
m_modules.insert(obj, module);
m_libs.insert(obj, lib);
connect(module, TQT_SIGNAL(moduleDeleted(KDEDModule *)), TQT_SLOT(slotKDEDModuleRemoved(KDEDModule *)));
connect(module, TQ_SIGNAL(moduleDeleted(KDEDModule *)), TQ_SLOT(slotKDEDModuleRemoved(KDEDModule *)));
kdDebug(7020) << "Successfully loaded module '" << obj << "'\n";
return module;
}
@ -400,12 +400,12 @@ void Kded::updateDirWatch()
delete m_pDirWatch;
m_pDirWatch = new KDirWatch;
TQObject::connect( m_pDirWatch, TQT_SIGNAL(dirty(const TQString&)),
this, TQT_SLOT(update(const TQString&)));
TQObject::connect( m_pDirWatch, TQT_SIGNAL(created(const TQString&)),
this, TQT_SLOT(update(const TQString&)));
TQObject::connect( m_pDirWatch, TQT_SIGNAL(deleted(const TQString&)),
this, TQT_SLOT(dirDeleted(const TQString&)));
TQObject::connect( m_pDirWatch, TQ_SIGNAL(dirty(const TQString&)),
this, TQ_SLOT(update(const TQString&)));
TQObject::connect( m_pDirWatch, TQ_SIGNAL(created(const TQString&)),
this, TQ_SLOT(update(const TQString&)));
TQObject::connect( m_pDirWatch, TQ_SIGNAL(deleted(const TQString&)),
this, TQ_SLOT(dirDeleted(const TQString&)));
// For each resource
for( TQStringList::ConstIterator it = m_allResourceDirs.begin();
@ -480,7 +480,7 @@ void Kded::recreate(bool initial)
if (!initial)
{
updateDirWatch(); // Update tree first, to be sure to miss nothing.
runBuildSycoca(this, TQT_SLOT(recreateDone()));
runBuildSycoca(this, TQ_SLOT(recreateDone()));
}
else
{
@ -491,7 +491,7 @@ void Kded::recreate(bool initial)
if(delayedCheck)
{
// do a proper tdesycoca check after a delay
TQTimer::singleShot( 60000, this, TQT_SLOT( runDelayedCheck()));
TQTimer::singleShot( 60000, this, TQ_SLOT( runDelayedCheck()));
m_needDelayedCheck = true;
delayedCheck = false;
}
@ -667,9 +667,9 @@ KUpdateD::KUpdateD()
{
m_pDirWatch = new KDirWatch;
m_pTimer = new TQTimer;
connect(m_pTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(runKonfUpdate()));
TQObject::connect( m_pDirWatch, TQT_SIGNAL(dirty(const TQString&)),
this, TQT_SLOT(slotNewUpdateFile()));
connect(m_pTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(runKonfUpdate()));
TQObject::connect( m_pDirWatch, TQ_SIGNAL(dirty(const TQString&)),
this, TQ_SLOT(slotNewUpdateFile()));
TQStringList dirs = TDEGlobal::dirs()->findDirs("data", "tdeconf_update");
for( TQStringList::ConstIterator it = dirs.begin();
@ -704,7 +704,7 @@ void KUpdateD::slotNewUpdateFile()
KHostnameD::KHostnameD(int pollInterval)
{
m_Timer.start(pollInterval, false /* repetitive */ );
connect(&m_Timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(checkHostname()));
connect(&m_Timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(checkHostname()));
checkHostname();
}
@ -785,7 +785,7 @@ public:
if( Kded::self()->newStartup())
Kded::self()->initModules();
else
TQTimer::singleShot(500, Kded::self(), TQT_SLOT(initModules()));
TQTimer::singleShot(500, Kded::self(), TQ_SLOT(initModules()));
} else
runBuildSycoca();
@ -955,8 +955,8 @@ extern "C" KDE_EXPORT int kdemain(int argc, char *argv[])
(void) new KHostnameD(HostnamePollInterval); // Watch for hostname changes
DCOPClient *client = kapp->dcopClient();
TQObject::connect(client, TQT_SIGNAL(applicationRemoved(const TQCString&)),
kded, TQT_SLOT(slotApplicationRemoved(const TQCString&)));
TQObject::connect(client, TQ_SIGNAL(applicationRemoved(const TQCString&)),
kded, TQ_SLOT(slotApplicationRemoved(const TQCString&)));
client->setNotifications(true);
client->setDaemonMode( true );

@ -41,7 +41,7 @@ KDEDModule::KDEDModule(const TQCString &name) : TQObject(), DCOPObject(name)
d = new KDEDModulePrivate;
d->objMap = 0;
d->timeout = 0;
connect(&(d->timer), TQT_SIGNAL(timeout()), this, TQT_SLOT(idle()));
connect(&(d->timer), TQ_SIGNAL(timeout()), this, TQ_SLOT(idle()));
}
KDEDModule::~KDEDModule()

@ -376,8 +376,8 @@ bool KBuildSycoca::build()
if (!m_trackId.isEmpty())
g_vfolder->setTrackId(m_trackId);
connect(g_vfolder, TQT_SIGNAL(newService(const TQString &, KService **)),
this, TQT_SLOT(slotCreateEntry(const TQString &, KService **)));
connect(g_vfolder, TQ_SIGNAL(newService(const TQString &, KService **)),
this, TQ_SLOT(slotCreateEntry(const TQString &, KService **)));
VFolderMenu::SubMenu *kdeMenu = g_vfolder->parseMenu("tde-applications.menu", true);
@ -390,8 +390,8 @@ bool KBuildSycoca::build()
(void) existingResourceDirs();
*g_allResourceDirs += g_vfolder->allDirectories();
disconnect(g_vfolder, TQT_SIGNAL(newService(const TQString &, KService **)),
this, TQT_SLOT(slotCreateEntry(const TQString &, KService **)));
disconnect(g_vfolder, TQ_SIGNAL(newService(const TQString &, KService **)),
this, TQ_SLOT(slotCreateEntry(const TQString &, KService **)));
if (g_changed || !g_allEntries)
{
@ -790,8 +790,8 @@ extern "C" KDE_EXPORT int kdemain(int argc, char **argv)
while (dcopClient->isApplicationRegistered(appName))
{
WaitForSignal *obj = new WaitForSignal;
obj->connect(dcopClient, TQT_SIGNAL(applicationRemoved(const TQCString &)),
TQT_SLOT(deleteLater()));
obj->connect(dcopClient, TQ_SIGNAL(applicationRemoved(const TQCString &)),
TQ_SLOT(deleteLater()));
kapp->eventLoop()->enterLoop();
}
dcopClient->setNotifications( false );

@ -122,7 +122,7 @@ KBlankEffect::KBlankEffect( TQObject *parent ) : TQObject( parent )
d->currentEffect = &KBlankEffect::blankNormal;
d->effectProgress = 0;
d->timer = new TQTimer( this );
connect( d->timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timeout()) );
connect( d->timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(timeout()) );
}

@ -73,8 +73,8 @@ NetworkStatusModule::NetworkStatusModule( const TQCString & obj ) : KDEDModule(
d = new Private;
/* d->clientIface = new ClientIfaceImpl( this );
d->serviceIface = new ServiceIfaceImpl( this );*/
connect( kapp->dcopClient(), TQT_SIGNAL( applicationRemoved( const TQCString& ) ) , this, TQT_SLOT( unregisteredFromDCOP( const TQCString& ) ) );
connect( kapp->dcopClient(), TQT_SIGNAL( applicationRegistered( const TQCString& ) ) , this, TQT_SLOT( registeredToDCOP( const TQCString& ) ) );
connect( kapp->dcopClient(), TQ_SIGNAL( applicationRemoved( const TQCString& ) ) , this, TQ_SLOT( unregisteredFromDCOP( const TQCString& ) ) );
connect( kapp->dcopClient(), TQ_SIGNAL( applicationRegistered( const TQCString& ) ) , this, TQ_SLOT( registeredToDCOP( const TQCString& ) ) );
}
NetworkStatusModule::~NetworkStatusModule()

@ -38,8 +38,8 @@ StatusBarNetworkStatusIndicator::StatusBarNetworkStatusIndicator(
label->setPixmap( SmallIcon("connect_no") );
TQToolTip::add( label, i18n( "The desktop is offline" ) );
connect( ConnectionManager::self(), TQT_SIGNAL( statusChanged( const TQString &, NetworkStatus::EnumStatus ) ),
TQT_SLOT( networkStatusChanged( const TQString &, NetworkStatus::EnumStatus) ) );
connect( ConnectionManager::self(), TQ_SIGNAL( statusChanged( const TQString &, NetworkStatus::EnumStatus ) ),
TQ_SLOT( networkStatusChanged( const TQString &, NetworkStatus::EnumStatus) ) );
}

@ -58,7 +58,7 @@ int TestService::establish( const TQString & network )
m_status = NetworkStatus::Establishing;
m_service->setNetworkStatus( "test_net", (int)m_status );
m_nextStatus = NetworkStatus::Online;
TQTimer::singleShot( 5000, this, TQT_SLOT( slotStatusChange() ) );
TQTimer::singleShot( 5000, this, TQ_SLOT( slotStatusChange() ) );
return (int)NetworkStatus::RequestAccepted;
}
@ -68,7 +68,7 @@ int TestService::shutdown( const TQString & network )
m_status = NetworkStatus::ShuttingDown;
m_service->setNetworkStatus( "test_net", (int)m_status );
m_nextStatus = NetworkStatus::Offline;
TQTimer::singleShot( 5000, this, TQT_SLOT( slotStatusChange() ) );
TQTimer::singleShot( 5000, this, TQ_SLOT( slotStatusChange() ) );
return (int)NetworkStatus::RequestAccepted;
}

@ -365,8 +365,8 @@ changed. So to make your application aware of changes use the following code:
#include <tdeabc/distributionlist.h>
1: connect( TDEABC::DistributionListWatcher::self(), SIGNAL( changed() ),
2: this, SLOT( slotDistributionListChanged() ) );
1: connect( TDEABC::DistributionListWatcher::self(), TQ_SIGNAL( changed() ),
2: this, TQ_SLOT( slotDistributionListChanged() ) );
You see, as usual, easy ;)

@ -711,15 +711,15 @@ bool AddressBook::addResource( Resource *resource )
d->mManager->add( resource );
resource->setAddressBook( this );
connect( resource, TQT_SIGNAL( loadingFinished( Resource* ) ),
this, TQT_SLOT( resourceLoadingFinished( Resource* ) ) );
connect( resource, TQT_SIGNAL( savingFinished( Resource* ) ),
this, TQT_SLOT( resourceSavingFinished( Resource* ) ) );
connect( resource, TQ_SIGNAL( loadingFinished( Resource* ) ),
this, TQ_SLOT( resourceLoadingFinished( Resource* ) ) );
connect( resource, TQ_SIGNAL( savingFinished( Resource* ) ),
this, TQ_SLOT( resourceSavingFinished( Resource* ) ) );
connect( resource, TQT_SIGNAL( loadingError( Resource*, const TQString& ) ),
this, TQT_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
connect( resource, TQT_SIGNAL( savingError( Resource*, const TQString& ) ),
this, TQT_SLOT( resourceSavingError( Resource*, const TQString& ) ) );
connect( resource, TQ_SIGNAL( loadingError( Resource*, const TQString& ) ),
this, TQ_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
connect( resource, TQ_SIGNAL( savingError( Resource*, const TQString& ) ),
this, TQ_SLOT( resourceSavingError( Resource*, const TQString& ) ) );
return true;
}
@ -733,15 +733,15 @@ bool AddressBook::removeResource( Resource *resource )
resource->setAddressBook( 0 );
disconnect( resource, TQT_SIGNAL( loadingFinished( Resource* ) ),
this, TQT_SLOT( resourceLoadingFinished( Resource* ) ) );
disconnect( resource, TQT_SIGNAL( savingFinished( Resource* ) ),
this, TQT_SLOT( resourceSavingFinished( Resource* ) ) );
disconnect( resource, TQ_SIGNAL( loadingFinished( Resource* ) ),
this, TQ_SLOT( resourceLoadingFinished( Resource* ) ) );
disconnect( resource, TQ_SIGNAL( savingFinished( Resource* ) ),
this, TQ_SLOT( resourceSavingFinished( Resource* ) ) );
disconnect( resource, TQT_SIGNAL( loadingError( Resource*, const TQString& ) ),
this, TQT_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
disconnect( resource, TQT_SIGNAL( savingError( Resource*, const TQString& ) ),
this, TQT_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
disconnect( resource, TQ_SIGNAL( loadingError( Resource*, const TQString& ) ),
this, TQ_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
disconnect( resource, TQ_SIGNAL( savingError( Resource*, const TQString& ) ),
this, TQ_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
d->mManager->remove( resource );

@ -72,15 +72,15 @@ AddresseeDialog::AddresseeDialog( TQWidget *parent, bool multiple ) :
mAddresseeList->setAllColumnsShowFocus( true );
mAddresseeList->setFullWidth( true );
listLayout->addWidget( mAddresseeList );
connect( mAddresseeList, TQT_SIGNAL( doubleClicked( TQListViewItem * ) ),
TQT_SLOT( slotOk() ) );
connect( mAddresseeList, TQT_SIGNAL( selectionChanged( TQListViewItem * ) ),
TQT_SLOT( updateEdit( TQListViewItem * ) ) );
connect( mAddresseeList, TQ_SIGNAL( doubleClicked( TQListViewItem * ) ),
TQ_SLOT( slotOk() ) );
connect( mAddresseeList, TQ_SIGNAL( selectionChanged( TQListViewItem * ) ),
TQ_SLOT( updateEdit( TQListViewItem * ) ) );
mAddresseeEdit = new KLineEdit( topWidget );
mAddresseeEdit->setCompletionMode( TDEGlobalSettings::CompletionAuto );
connect( mAddresseeEdit->completionObject(), TQT_SIGNAL( match( const TQString & ) ),
TQT_SLOT( selectItem( const TQString & ) ) );
connect( mAddresseeEdit->completionObject(), TQ_SIGNAL( match( const TQString & ) ),
TQ_SLOT( selectItem( const TQString & ) ) );
mAddresseeEdit->setFocus();
mAddresseeEdit->completionObject()->setIgnoreCase( true );
listLayout->addWidget( mAddresseeEdit );
@ -101,23 +101,23 @@ AddresseeDialog::AddresseeDialog( TQWidget *parent, bool multiple ) :
mSelectedList->addColumn( i18n("Email") );
mSelectedList->setAllColumnsShowFocus( true );
mSelectedList->setFullWidth( true );
connect( mSelectedList, TQT_SIGNAL( doubleClicked( TQListViewItem * ) ),
TQT_SLOT( removeSelected() ) );
connect( mSelectedList, TQ_SIGNAL( doubleClicked( TQListViewItem * ) ),
TQ_SLOT( removeSelected() ) );
TQPushButton *unselectButton = new TQPushButton( i18n("Unselect"), selectedGroup );
connect ( unselectButton, TQT_SIGNAL( clicked() ), TQT_SLOT( removeSelected() ) );
connect ( unselectButton, TQ_SIGNAL( clicked() ), TQ_SLOT( removeSelected() ) );
connect( mAddresseeList, TQT_SIGNAL( clicked( TQListViewItem * ) ),
TQT_SLOT( addSelected( TQListViewItem * ) ) );
connect( mAddresseeList, TQ_SIGNAL( clicked( TQListViewItem * ) ),
TQ_SLOT( addSelected( TQListViewItem * ) ) );
setInitialSize( TQSize( 650, 350 ) );
}
mAddressBook = StdAddressBook::self( true );
connect( mAddressBook, TQT_SIGNAL( addressBookChanged( AddressBook* ) ),
TQT_SLOT( addressBookChanged() ) );
connect( mAddressBook, TQT_SIGNAL( loadingFinished( Resource* ) ),
TQT_SLOT( addressBookChanged() ) );
connect( mAddressBook, TQ_SIGNAL( addressBookChanged( AddressBook* ) ),
TQ_SLOT( addressBookChanged() ) );
connect( mAddressBook, TQ_SIGNAL( loadingFinished( Resource* ) ),
TQ_SLOT( addressBookChanged() ) );
loadAddressBook();
}

@ -104,22 +104,22 @@ void AddressLineEdit::init()
ldapSearchDeleter.setObject( s_LDAPSearch, new LdapSearch );
ldapTextDeleter.setObject( s_LDAPText, new TQString );
}
connect( s_LDAPTimer, TQT_SIGNAL( timeout()), TQT_SLOT( slotStartLDAPLookup()));
connect( s_LDAPSearch, TQT_SIGNAL( searchData( const TQStringList& )),
TQT_SLOT( slotLDAPSearchData( const TQStringList& )));
connect( s_LDAPTimer, TQ_SIGNAL( timeout()), TQ_SLOT( slotStartLDAPLookup()));
connect( s_LDAPSearch, TQ_SIGNAL( searchData( const TQStringList& )),
TQ_SLOT( slotLDAPSearchData( const TQStringList& )));
}
if ( m_useCompletion && !m_completionInitialized )
{
setCompletionObject( s_completion, false ); // we handle it ourself
connect( this, TQT_SIGNAL( completion(const TQString&)),
this, TQT_SLOT(slotCompletion() ));
connect( this, TQ_SIGNAL( completion(const TQString&)),
this, TQ_SLOT(slotCompletion() ));
TDECompletionBox *box = completionBox();
connect( box, TQT_SIGNAL( highlighted( const TQString& )),
this, TQT_SLOT( slotPopupCompletion( const TQString& ) ));
connect( box, TQT_SIGNAL( userCancelled( const TQString& )),
TQT_SLOT( userCancelled( const TQString& )));
connect( box, TQ_SIGNAL( highlighted( const TQString& )),
this, TQ_SLOT( slotPopupCompletion( const TQString& ) ));
connect( box, TQ_SIGNAL( userCancelled( const TQString& )),
TQ_SLOT( userCancelled( const TQString& )));
m_completionInitialized = true; // don't connect muliple times. That's
// ugly, tho, better have completionBox()

@ -275,7 +275,7 @@ DistributionListWatcher::DistributionListWatcher()
mDirWatch = new KDirWatch;
mDirWatch->addFile( locateLocal( "data", "tdeabc/distlists" ) );
connect( mDirWatch, TQT_SIGNAL( dirty( const TQString& ) ), TQT_SIGNAL( changed() ) );
connect( mDirWatch, TQ_SIGNAL( dirty( const TQString& ) ), TQ_SIGNAL( changed() ) );
mDirWatch->startScan();
}

@ -182,7 +182,7 @@ class KABC_EXPORT DistributionListManager
\code
TDEABC::DistributionListWatcher *watchdog = TDEABC::DistributionListWatcher::self()
connect( watchdog, TQT_SIGNAL( changed() ), TQT_SLOT( doSomething() ) );
connect( watchdog, TQ_SIGNAL( changed() ), TQ_SLOT( doSomething() ) );
\endcode
*/

@ -46,7 +46,7 @@ DistributionListDialog::DistributionListDialog( AddressBook *addressBook, TQWidg
mEditor = new DistributionListEditorWidget( addressBook, this );
setMainWidget( mEditor );
connect( this, TQT_SIGNAL( okClicked() ), mEditor, TQT_SLOT( save() ) );
connect( this, TQ_SIGNAL( okClicked() ), mEditor, TQ_SLOT( save() ) );
}
DistributionListDialog::~DistributionListDialog()
@ -147,19 +147,19 @@ DistributionListEditorWidget::DistributionListEditorWidget( AddressBook *address
mNameCombo = new TQComboBox( this );
nameLayout->addWidget( mNameCombo );
connect( mNameCombo, TQT_SIGNAL( activated( int ) ), TQT_SLOT( updateEntryView() ) );
connect( mNameCombo, TQ_SIGNAL( activated( int ) ), TQ_SLOT( updateEntryView() ) );
mNewButton = new TQPushButton( i18n("New List..."), this );
nameLayout->addWidget( mNewButton );
connect( mNewButton, TQT_SIGNAL( clicked() ), TQT_SLOT( newList() ) );
connect( mNewButton, TQ_SIGNAL( clicked() ), TQ_SLOT( newList() ) );
mEditButton = new TQPushButton( i18n("Rename List..."), this );
nameLayout->addWidget( mEditButton );
connect( mEditButton, TQT_SIGNAL( clicked() ), TQT_SLOT( editList() ) );
connect( mEditButton, TQ_SIGNAL( clicked() ), TQ_SLOT( editList() ) );
mRemoveButton = new TQPushButton( i18n("Remove List"), this );
nameLayout->addWidget( mRemoveButton );
connect( mRemoveButton, TQT_SIGNAL( clicked() ), TQT_SLOT( removeList() ) );
connect( mRemoveButton, TQ_SIGNAL( clicked() ), TQ_SLOT( removeList() ) );
TQGridLayout *gridLayout = new TQGridLayout( topLayout, 3, 3 );
gridLayout->setColStretch(1, 1);
@ -175,15 +175,15 @@ DistributionListEditorWidget::DistributionListEditorWidget( AddressBook *address
mAddresseeView->addColumn( i18n("Preferred Email") );
mAddresseeView->setAllColumnsShowFocus( true );
gridLayout->addWidget( mAddresseeView, 1, 0 );
connect( mAddresseeView, TQT_SIGNAL( selectionChanged() ),
TQT_SLOT( slotSelectionAddresseeViewChanged() ) );
connect( mAddresseeView, TQT_SIGNAL( doubleClicked( TQListViewItem * ) ),
TQT_SLOT( addEntry() ) );
connect( mAddresseeView, TQ_SIGNAL( selectionChanged() ),
TQ_SLOT( slotSelectionAddresseeViewChanged() ) );
connect( mAddresseeView, TQ_SIGNAL( doubleClicked( TQListViewItem * ) ),
TQ_SLOT( addEntry() ) );
mAddEntryButton = new TQPushButton( i18n("Add Entry"), this );
mAddEntryButton->setEnabled(false);
gridLayout->addWidget( mAddEntryButton, 2, 0 );
connect( mAddEntryButton, TQT_SIGNAL( clicked() ), TQT_SLOT( addEntry() ) );
connect( mAddEntryButton, TQ_SIGNAL( clicked() ), TQ_SLOT( addEntry() ) );
mEntryView = new TQListView( this );
mEntryView->addColumn( i18n("Name") );
@ -192,16 +192,16 @@ DistributionListEditorWidget::DistributionListEditorWidget( AddressBook *address
mEntryView->setEnabled(false);
mEntryView->setAllColumnsShowFocus( true );
gridLayout->addMultiCellWidget( mEntryView, 1, 1, 1, 2 );
connect( mEntryView, TQT_SIGNAL( selectionChanged() ),
TQT_SLOT( slotSelectionEntryViewChanged() ) );
connect( mEntryView, TQ_SIGNAL( selectionChanged() ),
TQ_SLOT( slotSelectionEntryViewChanged() ) );
mChangeEmailButton = new TQPushButton( i18n("Change Email..."), this );
gridLayout->addWidget( mChangeEmailButton, 2, 1 );
connect( mChangeEmailButton, TQT_SIGNAL( clicked() ), TQT_SLOT( changeEmail() ) );
connect( mChangeEmailButton, TQ_SIGNAL( clicked() ), TQ_SLOT( changeEmail() ) );
mRemoveEntryButton = new TQPushButton( i18n("Remove Entry"), this );
gridLayout->addWidget( mRemoveEntryButton, 2, 2 );
connect( mRemoveEntryButton, TQT_SIGNAL( clicked() ), TQT_SLOT( removeEntry() ) );
connect( mRemoveEntryButton, TQ_SIGNAL( clicked() ), TQ_SLOT( removeEntry() ) );
mManager = new DistributionListManager( mAddressBook );
mManager->load();

@ -128,34 +128,34 @@ DistributionListEditor::DistributionListEditor( AddressBook *addressBook, TQWidg
mNameCombo = new TQComboBox( this );
nameLayout->addWidget( mNameCombo );
connect( mNameCombo, TQT_SIGNAL( activated( int ) ), TQT_SLOT( updateEntryView() ) );
connect( mNameCombo, TQ_SIGNAL( activated( int ) ), TQ_SLOT( updateEntryView() ) );
newButton = new TQPushButton( i18n("New List"), this );
nameLayout->addWidget( newButton );
connect( newButton, TQT_SIGNAL( clicked() ), TQT_SLOT( newList() ) );
connect( newButton, TQ_SIGNAL( clicked() ), TQ_SLOT( newList() ) );
removeButton = new TQPushButton( i18n("Remove List"), this );
nameLayout->addWidget( removeButton );
connect( removeButton, TQT_SIGNAL( clicked() ), TQT_SLOT( removeList() ) );
connect( removeButton, TQ_SIGNAL( clicked() ), TQ_SLOT( removeList() ) );
mEntryView = new TQListView( this );
mEntryView->addColumn( i18n("Name") );
mEntryView->addColumn( i18n("Email") );
mEntryView->addColumn( i18n("Use Preferred") );
topLayout->addWidget( mEntryView );
connect(mEntryView,TQT_SIGNAL(selectionChanged ()),this, TQT_SLOT(slotSelectionEntryViewChanged()));
connect(mEntryView,TQ_SIGNAL(selectionChanged ()),this, TQ_SLOT(slotSelectionEntryViewChanged()));
changeEmailButton = new TQPushButton( i18n("Change Email"), this );
topLayout->addWidget( changeEmailButton );
connect( changeEmailButton, TQT_SIGNAL( clicked() ), TQT_SLOT( changeEmail() ) );
connect( changeEmailButton, TQ_SIGNAL( clicked() ), TQ_SLOT( changeEmail() ) );
removeEntryButton = new TQPushButton( i18n("Remove Entry"), this );
topLayout->addWidget( removeEntryButton );
connect( removeEntryButton, TQT_SIGNAL( clicked() ), TQT_SLOT( removeEntry() ) );
connect( removeEntryButton, TQ_SIGNAL( clicked() ), TQ_SLOT( removeEntry() ) );
addEntryButton = new TQPushButton( i18n("Add Entry"), this );
topLayout->addWidget( addEntryButton );
connect( addEntryButton, TQT_SIGNAL( clicked() ), TQT_SLOT( addEntry() ) );
connect( addEntryButton, TQ_SIGNAL( clicked() ), TQ_SLOT( addEntry() ) );
mAddresseeView = new TQListView( this );
mAddresseeView->addColumn( i18n("Name") );
@ -163,7 +163,7 @@ DistributionListEditor::DistributionListEditor( AddressBook *addressBook, TQWidg
topLayout->addWidget( mAddresseeView );
connect(mAddresseeView,TQT_SIGNAL(selectionChanged ()),this, TQT_SLOT(slotSelectionAddresseeViewChanged()));
connect(mAddresseeView,TQ_SIGNAL(selectionChanged ()),this, TQ_SLOT(slotSelectionAddresseeViewChanged()));
mManager = new DistributionListManager( mAddressBook );
mManager->load();

@ -138,12 +138,12 @@ void LdapClient::startQuery( const TQString& filter )
startParseLDIF();
mActive = true;
mJob = TDEIO::get( url, false, false );
connect( mJob, TQT_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQT_SLOT( slotData( TDEIO::Job*, const TQByteArray& ) ) );
connect( mJob, TQT_SIGNAL( infoMessage( TDEIO::Job*, const TQString& ) ),
this, TQT_SLOT( slotInfoMessage( TDEIO::Job*, const TQString& ) ) );
connect( mJob, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( slotDone() ) );
connect( mJob, TQ_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQ_SLOT( slotData( TDEIO::Job*, const TQByteArray& ) ) );
connect( mJob, TQ_SIGNAL( infoMessage( TDEIO::Job*, const TQString& ) ),
this, TQ_SLOT( slotInfoMessage( TDEIO::Job*, const TQString& ) ) );
connect( mJob, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( slotDone() ) );
}
void LdapClient::cancelQuery()
@ -285,18 +285,18 @@ LdapSearch::LdapSearch()
attrs << "cn" << "mail" << "givenname" << "sn";
ldapClient->setAttrs( attrs );
connect( ldapClient, TQT_SIGNAL( result( const TDEABC::LdapObject& ) ),
this, TQT_SLOT( slotLDAPResult( const TDEABC::LdapObject& ) ) );
connect( ldapClient, TQT_SIGNAL( done() ),
this, TQT_SLOT( slotLDAPDone() ) );
connect( ldapClient, TQT_SIGNAL( error( const TQString& ) ),
this, TQT_SLOT( slotLDAPError( const TQString& ) ) );
connect( ldapClient, TQ_SIGNAL( result( const TDEABC::LdapObject& ) ),
this, TQ_SLOT( slotLDAPResult( const TDEABC::LdapObject& ) ) );
connect( ldapClient, TQ_SIGNAL( done() ),
this, TQ_SLOT( slotLDAPDone() ) );
connect( ldapClient, TQ_SIGNAL( error( const TQString& ) ),
this, TQ_SLOT( slotLDAPError( const TQString& ) ) );
mClients.append( ldapClient );
}
}
connect( &mDataTimer, TQT_SIGNAL( timeout() ), TQT_SLOT( slotDataTimer() ) );
connect( &mDataTimer, TQ_SIGNAL( timeout() ), TQ_SLOT( slotDataTimer() ) );
}
void LdapSearch::startSearch( const TQString& txt )

@ -180,7 +180,7 @@ void LdapConfigWidget::initWidget()
//without host query doesn't make sense
if ( mHost ) {
TQPushButton *dnquery = new TQPushButton( i18n( "Query Server" ), this );
connect( dnquery, TQT_SIGNAL( clicked() ), TQT_SLOT( mQueryDNClicked() ) );
connect( dnquery, TQ_SIGNAL( clicked() ), TQ_SLOT( mQueryDNClicked() ) );
mainLayout->addMultiCellWidget( dnquery, row, row, 2, 3 );
}
row++;
@ -202,9 +202,9 @@ void LdapConfigWidget::initWidget()
mSecSSL = new TQRadioButton( i18n( "SSL" ), btgroup, "kcfg_ldapssl" );
mainLayout->addMultiCellWidget( btgroup, row, row, 0, 3 );
connect( mSecNO, TQT_SIGNAL( clicked() ), TQT_SLOT( setLDAPPort() ) );
connect( mSecTLS, TQT_SIGNAL( clicked() ), TQT_SLOT( setLDAPPort() ) );
connect( mSecSSL, TQT_SIGNAL( clicked() ), TQT_SLOT( setLDAPSPort( ) ) );
connect( mSecNO, TQ_SIGNAL( clicked() ), TQ_SLOT( setLDAPPort() ) );
connect( mSecTLS, TQ_SIGNAL( clicked() ), TQ_SLOT( setLDAPPort() ) );
connect( mSecSSL, TQ_SIGNAL( clicked() ), TQ_SLOT( setLDAPSPort( ) ) );
mSecNO->setChecked( true );
row++;
@ -229,14 +229,14 @@ void LdapConfigWidget::initWidget()
//without host query doesn't make sense
if ( mHost ) {
mQueryMech = new TQPushButton( i18n( "Query Server" ), authbox );
connect( mQueryMech, TQT_SIGNAL( clicked() ), TQT_SLOT( mQueryMechClicked() ) );
connect( mQueryMech, TQ_SIGNAL( clicked() ), TQ_SLOT( mQueryMechClicked() ) );
}
mainLayout->addMultiCellWidget( authbox, row, row+1, 0, 3 );
connect( mAnonymous, TQT_SIGNAL( stateChanged(int) ), TQT_SLOT( setAnonymous(int) ) );
connect( mSimple, TQT_SIGNAL( stateChanged(int) ), TQT_SLOT( setSimple(int) ) );
connect( mSASL, TQT_SIGNAL( stateChanged(int) ), TQT_SLOT( setSASL(int) ) );
connect( mAnonymous, TQ_SIGNAL( stateChanged(int) ), TQ_SLOT( setAnonymous(int) ) );
connect( mSimple, TQ_SIGNAL( stateChanged(int) ), TQ_SLOT( setSimple(int) ) );
connect( mSASL, TQ_SIGNAL( stateChanged(int) ), TQ_SLOT( setSASL(int) ) );
mAnonymous->setChecked( true );
}
@ -293,10 +293,10 @@ void LdapConfigWidget::sendQuery()
mLdif.startParsing();
TDEIO::Job *job = TDEIO::get( _url, true, false );
job->addMetaData("no-auth-prompt","true");
connect( job, TQT_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQT_SLOT( loadData( TDEIO::Job*, const TQByteArray& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( loadResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQ_SLOT( loadData( TDEIO::Job*, const TQByteArray& ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( loadResult( TDEIO::Job* ) ) );
if ( mProg == NULL )
mProg = new KProgressDialog( this, 0, i18n("LDAP Query"), _url.prettyURL(), true );

@ -87,9 +87,9 @@ void ResourceDir::init( const TQString &path, const TQString &format )
mLock = 0;
connect( &mDirWatch, TQT_SIGNAL( dirty(const TQString&) ), TQT_SLOT( pathChanged() ) );
connect( &mDirWatch, TQT_SIGNAL( created(const TQString&) ), TQT_SLOT( pathChanged() ) );
connect( &mDirWatch, TQT_SIGNAL( deleted(const TQString&) ), TQT_SLOT( pathChanged() ) );
connect( &mDirWatch, TQ_SIGNAL( dirty(const TQString&) ), TQ_SLOT( pathChanged() ) );
connect( &mDirWatch, TQ_SIGNAL( created(const TQString&) ), TQ_SLOT( pathChanged() ) );
connect( &mDirWatch, TQ_SIGNAL( deleted(const TQString&) ), TQ_SLOT( pathChanged() ) );
setPath( path );
}

@ -83,9 +83,9 @@ void ResourceFile::init( const TQString &fileName, const TQString &formatName )
mFormat = factory->format( mFormatName );
}
connect( &mDirWatch, TQT_SIGNAL( dirty(const TQString&) ), TQT_SLOT( fileChanged() ) );
connect( &mDirWatch, TQT_SIGNAL( created(const TQString&) ), TQT_SLOT( fileChanged() ) );
connect( &mDirWatch, TQT_SIGNAL( deleted(const TQString&) ), TQT_SLOT( fileChanged() ) );
connect( &mDirWatch, TQ_SIGNAL( dirty(const TQString&) ), TQ_SLOT( fileChanged() ) );
connect( &mDirWatch, TQ_SIGNAL( created(const TQString&) ), TQ_SLOT( fileChanged() ) );
connect( &mDirWatch, TQ_SIGNAL( deleted(const TQString&) ), TQ_SLOT( fileChanged() ) );
setFileName( fileName );
@ -333,9 +333,9 @@ bool ResourceFile::asyncSave( Ticket *ticket )
bool ok = save( ticket );
if ( !ok )
TQTimer::singleShot( 0, this, TQT_SLOT( emitSavingError() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( emitSavingError() ) );
else
TQTimer::singleShot( 0, this, TQT_SLOT( emitSavingFinished() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( emitSavingFinished() ) );
return ok;
}

@ -51,8 +51,8 @@ ResourceFileConfig::ResourceFileConfig( TQWidget* parent, const char* name )
label = new TQLabel( i18n( "Location:" ), this );
mFileNameEdit = new KURLRequester( this );
connect( mFileNameEdit, TQT_SIGNAL( textChanged( const TQString & ) ),
TQT_SLOT( checkFilePermissions( const TQString & ) ) );
connect( mFileNameEdit, TQ_SIGNAL( textChanged( const TQString & ) ),
TQ_SLOT( checkFilePermissions( const TQString & ) ) );
mainLayout->addWidget( label, 1, 0 );
mainLayout->addWidget( mFileNameEdit, 1, 1 );

@ -173,10 +173,10 @@ TQString ResourceLDAPTDEIO::findUid( const TQString &uid )
TDEIO::ListJob * listJob = TDEIO::listDir( url, false /* no GUI */ );
connect( listJob,
TQT_SIGNAL( entries( TDEIO::Job *, const TDEIO::UDSEntryList& ) ),
TQT_SLOT( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( listJob, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( listResult( TDEIO::Job* ) ) );
TQ_SIGNAL( entries( TDEIO::Job *, const TDEIO::UDSEntryList& ) ),
TQ_SLOT( entries( TDEIO::Job*, const TDEIO::UDSEntryList& ) ) );
connect( listJob, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( listResult( TDEIO::Job* ) ) );
enter_loop();
return d->mResultDn;
@ -511,8 +511,8 @@ TDEIO::Job *ResourceLDAPTDEIO::loadFromCache()
KURL url( d->mCacheDst );
job = TDEIO::get( url, true, false );
connect( job, TQT_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQT_SLOT( data( TDEIO::Job*, const TQByteArray& ) ) );
connect( job, TQ_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQ_SLOT( data( TDEIO::Job*, const TQByteArray& ) ) );
}
return job;
}
@ -535,17 +535,17 @@ bool ResourceLDAPTDEIO::load()
createCache();
if ( d->mCachePolicy != Cache_Always ) {
job = TDEIO::get( d->mLDAPUrl, true, false );
connect( job, TQT_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQT_SLOT( data( TDEIO::Job*, const TQByteArray& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( syncLoadSaveResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQ_SLOT( data( TDEIO::Job*, const TQByteArray& ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( syncLoadSaveResult( TDEIO::Job* ) ) );
enter_loop();
}
job = loadFromCache();
if ( job ) {
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( syncLoadSaveResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( syncLoadSaveResult( TDEIO::Job* ) ) );
enter_loop();
}
if ( mErrorMsg.isEmpty() ) {
@ -572,10 +572,10 @@ bool ResourceLDAPTDEIO::asyncLoad()
createCache();
if ( d->mCachePolicy != Cache_Always ) {
TDEIO::Job *job = TDEIO::get( d->mLDAPUrl, true, false );
connect( job, TQT_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQT_SLOT( data( TDEIO::Job*, const TQByteArray& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( result( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( data( TDEIO::Job*, const TQByteArray& ) ),
this, TQ_SLOT( data( TDEIO::Job*, const TQByteArray& ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( result( TDEIO::Job* ) ) );
} else {
result( NULL );
}
@ -714,8 +714,8 @@ void ResourceLDAPTDEIO::result( TDEIO::Job *job )
TDEIO::Job *cjob;
cjob = loadFromCache();
if ( cjob ) {
connect( cjob, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( loadCacheResult( TDEIO::Job* ) ) );
connect( cjob, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( loadCacheResult( TDEIO::Job* ) ) );
} else {
if ( !mErrorMsg.isEmpty() )
emit loadingError( this, mErrorMsg );
@ -730,10 +730,10 @@ bool ResourceLDAPTDEIO::save( Ticket* )
d->mSaveIt = begin();
TDEIO::Job *job = TDEIO::put( d->mLDAPUrl, -1, true, false, false );
connect( job, TQT_SIGNAL( dataReq( TDEIO::Job*, TQByteArray& ) ),
this, TQT_SLOT( saveData( TDEIO::Job*, TQByteArray& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( syncLoadSaveResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( dataReq( TDEIO::Job*, TQByteArray& ) ),
this, TQ_SLOT( saveData( TDEIO::Job*, TQByteArray& ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( syncLoadSaveResult( TDEIO::Job* ) ) );
enter_loop();
if ( mErrorMsg.isEmpty() ) {
kdDebug(7125) << "ResourceLDAPTDEIO save ok!" << endl;
@ -750,10 +750,10 @@ bool ResourceLDAPTDEIO::asyncSave( Ticket* )
kdDebug(7125) << "ResourceLDAPTDEIO asyncSave" << endl;
d->mSaveIt = begin();
TDEIO::Job *job = TDEIO::put( d->mLDAPUrl, -1, true, false, false );
connect( job, TQT_SIGNAL( dataReq( TDEIO::Job*, TQByteArray& ) ),
this, TQT_SLOT( saveData( TDEIO::Job*, TQByteArray& ) ) );
connect( job, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( saveResult( TDEIO::Job* ) ) );
connect( job, TQ_SIGNAL( dataReq( TDEIO::Job*, TQByteArray& ) ),
this, TQ_SLOT( saveData( TDEIO::Job*, TQByteArray& ) ) );
connect( job, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( saveResult( TDEIO::Job* ) ) );
return true;
}

@ -58,8 +58,8 @@ ResourceLDAPTDEIOConfig::ResourceLDAPTDEIOConfig( TQWidget* parent, const char*
mEditButton = new TQPushButton( i18n( "Edit Attributes..." ), box );
mCacheButton = new TQPushButton( i18n( "Offline Use..." ), box );
connect( mEditButton, TQT_SIGNAL( clicked() ), TQT_SLOT( editAttributes() ) );
connect( mCacheButton, TQT_SIGNAL( clicked() ), TQT_SLOT( editCache() ) );
connect( mEditButton, TQ_SIGNAL( clicked() ), TQ_SLOT( editAttributes() ) );
connect( mCacheButton, TQ_SIGNAL( clicked() ), TQ_SLOT( editCache() ) );
}
void ResourceLDAPTDEIOConfig::loadSettings( KRES::Resource *res )
@ -247,7 +247,7 @@ AttributesDialog::AttributesDialog( const TQMap<TQString, TQString> &attributes,
mMapCombo->insertItem( i18n( "Netscape" ) );
mMapCombo->insertItem( i18n( "Evolution" ) );
mMapCombo->insertItem( i18n( "Outlook" ) );
connect( mMapCombo, TQT_SIGNAL( activated( int ) ), TQT_SLOT( mapChanged( int ) ) );
connect( mMapCombo, TQ_SIGNAL( activated( int ) ), TQ_SLOT( mapChanged( int ) ) );
label = new TQLabel( i18n( "RDN prefix attribute:" ), page );
layout->addWidget( label, 1, 0 );
@ -356,10 +356,10 @@ OfflineDialog::OfflineDialog( bool autoCache, int cachePolicy, const KURL &src,
mAutoCache->setChecked( autoCache );
mAutoCache->setEnabled( bt->isChecked() );
connect( bt, TQT_SIGNAL(toggled(bool)), mAutoCache, TQT_SLOT(setEnabled(bool)) );
connect( bt, TQ_SIGNAL(toggled(bool)), mAutoCache, TQ_SLOT(setEnabled(bool)) );
TQPushButton *lcache = new TQPushButton( i18n("Load into Cache"), page );
connect( lcache, TQT_SIGNAL( clicked() ), TQT_SLOT( loadCache() ) );
connect( lcache, TQ_SIGNAL( clicked() ), TQ_SLOT( loadCache() ) );
}
OfflineDialog::~OfflineDialog()

@ -192,8 +192,8 @@ bool ResourceNet::asyncLoad()
TDEIO::Scheduler::checkSlaveOnHold( true );
d->mLoadJob = TDEIO::file_copy( mUrl, dest, -1, true, false, false );
d->mIsLoading = true;
connect( d->mLoadJob, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( downloadFinished( TDEIO::Job* ) ) );
connect( d->mLoadJob, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( downloadFinished( TDEIO::Job* ) ) );
return true;
}
@ -286,8 +286,8 @@ bool ResourceNet::asyncSave( Ticket* )
TDEIO::Scheduler::checkSlaveOnHold( true );
d->mIsSaving = true;
d->mSaveJob = TDEIO::file_copy( src, mUrl, -1, true, false, false );
connect( d->mSaveJob, TQT_SIGNAL( result( TDEIO::Job* ) ),
this, TQT_SLOT( uploadFinished( TDEIO::Job* ) ) );
connect( d->mSaveJob, TQ_SIGNAL( result( TDEIO::Job* ) ),
this, TQ_SLOT( uploadFinished( TDEIO::Job* ) ) );
return true;
}
@ -352,7 +352,7 @@ void ResourceNet::downloadFinished( TDEIO::Job* )
if ( !hasTempFile() || mTempFile->status() != 0 ) {
d->mLastErrorString = i18n( "Download failed: Unable to create temporary file" );
TQTimer::singleShot( 0, this, TQT_SLOT( signalError() ) );
TQTimer::singleShot( 0, this, TQ_SLOT( signalError() ) );
return;
}

@ -54,8 +54,8 @@ ResourceSelectDialog::ResourceSelectDialog( AddressBook *ab, TQWidget *parent, c
KButtonBox *buttonBox = new KButtonBox( this );
buttonBox->addStretch();
buttonBox->addButton( KStdGuiItem::ok(), this, TQT_SLOT( accept() ) );
buttonBox->addButton( KStdGuiItem::cancel(), this, TQT_SLOT( reject() ) );
buttonBox->addButton( KStdGuiItem::ok(), this, TQ_SLOT( accept() ) );
buttonBox->addButton( KStdGuiItem::cancel(), this, TQ_SLOT( reject() ) );
buttonBox->layout();
mainLayout->addWidget( buttonBox );

@ -103,15 +103,15 @@ void StdAddressBook::init( bool asynchronous )
error( TQString( "Unable to open resource '%1'!" ).arg( (*it)->resourceName() ) );
continue;
}
connect( *it, TQT_SIGNAL( loadingFinished( Resource* ) ),
this, TQT_SLOT( resourceLoadingFinished( Resource* ) ) );
connect( *it, TQT_SIGNAL( savingFinished( Resource* ) ),
this, TQT_SLOT( resourceSavingFinished( Resource* ) ) );
connect( *it, TQT_SIGNAL( loadingError( Resource*, const TQString& ) ),
this, TQT_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
connect( *it, TQT_SIGNAL( savingError( Resource*, const TQString& ) ),
this, TQT_SLOT( resourceSavingError( Resource*, const TQString& ) ) );
connect( *it, TQ_SIGNAL( loadingFinished( Resource* ) ),
this, TQ_SLOT( resourceLoadingFinished( Resource* ) ) );
connect( *it, TQ_SIGNAL( savingFinished( Resource* ) ),
this, TQ_SLOT( resourceSavingFinished( Resource* ) ) );
connect( *it, TQ_SIGNAL( loadingError( Resource*, const TQString& ) ),
this, TQ_SLOT( resourceLoadingError( Resource*, const TQString& ) ) );
connect( *it, TQ_SIGNAL( savingError( Resource*, const TQString& ) ),
this, TQ_SLOT( resourceSavingError( Resource*, const TQString& ) ) );
}
Resource *res = standardResource();

@ -21,7 +21,7 @@ int main( int argc,char **argv )
lineEdit->show();
app.setMainWidget( lineEdit );
TQObject::connect( &app, TQT_SIGNAL( lastWindowClosed() ), &app, TQT_SLOT( quit() ) );
TQObject::connect( &app, TQ_SIGNAL( lastWindowClosed() ), &app, TQ_SLOT( quit() ) );
app.exec();

@ -51,7 +51,7 @@ int main(int argc,char **argv)
editor->show();
app.setMainWidget(editor);
TQObject::connect( &app, TQT_SIGNAL( lastWindowClosed() ), &app, TQT_SLOT( quit() ) );
TQObject::connect( &app, TQ_SIGNAL( lastWindowClosed() ), &app, TQ_SLOT( quit() ) );
app.exec();

@ -97,12 +97,12 @@ void TestLDAPClient::testIntevation()
// But this certainly looks fishy, it might break on non-utf8 systems.
TQString filter = "&(|(objectclass=person)(objectclass=groupofnames)(mail=*))(|(cn=*Ägypten MDK*)(sn=*Ägypten MDK*))";
connect( mClient, TQT_SIGNAL( result( const TDEABC::LdapObject& ) ),
this, TQT_SLOT( slotLDAPResult( const TDEABC::LdapObject& ) ) );
connect( mClient, TQT_SIGNAL( done() ),
this, TQT_SLOT( slotLDAPDone() ) );
connect( mClient, TQT_SIGNAL( error( const TQString& ) ),
this, TQT_SLOT( slotLDAPError( const TQString& ) ) );
connect( mClient, TQ_SIGNAL( result( const TDEABC::LdapObject& ) ),
this, TQ_SLOT( slotLDAPResult( const TDEABC::LdapObject& ) ) );
connect( mClient, TQ_SIGNAL( done() ),
this, TQ_SLOT( slotLDAPDone() ) );
connect( mClient, TQ_SIGNAL( error( const TQString& ) ),
this, TQ_SLOT( slotLDAPError( const TQString& ) ) );
mClient->startQuery( filter );
kapp->eventLoop()->enterLoop();
delete mClient; mClient = 0;

@ -77,11 +77,11 @@ LockWidget::LockWidget( const TQString &identifier )
TQPushButton *button = new TQPushButton( "Lock", this );
topLayout->addWidget( button );
connect( button, TQT_SIGNAL( clicked() ), TQT_SLOT( lock() ) );
connect( button, TQ_SIGNAL( clicked() ), TQ_SLOT( lock() ) );
button = new TQPushButton( "Unlock", this );
topLayout->addWidget( button );
connect( button, TQT_SIGNAL( clicked() ), TQT_SLOT( unlock() ) );
connect( button, TQ_SIGNAL( clicked() ), TQ_SLOT( unlock() ) );
}
mLockView = new TQListView( this );
@ -94,15 +94,15 @@ LockWidget::LockWidget( const TQString &identifier )
TQPushButton *quitButton = new TQPushButton( "Quit", this );
topLayout->addWidget( quitButton );
connect( quitButton, TQT_SIGNAL( clicked() ), TQT_SLOT( close() ) );
connect( quitButton, TQ_SIGNAL( clicked() ), TQ_SLOT( close() ) );
KDirWatch *watch = KDirWatch::self();
connect( watch, TQT_SIGNAL( dirty( const TQString & ) ),
TQT_SLOT( updateLockView() ) );
connect( watch, TQT_SIGNAL( created( const TQString & ) ),
TQT_SLOT( updateLockView() ) );
connect( watch, TQT_SIGNAL( deleted( const TQString & ) ),
TQT_SLOT( updateLockView() ) );
connect( watch, TQ_SIGNAL( dirty( const TQString & ) ),
TQ_SLOT( updateLockView() ) );
connect( watch, TQ_SIGNAL( created( const TQString & ) ),
TQ_SLOT( updateLockView() ) );
connect( watch, TQ_SIGNAL( deleted( const TQString & ) ),
TQ_SLOT( updateLockView() ) );
watch->addDir( Lock::locksDir() );
watch->startScan();
}

@ -169,7 +169,7 @@ _baseGrid->addMultiCellWidget(_sideList, 0, 13, 0, 1);
_importAll = new TQPushButton(i18n("Import &All"), _frame);
_baseGrid->addMultiCellWidget(_importAll, 14, 14, 0, 1);
connect(_importAll, TQT_SIGNAL(clicked()), TQT_SLOT(slotImportAll()));
connect(_importAll, TQ_SIGNAL(clicked()), TQ_SLOT(slotImportAll()));
@ -184,7 +184,7 @@ grid->addMultiCellWidget(new TQLabel(i18n("TDE Secure Certificate Import"), _pkc
grid->addWidget(new TQLabel(i18n("Chain:"), _pkcsFrame), 1, 0);
_p12_chain = new KComboBox(_pkcsFrame);
grid->addMultiCellWidget(_p12_chain, 1, 1, 1, 4);
connect(_p12_chain, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChain(int)));
connect(_p12_chain, TQ_SIGNAL(activated(int)), TQ_SLOT(slotChain(int)));
grid->addWidget(new TQLabel(i18n("Subject:"), _pkcsFrame), 2, 0);
grid->addWidget(new TQLabel(i18n("Issued by:"), _pkcsFrame), 2, 3);
@ -373,10 +373,10 @@ _baseGrid->addMultiCellWidget(_launch, 14, 14, 4, 5);
_baseGrid->addWidget(_import, 14, 6);
_baseGrid->addWidget(_save, 14, 7);
_baseGrid->addWidget(_done, 14, 8);
connect(_launch, TQT_SIGNAL(clicked()), TQT_SLOT(slotLaunch()));
connect(_import, TQT_SIGNAL(clicked()), TQT_SLOT(slotImport()));
connect(_save, TQT_SIGNAL(clicked()), TQT_SLOT(slotSave()));
connect(_done, TQT_SIGNAL(clicked()), TQT_SLOT(slotDone()));
connect(_launch, TQ_SIGNAL(clicked()), TQ_SLOT(slotLaunch()));
connect(_import, TQ_SIGNAL(clicked()), TQ_SLOT(slotImport()));
connect(_save, TQ_SIGNAL(clicked()), TQ_SLOT(slotSave()));
connect(_done, TQ_SIGNAL(clicked()), TQ_SLOT(slotDone()));
_import->setEnabled(false);
_save->setEnabled(false);
@ -386,8 +386,8 @@ _baseGrid->addMultiCellWidget(_pkcsFrame, 0, 12, 2, 8);
_baseGrid->addMultiCellWidget(_x509Frame, 0, 12, 2, 8);
_baseGrid->addMultiCellWidget(_blankFrame, 0, 12, 2, 8);
connect(_sideList, TQT_SIGNAL(selectionChanged(TQListViewItem*)),
this, TQT_SLOT(slotSelectionChanged(TQListViewItem*)));
connect(_sideList, TQ_SIGNAL(selectionChanged(TQListViewItem*)),
this, TQ_SLOT(slotSelectionChanged(TQListViewItem*)));
setReadWrite(true);
}

@ -170,8 +170,8 @@ void KCMShell::waitForExit()
{
kdDebug(780) << k_funcinfo << endl;
connect(dcopClient(), TQT_SIGNAL(applicationRemoved(const TQCString&)),
TQT_SLOT( appExit(const TQCString&) ));
connect(dcopClient(), TQ_SIGNAL(applicationRemoved(const TQCString&)),
TQ_SLOT( appExit(const TQCString&) ));
exec();
}

@ -48,7 +48,7 @@ class KAudioPlayerPrivate;
*
* \code
* KAudioPlayer player("/var/share/foo.wav");
* connect(&button, TQT_SIGNAL(clicked()), &player, TQT_SLOT(play()));
* connect(&button, TQ_SIGNAL(clicked()), &player, TQ_SLOT(play()));
* \endcode
*
*/

@ -89,7 +89,7 @@ KCheckAccelerators::KCheckAccelerators( TQObject* parent )
}
alwaysShow = TDEGlobal::config()->readBoolEntry( "AlwaysShowCheckAccelerators", false );
autoCheck = TDEGlobal::config()->readBoolEntry( "AutoCheckAccelerators", true );
connect( &autoCheckTimer, TQT_SIGNAL( timeout()), TQT_SLOT( autoCheckSlot()));
connect( &autoCheckTimer, TQ_SIGNAL( timeout()), TQ_SLOT( autoCheckSlot()));
}
bool KCheckAccelerators::eventFilter( TQObject * , TQEvent * e)
@ -153,11 +153,11 @@ void KCheckAccelerators::createDialog(TQWidget *actWin, bool automatic)
TQCheckBox* disableAutoCheck = NULL;
if( automatic ) {
disableAutoCheck = new TQCheckBox( i18n( "&Disable automatic checking" ), drklash );
connect(disableAutoCheck, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotDisableCheck(bool)));
connect(disableAutoCheck, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotDisableCheck(bool)));
}
TQPushButton* btnClose = new TQPushButton( i18n( "&Close" ), drklash );
btnClose->setDefault( true );
connect( btnClose, TQT_SIGNAL( clicked() ), drklash, TQT_SLOT( close() ) );
connect( btnClose, TQ_SIGNAL( clicked() ), drklash, TQ_SLOT( close() ) );
if (disableAutoCheck)
disableAutoCheck->setFocus();
else

@ -126,11 +126,11 @@ void TDEClipboardSynchronizer::setupSignals()
TQClipboard *clip = TQApplication::clipboard();
disconnect( clip, NULL, this, NULL );
if( s_sync )
connect( clip, TQT_SIGNAL( selectionChanged() ),
TQT_SLOT( slotSelectionChanged() ));
connect( clip, TQ_SIGNAL( selectionChanged() ),
TQ_SLOT( slotSelectionChanged() ));
if( s_reverse_sync )
connect( clip, TQT_SIGNAL( dataChanged() ),
TQT_SLOT( slotClipboardChanged() ));
connect( clip, TQ_SIGNAL( dataChanged() ),
TQ_SLOT( slotClipboardChanged() ));
}
void TDEClipboardSynchronizer::slotSelectionChanged()

@ -639,7 +639,7 @@ bool KExtendedSocket::setBufferSize(int rsize, int wsize)
if (d->qsnIn == NULL)
{
d->qsnIn = new TQSocketNotifier(sockfd, TQSocketNotifier::Read);
TQObject::connect(d->qsnIn, TQT_SIGNAL(activated(int)), this, TQT_SLOT(socketActivityRead()));
TQObject::connect(d->qsnIn, TQ_SIGNAL(activated(int)), this, TQ_SLOT(socketActivityRead()));
d->qsnIn->setEnabled(true);
}
@ -687,7 +687,7 @@ bool KExtendedSocket::setBufferSize(int rsize, int wsize)
if (d->qsnOut == NULL)
{
d->qsnOut = new TQSocketNotifier(sockfd, TQSocketNotifier::Write);
TQObject::connect(d->qsnOut, TQT_SIGNAL(activated(int)), this, TQT_SLOT(socketActivityWrite()));
TQObject::connect(d->qsnOut, TQ_SIGNAL(activated(int)), this, TQ_SLOT(socketActivityWrite()));
// if the class is being created now, there's nothing to write yet
// so socketActivityWrite() will get called once and disable
// the notifier
@ -702,7 +702,7 @@ bool KExtendedSocket::setBufferSize(int rsize, int wsize)
if (d->emitWrite && d->qsnOut == NULL)
{
d->qsnOut = new TQSocketNotifier(sockfd, TQSocketNotifier::Write);
TQObject::connect(d->qsnOut, TQT_SIGNAL(activated(int)), this, TQT_SLOT(socketActivityWrite()));
TQObject::connect(d->qsnOut, TQ_SIGNAL(activated(int)), this, TQ_SLOT(socketActivityWrite()));
}
return true;
@ -783,8 +783,8 @@ int KExtendedSocket::startAsyncLookup()
d->resRemote.setFlags(flags);
d->resRemote.setFamily(familyMask);
d->resRemote.setSocketType(socktype);
TQObject::connect(&d->resRemote, TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(dnsResultsReady()));
TQObject::connect(&d->resRemote, TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(dnsResultsReady()));
if (!d->resRemote.start())
{
@ -800,8 +800,8 @@ int KExtendedSocket::startAsyncLookup()
d->resLocal.setFlags(flags);
d->resLocal.setFamily(familyMask);
d->resLocal.setSocketType(socktype);
TQObject::connect(&d->resLocal, TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(dnsResultsReady()));
TQObject::connect(&d->resLocal, TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(dnsResultsReady()));
if (!d->resLocal.start())
{
@ -896,7 +896,7 @@ int KExtendedSocket::listen(int N)
{
d->status = listening;
d->qsnIn = new TQSocketNotifier(sockfd, TQSocketNotifier::Read);
TQObject::connect(d->qsnIn, TQT_SIGNAL(activated(int)), this, TQT_SLOT(socketActivityRead()));
TQObject::connect(d->qsnIn, TQ_SIGNAL(activated(int)), this, TQ_SLOT(socketActivityRead()));
}
return retval == -1 ? -1 : 0;
}
@ -1218,7 +1218,7 @@ int KExtendedSocket::startAsyncConnect()
// signal lookupFinished to do connection
if (d->status < lookupDone)
{
TQObject::connect(this, TQT_SIGNAL(lookupFinished(int)), this, TQT_SLOT(startAsyncConnectSlot()));
TQObject::connect(this, TQ_SIGNAL(lookupFinished(int)), this, TQ_SLOT(startAsyncConnectSlot()));
if (d->status < lookupInProgress)
return startAsyncLookup();
else
@ -1909,9 +1909,9 @@ void KExtendedSocket::connectionEvent()
// error here is either EWOULDBLOCK or EINPROGRESS
// so, it is a good condition
d->qsnIn = new TQSocketNotifier(sockfd, TQSocketNotifier::Read);
TQObject::connect(d->qsnIn, TQT_SIGNAL(activated(int)), this, TQT_SLOT(socketActivityRead()));
TQObject::connect(d->qsnIn, TQ_SIGNAL(activated(int)), this, TQ_SLOT(socketActivityRead()));
d->qsnOut = new TQSocketNotifier(sockfd, TQSocketNotifier::Write);
TQObject::connect(d->qsnOut, TQT_SIGNAL(activated(int)), this, TQT_SLOT(socketActivityWrite()));
TQObject::connect(d->qsnOut, TQ_SIGNAL(activated(int)), this, TQ_SLOT(socketActivityWrite()));
// ok, let the Qt event loop do the selecting for us
return;
@ -1969,7 +1969,7 @@ void KExtendedSocket::dnsResultsReady()
void KExtendedSocket::startAsyncConnectSlot()
{
TQObject::disconnect(this, TQT_SIGNAL(lookupFinished(int)), this, TQT_SLOT(startAsyncConnectSlot()));
TQObject::disconnect(this, TQ_SIGNAL(lookupFinished(int)), this, TQ_SLOT(startAsyncConnectSlot()));
if (d->status == lookupDone)
startAsyncConnect();

@ -76,7 +76,7 @@ class TDECORE_EXPORT TDEGlobalAccel : public TQObject
* insert( "Do Something", i18n("Do Something"),
* i18n("This action allows you to do something really great with this program to "
* "the currently open document."),
* ALT+CTRL+Key_Q, KKey::QtWIN+CTRL+Key_Q, this, TQT_SLOT(slotDoSomething()) );
* ALT+CTRL+Key_Q, KKey::QtWIN+CTRL+Key_Q, this, TQ_SLOT(slotDoSomething()) );
*\endcode
*
* @param sAction The internal name of the action.

@ -283,9 +283,9 @@ bool TDEGlobalAccelPrivate::x11KeyPress( const XEvent *pEvent )
if( !recursion_block ) {
recursion_block = true;
TQPopupMenu* pMenu = createPopupMenu( 0, KKeySequence(key) );
connect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated(int)) );
connect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated(int)) );
pMenu->exec( TQPoint( 0, 0 ) );
disconnect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated(int)));
disconnect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated(int)));
delete pMenu;
recursion_block = false;
}

@ -90,7 +90,7 @@ TDEGlobalAccelPrivate::TDEGlobalAccelPrivate()
all_accels->append( this );
m_sConfigGroup = "Global Shortcuts";
kapp->installX11EventFilter( this );
connect(kapp, TQT_SIGNAL(coreFakeKeyPress(unsigned int)), this, TQT_SLOT(fakeKeyPressed(unsigned int)));
connect(kapp, TQ_SIGNAL(coreFakeKeyPress(unsigned int)), this, TQ_SLOT(fakeKeyPressed(unsigned int)));
}
TDEGlobalAccelPrivate::~TDEGlobalAccelPrivate()
@ -313,9 +313,9 @@ void TDEGlobalAccelPrivate::fakeKeyPressed(unsigned int keyCode) {
if( !recursion_block ) {
recursion_block = true;
TQPopupMenu* pMenu = createPopupMenu( 0, KKeySequence(key) );
connect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated(int)) );
connect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated(int)) );
pMenu->exec( TQPoint( 0, 0 ) );
disconnect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated(int)));
disconnect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated(int)));
delete pMenu;
recursion_block = false;
}
@ -392,9 +392,9 @@ bool TDEGlobalAccelPrivate::x11KeyPress( const XEvent *pEvent )
if( !recursion_block ) {
recursion_block = true;
TQPopupMenu* pMenu = createPopupMenu( 0, KKeySequence(key) );
connect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated(int)) );
connect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated(int)) );
pMenu->exec( TQPoint( 0, 0 ) );
disconnect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated(int)));
disconnect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated(int)));
delete pMenu;
recursion_block = false;
}

@ -157,7 +157,7 @@ TDEIconLoader::TDEIconLoader(const TQString& _appname, TDEStandardDirs *_dirs)
if (kapp) {
kapp->addKipcEventMask(KIPC::IconChanged);
TQObject::connect(kapp, TQT_SIGNAL(updateIconLoaders()), d, TQT_SLOT(reconfigure()));
TQObject::connect(kapp, TQ_SIGNAL(updateIconLoaders()), d, TQ_SLOT(reconfigure()));
}
init( _appname, _dirs );

@ -121,8 +121,8 @@ KLibrary::~KLibrary()
for ( ; it.current() ; ++it )
{
kdDebug(150) << "Factory still has object " << it.current() << " " << it.current()->name () << " Library = " << m_libname << endl;
disconnect( it.current(), TQT_SIGNAL( destroyed() ),
this, TQT_SLOT( slotObjectDestroyed() ) );
disconnect( it.current(), TQ_SIGNAL( destroyed() ),
this, TQ_SLOT( slotObjectDestroyed() ) );
}
m_objs.setAutoDelete(true);
m_objs.clear();
@ -172,8 +172,8 @@ KLibFactory* KLibrary::factory()
return 0;
}
connect( m_factory, TQT_SIGNAL( objectCreated( TQObject * ) ),
this, TQT_SLOT( slotObjectCreated( TQObject * ) ) );
connect( m_factory, TQ_SIGNAL( objectCreated( TQObject * ) ),
this, TQ_SLOT( slotObjectCreated( TQObject * ) ) );
return m_factory;
}
@ -214,8 +214,8 @@ void KLibrary::slotObjectCreated( TQObject *obj )
if ( m_objs.containsRef( obj ) )
return; // we know this object already
connect( obj, TQT_SIGNAL( destroyed() ),
this, TQT_SLOT( slotObjectDestroyed() ) );
connect( obj, TQ_SIGNAL( destroyed() ),
this, TQ_SLOT( slotObjectDestroyed() ) );
m_objs.append( obj );
}
@ -232,8 +232,8 @@ void KLibrary::slotObjectDestroyed()
if ( !m_timer )
{
m_timer = new TQTimer( this, "klibrary_shutdown_timer" );
connect( m_timer, TQT_SIGNAL( timeout() ),
this, TQT_SLOT( slotTimeout() ) );
connect( m_timer, TQ_SIGNAL( timeout() ),
this, TQ_SLOT( slotTimeout() ) );
}
// as long as it's not stable make the timeout short, for debugging
@ -447,8 +447,8 @@ KLibrary* KLibLoader::library( const char *name )
}
m_libs.insert( name, wrap );
connect( wrap->lib, TQT_SIGNAL( destroyed() ),
this, TQT_SLOT( slotLibraryDestroyed() ) );
connect( wrap->lib, TQ_SIGNAL( destroyed() ),
this, TQ_SLOT( slotLibraryDestroyed() ) );
return wrap->lib;
}
@ -470,8 +470,8 @@ void KLibLoader::unloadLibrary( const char *libname )
m_libs.remove( libname );
disconnect( wrap->lib, TQT_SIGNAL( destroyed() ),
this, TQT_SLOT( slotLibraryDestroyed() ) );
disconnect( wrap->lib, TQ_SIGNAL( destroyed() ),
this, TQ_SLOT( slotLibraryDestroyed() ) );
close_pending( wrap );
}
@ -511,8 +511,8 @@ void KLibLoader::close_pending(KLibWrapPrivate *wrap)
for (; it.current(); ++it) {
wrap = it.current();
if (wrap->lib) {
disconnect( wrap->lib, TQT_SIGNAL( destroyed() ),
this, TQT_SLOT( slotLibraryDestroyed() ) );
disconnect( wrap->lib, TQ_SIGNAL( destroyed() ),
this, TQ_SLOT( slotLibraryDestroyed() ) );
KLibrary* to_delete = wrap->lib;
wrap->lib = 0L; // unset first, because KLibrary dtor can cause
delete to_delete; // recursive call to close_pending()

@ -71,8 +71,8 @@ TDEProcessController::TDEProcessController()
notifier = new TQSocketNotifier( fd[0], TQSocketNotifier::Read );
notifier->setEnabled( true );
TQObject::connect( notifier, TQT_SIGNAL(activated(int)),
TQT_SLOT(slotDoHousekeeping()));
TQObject::connect( notifier, TQ_SIGNAL(activated(int)),
TQ_SLOT(slotDoHousekeeping()));
}
TDEProcessController::~TDEProcessController()

@ -959,15 +959,15 @@ int TDEProcess::commSetupDoneP()
innot = new TQSocketNotifier(in[1], TQSocketNotifier::Write, this);
TQ_CHECK_PTR(innot);
innot->setEnabled(false); // will be enabled when data has to be sent
TQObject::connect(innot, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotSendData(int)));
TQObject::connect(innot, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotSendData(int)));
}
if (communication & Stdout) {
outnot = new TQSocketNotifier(out[0], TQSocketNotifier::Read, this);
TQ_CHECK_PTR(outnot);
TQObject::connect(outnot, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotChildOutput(int)));
TQObject::connect(outnot, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotChildOutput(int)));
if (communication & NoRead)
suspend();
}
@ -975,8 +975,8 @@ int TDEProcess::commSetupDoneP()
if (communication & Stderr) {
errnot = new TQSocketNotifier(err[0], TQSocketNotifier::Read, this );
TQ_CHECK_PTR(errnot);
TQObject::connect(errnot, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(slotChildError(int)));
TQObject::connect(errnot, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(slotChildError(int)));
}
return 1;

@ -96,8 +96,8 @@ class KPty;
*
* *proc << "my_executable";
* *proc << "These" << "are" << "the" << "command" << "line" << "args";
* TQApplication::connect(proc, TQT_SIGNAL(processExited(TDEProcess *)),
* pointer_to_my_object, TQT_SLOT(my_objects_slot(TDEProcess *)));
* TQApplication::connect(proc, TQ_SIGNAL(processExited(TDEProcess *)),
* pointer_to_my_object, TQ_SLOT(my_objects_slot(TDEProcess *)));
* proc->start();
* \endcode
*

@ -67,14 +67,14 @@ KProcIO::resetAll ()
rbi=0;
readsignalon=writeready=true;
disconnect (this, TQT_SIGNAL (receivedStdout (TDEProcess *, char *, int)),
this, TQT_SLOT (received (TDEProcess *, char *, int)));
disconnect (this, TQ_SIGNAL (receivedStdout (TDEProcess *, char *, int)),
this, TQ_SLOT (received (TDEProcess *, char *, int)));
disconnect (this, TQT_SIGNAL (receivedStderr (TDEProcess *, char *, int)),
this, TQT_SLOT (received (TDEProcess *, char *, int)));
disconnect (this, TQ_SIGNAL (receivedStderr (TDEProcess *, char *, int)),
this, TQ_SLOT (received (TDEProcess *, char *, int)));
disconnect (this, TQT_SIGNAL (wroteStdin(TDEProcess *)),
this, TQT_SLOT (sent (TDEProcess *)));
disconnect (this, TQ_SIGNAL (wroteStdin(TDEProcess *)),
this, TQ_SLOT (sent (TDEProcess *)));
outbuffer.clear();
@ -87,17 +87,17 @@ void KProcIO::setComm (Communication comm)
bool KProcIO::start (RunMode runmode, bool includeStderr)
{
connect (this, TQT_SIGNAL (receivedStdout (TDEProcess *, char *, int)),
this, TQT_SLOT (received (TDEProcess *, char *, int)));
connect (this, TQ_SIGNAL (receivedStdout (TDEProcess *, char *, int)),
this, TQ_SLOT (received (TDEProcess *, char *, int)));
if (includeStderr)
{
connect (this, TQT_SIGNAL (receivedStderr (TDEProcess *, char *, int)),
this, TQT_SLOT (received (TDEProcess *, char *, int)));
connect (this, TQ_SIGNAL (receivedStderr (TDEProcess *, char *, int)),
this, TQ_SLOT (received (TDEProcess *, char *, int)));
}
connect (this, TQT_SIGNAL (wroteStdin(TDEProcess *)),
this, TQT_SLOT (sent (TDEProcess *)));
connect (this, TQ_SIGNAL (wroteStdin(TDEProcess *)),
this, TQ_SLOT (sent (TDEProcess *)));
return TDEProcess::start (runmode, d->comm);
}

@ -213,7 +213,7 @@ KSimpleDirWatchPrivate::KSimpleDirWatchPrivate()
: rescan_timer(0, "KSimpleDirWatchPrivate::rescan_timer")
{
timer = new TQTimer(this, "KSimpleDirWatchPrivate::timer");
connect (timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotRescan()));
connect (timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotRescan()));
freq = 3600000; // 1 hour as upper bound
statEntries = 0;
delayRemove = false;
@ -227,7 +227,7 @@ KSimpleDirWatchPrivate::KSimpleDirWatchPrivate()
// used for FAM and DNOTIFY
rescan_all = false;
connect(&rescan_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotRescan()));
connect(&rescan_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotRescan()));
#ifdef HAVE_FAM
// It's possible that FAM server can't be started
@ -236,8 +236,8 @@ KSimpleDirWatchPrivate::KSimpleDirWatchPrivate()
use_fam=true;
sn = new TQSocketNotifier( FAMCONNECTION_GETFD(&fc),
TQSocketNotifier::Read, this);
connect( sn, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(famEventReceived()) );
connect( sn, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(famEventReceived()) );
}
else {
kdDebug(7001) << "Can't use FAM (fam daemon not running?)" << endl;
@ -273,7 +273,7 @@ KSimpleDirWatchPrivate::KSimpleDirWatchPrivate()
fcntl(m_inotify_fd, F_SETFD, FD_CLOEXEC);
mSn = new TQSocketNotifier( m_inotify_fd, TQSocketNotifier::Read, this );
connect( mSn, TQT_SIGNAL(activated( int )), this, TQT_SLOT( slotActivated() ) );
connect( mSn, TQ_SIGNAL(activated( int )), this, TQ_SLOT( slotActivated() ) );
}
#endif
@ -307,7 +307,7 @@ KSimpleDirWatchPrivate::KSimpleDirWatchPrivate()
fcntl(mPipe[0], F_SETFL, O_NONBLOCK | fcntl(mPipe[0], F_GETFL));
fcntl(mPipe[1], F_SETFL, O_NONBLOCK | fcntl(mPipe[1], F_GETFL));
mSn = new TQSocketNotifier( mPipe[0], TQSocketNotifier::Read, this);
connect(mSn, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotActivated()));
connect(mSn, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotActivated()));
// Install the signal handler only once
if ( dnotify_signal == 0 )
{
@ -1372,7 +1372,7 @@ void KSimpleDirWatchPrivate::slotRescan()
if ( timerRunning )
timer->start(freq);
TQTimer::singleShot(0, this, TQT_SLOT(slotRemoveDelayed()));
TQTimer::singleShot(0, this, TQ_SLOT(slotRemoveDelayed()));
}
bool KSimpleDirWatchPrivate::isNoisyFile( const char * filename )
@ -1421,7 +1421,7 @@ void KSimpleDirWatchPrivate::famEventReceived()
checkFAMEvent(&fe);
}
TQTimer::singleShot(0, this, TQT_SLOT(slotRemoveDelayed()));
TQTimer::singleShot(0, this, TQ_SLOT(slotRemoveDelayed()));
}
void KSimpleDirWatchPrivate::checkFAMEvent(FAMEvent* fe)

@ -140,7 +140,7 @@ void TDESocket::enableRead( bool _state )
if ( !d->readNotifier )
{
d->readNotifier = new TQSocketNotifier( sock, TQSocketNotifier::Read );
TQObject::connect( d->readNotifier, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( slotRead(int) ) );
TQObject::connect( d->readNotifier, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( slotRead(int) ) );
}
else
d->readNotifier->setEnabled( true );
@ -156,8 +156,8 @@ void TDESocket::enableWrite( bool _state )
if ( !d->writeNotifier )
{
d->writeNotifier = new TQSocketNotifier( sock, TQSocketNotifier::Write );
TQObject::connect( d->writeNotifier, TQT_SIGNAL( activated(int) ), this,
TQT_SLOT( slotWrite(int) ) );
TQObject::connect( d->writeNotifier, TQ_SIGNAL( activated(int) ), this,
TQ_SLOT( slotWrite(int) ) );
}
else
d->writeNotifier->setEnabled( true );
@ -357,7 +357,7 @@ bool TDEServerSocket::bindAndListen(bool suppressFailureMessages)
sock = d->ks->fd();
connect( d->ks->readNotifier(), TQT_SIGNAL( activated(int) ), this, TQT_SLOT( slotAccept(int) ) );
connect( d->ks->readNotifier(), TQ_SIGNAL( activated(int) ), this, TQ_SLOT( slotAccept(int) ) );
return true;
}

@ -324,11 +324,11 @@ KUniqueApplication::KUniqueApplication(bool allowStyles, bool GUIenabled, bool c
if (s_nofork) {
// Can't call newInstance directly from the constructor since it's virtual...
TQTimer::singleShot( 0, this, TQT_SLOT(newInstanceNoFork()) );
TQTimer::singleShot( 0, this, TQ_SLOT(newInstanceNoFork()) );
}
else {
// Force to handle DCOP requests (newInstance call)
TQTimer::singleShot( 0, this, TQT_SLOT(processDelayed()));
TQTimer::singleShot( 0, this, TQ_SLOT(processDelayed()));
}
}
@ -345,11 +345,11 @@ KUniqueApplication::KUniqueApplication(Display *display, TQt::HANDLE visual,
if (s_nofork) {
// Can't call newInstance directly from the constructor since it's virtual...
TQTimer::singleShot( 0, this, TQT_SLOT(newInstanceNoFork()) );
TQTimer::singleShot( 0, this, TQ_SLOT(newInstanceNoFork()) );
}
else {
// Force to handle DCOP requests (newInstance call)
TQTimer::singleShot( 0, this, TQT_SLOT(processDelayed()));
TQTimer::singleShot( 0, this, TQ_SLOT(processDelayed()));
}
}
#endif
@ -380,7 +380,7 @@ void KUniqueApplication::newInstanceNoFork()
if (dcopClient()->isSuspended())
{
// Try again later.
TQTimer::singleShot( 200, this, TQT_SLOT(newInstanceNoFork()) );
TQTimer::singleShot( 200, this, TQ_SLOT(newInstanceNoFork()) );
return;
}
@ -421,7 +421,7 @@ KUniqueApplication::delayRequest(const TQCString &fun, const TQByteArray &data)
d->requestList.append(request);
if (!d->processingRequest)
{
TQTimer::singleShot(0, this, TQT_SLOT(processDelayed()));
TQTimer::singleShot(0, this, TQ_SLOT(processDelayed()));
}
}
@ -431,7 +431,7 @@ KUniqueApplication::processDelayed()
if (dcopClient()->isSuspended())
{
// Try again later.
TQTimer::singleShot( 200, this, TQT_SLOT(processDelayed()));
TQTimer::singleShot( 200, this, TQ_SLOT(processDelayed()));
return;
}
d->processingRequest = true;

@ -208,7 +208,7 @@ void TDEBufferedSocket::enableRead(bool enable)
if (enable && state() != Connected && d->input && !d->input->isEmpty())
// this means the buffer is still dirty
// allow the signal to be emitted
TQTimer::singleShot(0, this, TQT_SLOT(slotReadActivity()));
TQTimer::singleShot(0, this, TQ_SLOT(slotReadActivity()));
}
void TDEBufferedSocket::enableWrite(bool enable)
@ -358,7 +358,7 @@ void TDEBufferedSocket::slotReadActivity()
{
// buffer isn't empty
// keep emitting signals till it is
TQTimer::singleShot(0, this, TQT_SLOT(slotReadActivity()));
TQTimer::singleShot(0, this, TQ_SLOT(slotReadActivity()));
emit readyRead();
}
}

@ -144,10 +144,10 @@ bool KClientSocketBase::lookup()
// don't restart the lookups if they had succeeded and
// the input values weren't changed
TQObject::connect(&d->peerResolver, TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(lookupFinishedSlot()));
TQObject::connect(&d->localResolver, TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(lookupFinishedSlot()));
TQObject::connect(&d->peerResolver, TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(lookupFinishedSlot()));
TQObject::connect(&d->localResolver, TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(lookupFinishedSlot()));
if (d->localResolver.status() <= 0)
d->localResolver.start();
@ -164,7 +164,7 @@ bool KClientSocketBase::lookup()
if (blocking())
lookupFinishedSlot();
else
TQTimer::singleShot(0, this, TQT_SLOT(lookupFinishedSlot()));
TQTimer::singleShot(0, this, TQ_SLOT(lookupFinishedSlot()));
}
else
{
@ -427,8 +427,8 @@ void KClientSocketBase::lookupFinishedSlot()
if (d->peerResolver.isRunning() || d->localResolver.isRunning() || state() != HostLookup)
return;
TQObject::disconnect(&d->peerResolver, 0L, this, TQT_SLOT(lookupFinishedSlot()));
TQObject::disconnect(&d->localResolver, 0L, this, TQT_SLOT(lookupFinishedSlot()));
TQObject::disconnect(&d->peerResolver, 0L, this, TQ_SLOT(lookupFinishedSlot()));
TQObject::disconnect(&d->localResolver, 0L, this, TQ_SLOT(lookupFinishedSlot()));
if (d->peerResolver.status() < 0 || d->localResolver.status() < 0)
{
setState(Idle); // backtrack
@ -453,7 +453,7 @@ void KClientSocketBase::stateChanging(SocketState newState)
if (n)
{
n->setEnabled(d->enableRead);
TQObject::connect(n, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotReadActivity()));
TQObject::connect(n, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotReadActivity()));
}
else
return;
@ -462,7 +462,7 @@ void KClientSocketBase::stateChanging(SocketState newState)
if (n)
{
n->setEnabled(d->enableWrite);
TQObject::connect(n, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotWriteActivity()));
TQObject::connect(n, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotWriteActivity()));
}
else
return;

@ -52,11 +52,11 @@ KDatagramSocket::KDatagramSocket(TQObject* parent, const char *name)
localResolver().setFlags(KResolver::Passive);
// TQObject::connect(localResolver(), TQT_SIGNAL(finished(KResolverResults)),
// this, TQT_SLOT(lookupFinishedLocal()));
TQObject::connect(&peerResolver(), TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(lookupFinishedPeer()));
TQObject::connect(this, TQT_SIGNAL(hostFound()), this, TQT_SLOT(lookupFinishedLocal()));
// TQObject::connect(localResolver(), TQ_SIGNAL(finished(KResolverResults)),
// this, TQ_SLOT(lookupFinishedLocal()));
TQObject::connect(&peerResolver(), TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(lookupFinishedPeer()));
TQObject::connect(this, TQ_SIGNAL(hostFound()), this, TQ_SLOT(lookupFinishedLocal()));
}
KDatagramSocket::~KDatagramSocket()
@ -265,7 +265,7 @@ void KDatagramSocket::setupSignals()
if (n)
{
n->setEnabled(emitsReadyRead());
TQObject::connect(n, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotReadActivity()));
TQObject::connect(n, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotReadActivity()));
}
else
return;
@ -274,7 +274,7 @@ void KDatagramSocket::setupSignals()
if (n)
{
n->setEnabled(emitsReadyWrite());
TQObject::connect(n, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotWriteActivity()));
TQObject::connect(n, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotWriteActivity()));
}
else
return;

@ -604,7 +604,7 @@ bool KResolver::resolveAsync(TQObject* userObj, const char *userSlot,
int flags, int families)
{
KResolver* qres = new KResolver(host, service, tqApp, "asynchronous KResolver");
TQObject::connect(qres, TQT_SIGNAL(finished(KResolverResults)), userObj, userSlot);
TQObject::connect(qres, TQ_SIGNAL(finished(KResolverResults)), userObj, userSlot);
qres->setFlags(flags);
qres->setFamily(families);
qres->d->deleteWhenDone = true; // this is the only difference from the example code

@ -759,7 +759,7 @@ public:
*
* \code
* KResolver* qres = new KResolver(host, service);
* TQObject::connect(qres, TQT_SIGNAL(finished(KResolverResults)),
* TQObject::connect(qres, TQ_SIGNAL(finished(KResolverResults)),
* userObj, userSlot);
* qres->setFlags(flags);
* qres->setFamily(families);
@ -768,7 +768,7 @@ public:
*
* You should use it like this in your code:
* \code
* KResolver::resolveAsync(myObj, TQT_SLOT(mySlot(KResolverResults)), host, service);
* KResolver::resolveAsync(myObj, TQ_SLOT(mySlot(KResolverResults)), host, service);
* \endcode
*
* @param userObj the object whose slot @p userSlot we will connect

@ -61,15 +61,15 @@ public:
TDEServerSocket::TDEServerSocket(TQObject* parent, const char *name)
: TQObject(parent, name), d(new TDEServerSocketPrivate)
{
TQObject::connect(&d->resolver, TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(lookupFinishedSlot()));
TQObject::connect(&d->resolver, TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(lookupFinishedSlot()));
}
TDEServerSocket::TDEServerSocket(const TQString& service, TQObject* parent, const char *name)
: TQObject(parent, name), d(new TDEServerSocketPrivate)
{
TQObject::connect(&d->resolver, TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(lookupFinishedSlot()));
TQObject::connect(&d->resolver, TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(lookupFinishedSlot()));
d->resolver.setServiceName(service);
}
@ -77,8 +77,8 @@ TDEServerSocket::TDEServerSocket(const TQString& node, const TQString& service,
TQObject* parent, const char* name)
: TQObject(parent, name), d(new TDEServerSocketPrivate)
{
TQObject::connect(&d->resolver, TQT_SIGNAL(finished(KResolverResults)),
this, TQT_SLOT(lookupFinishedSlot()));
TQObject::connect(&d->resolver, TQ_SIGNAL(finished(KResolverResults)),
this, TQ_SLOT(lookupFinishedSlot()));
setAddress(node, service);
}
@ -403,8 +403,8 @@ bool TDEServerSocket::doListen()
}
// set up ready accept signal
TQObject::connect(socketDevice()->readNotifier(), TQT_SIGNAL(activated(int)),
this, TQT_SIGNAL(readyAccept()));
TQObject::connect(socketDevice()->readNotifier(), TQ_SIGNAL(activated(int)),
this, TQ_SIGNAL(readyAccept()));
d->state = TDEServerSocketPrivate::Listening;
return true;
}

@ -50,8 +50,8 @@ class TDEServerSocketPrivate;
* \code
* TQString service = "http";
* TDEServerSocket *ss = new TDEServerSocket(service);
* connect(ss, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
* connect(ss, TQT_SIGNAL(gotError(int)), this, TQT_SLOT(slotSocketError(int)));
* connect(ss, TQ_SIGNAL(readyAccept()), this, TQ_SLOT(slotReadyAccept()));
* connect(ss, TQ_SIGNAL(gotError(int)), this, TQ_SLOT(slotSocketError(int)));
* ss->listen();
* \endcode
*
@ -84,8 +84,8 @@ class TDEServerSocketPrivate;
* if( !found ) {
* // Couldn't connect to any port.
* } else {
* connect(ss, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
* connect(ss, TQT_SIGNAL(gotError(int)), this, TQT_SLOT(slotSocketError(int)));
* connect(ss, TQ_SIGNAL(readyAccept()), this, TQ_SLOT(slotReadyAccept()));
* connect(ss, TQ_SIGNAL(gotError(int)), this, TQ_SLOT(slotSocketError(int)));
* ss->listen();
* }
* \endcode

@ -226,7 +226,7 @@ bool KSrvResolverWorker::postprocess()
void KSrvResolverWorker::customEvent(TQCustomEvent*)
{
dns = new TQDns(TQString::fromLatin1(encodedName), TQDns::Srv);
TQObject::connect(dns, TQT_SIGNAL(resultsReady()), this, TQT_SLOT(dnsResultsReady()));
TQObject::connect(dns, TQ_SIGNAL(resultsReady()), this, TQ_SLOT(dnsResultsReady()));
}
void KSrvResolverWorker::dnsResultsReady()

@ -61,7 +61,7 @@ KStreamSocket::KStreamSocket(const TQString& node, const TQString& service,
setSocketOptions(socketOptions() & ~Blocking);
TQObject::connect(&d->timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timeoutSlot()));
TQObject::connect(&d->timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(timeoutSlot()));
}
KStreamSocket::~KStreamSocket()
@ -130,7 +130,7 @@ bool KStreamSocket::connect(const TQString& node, const TQString& service)
// connection hasn't started yet
if (!blocking())
{
TQObject::connect(this, TQT_SIGNAL(hostFound()), TQT_SLOT(hostFoundSlot()));
TQObject::connect(this, TQ_SIGNAL(hostFound()), TQ_SLOT(hostFoundSlot()));
return lookup();
}
@ -196,10 +196,10 @@ bool KStreamSocket::connect(const KResolverEntry& entry)
void KStreamSocket::hostFoundSlot()
{
TQObject::disconnect(this, TQT_SLOT(hostFoundSlot()));
TQObject::disconnect(this, TQ_SLOT(hostFoundSlot()));
if (timeout() > 0)
d->timer.start(timeout(), true);
TQTimer::singleShot(0, this, TQT_SLOT(connectionEvent()));
TQTimer::singleShot(0, this, TQ_SLOT(connectionEvent()));
}
void KStreamSocket::connectionEvent()
@ -267,13 +267,13 @@ void KStreamSocket::connectionEvent()
if (socketDevice()->error() == InProgress)
{
TQSocketNotifier *n = socketDevice()->readNotifier();
TQObject::connect(n, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(connectionEvent()));
TQObject::connect(n, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(connectionEvent()));
n->setEnabled(true);
n = socketDevice()->writeNotifier();
TQObject::connect(n, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(connectionEvent()));
TQObject::connect(n, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(connectionEvent()));
n->setEnabled(true);
return; // wait for activity
@ -350,8 +350,8 @@ bool KStreamSocket::bindLocallyFor(const KResolverEntry& peer)
void KStreamSocket::connectionSucceeded(const KResolverEntry& peer)
{
TQObject::disconnect(socketDevice()->readNotifier(), 0, this, TQT_SLOT(connectionEvent()));
TQObject::disconnect(socketDevice()->writeNotifier(), 0, this, TQT_SLOT(connectionEvent()));
TQObject::disconnect(socketDevice()->readNotifier(), 0, this, TQ_SLOT(connectionEvent()));
TQObject::disconnect(socketDevice()->writeNotifier(), 0, this, TQ_SLOT(connectionEvent()));
resetError();
setFlags(IO_Sequential | IO_Raw | IO_ReadWrite | IO_Open | IO_Async);

@ -70,14 +70,14 @@ class KStreamSocketPrivate;
* : socket(hostname, port)
* {
* // connect signals to our slots
* TQObject::connect(&socket, TQT_SIGNAL(connected(const KResolverEntry&)),
* this, TQT_SLOT(slotSocketConnected()));
* TQObject::connect(&socket, TQT_SIGNAL(gotError(int)),
* this, TQT_SLOT(slotSocketError(int)));
* TQObject::connect(&socket, TQT_SIGNAL(readyRead()),
* this, TQT_SLOT(slotSocketReadyToRead()));
* TQObject::connect(&socket, TQT_SIGNAL(readyWrite()),
* this, TQT_SLOT(slotSocketReadyToWrite()));
* TQObject::connect(&socket, TQ_SIGNAL(connected(const KResolverEntry&)),
* this, TQ_SLOT(slotSocketConnected()));
* TQObject::connect(&socket, TQ_SIGNAL(gotError(int)),
* this, TQ_SLOT(slotSocketError(int)));
* TQObject::connect(&socket, TQ_SIGNAL(readyRead()),
* this, TQ_SLOT(slotSocketReadyToRead()));
* TQObject::connect(&socket, TQ_SIGNAL(readyWrite()),
* this, TQ_SLOT(slotSocketReadyToWrite()));
*
* // set non-blocking mode in order to work asynchronously
* socket.setBlocking(false);

@ -170,7 +170,7 @@ TDEAccelPrivate::TDEAccelPrivate( TDEAccel* pParent, TQWidget* pWatch )
m_pAccel = pParent;
m_pWatch = pWatch;
m_bAutoUpdate = true;
connect( (TQAccel*)m_pAccel, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotKeyPressed(int)) );
connect( (TQAccel*)m_pAccel, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotKeyPressed(int)) );
#ifdef Q_WS_X11 //only makes sense if TDEAccelEventHandler is working
if( m_pWatch )
@ -240,7 +240,7 @@ bool TDEAccelPrivate::connectKey( TDEAccelAction& action, const KKeyServer::Key&
#ifdef Q_WS_WIN /** @todo TEMP: new implementation (commit #424926) didn't work */
((TQAccel*)m_pAccel)->connectItem( nID, action.objSlotPtr(), action.methodSlotPtr() );
#else
((TQAccel*)m_pAccel)->connectItem( nID, this, TQT_SLOT(slotKeyPressed(int)));
((TQAccel*)m_pAccel)->connectItem( nID, this, TQ_SLOT(slotKeyPressed(int)));
#endif
if( !action.isEnabled() )
((TQAccel*)m_pAccel)->setItemEnabled( nID, false );
@ -318,9 +318,9 @@ void TDEAccelPrivate::slotKeyPressed( int id )
int iAction = pMenu->idAt(1);
slotMenuActivated( iAction );
} else {
connect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotMenuActivated(int)) );
connect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotMenuActivated(int)) );
pMenu->exec( m_pWatch->mapToGlobal( TQPoint( 0, 0 ) ) );
disconnect( pMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotMenuActivated(int)) );
disconnect( pMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotMenuActivated(int)) );
}
delete pMenu;
}
@ -336,9 +336,9 @@ void TDEAccelPrivate::slotMenuActivated( int iAction )
TDEAccelAction* pAction = actions().actionPtr( iAction );
#ifdef Q_WS_WIN /** @todo TEMP: new implementation (commit #424926) didn't work */
if( pAction ) {
connect( this, TQT_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
connect( this, TQ_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
emit menuItemActivated();
disconnect( this, TQT_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
disconnect( this, TQ_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
}
#else
emitActivatedSignal( pAction );
@ -364,10 +364,10 @@ bool TDEAccelPrivate::eventFilter( TQObject* /*pWatched*/, TQEvent* pEvent )
continue;
#ifdef Q_WS_WIN /** @todo TEMP: new implementation (commit #424926) didn't work */
TQGuardedPtr<TDEAccelPrivate> me = this;
connect( this, TQT_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
connect( this, TQ_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
emit menuItemActivated();
if (me) {
disconnect( me, TQT_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
disconnect( me, TQ_SIGNAL(menuItemActivated()), pAction->objSlotPtr(), pAction->methodSlotPtr() );
}
#else
emitActivatedSignal( pAction );
@ -391,18 +391,18 @@ void TDEAccelPrivate::emitActivatedSignal( TDEAccelAction* pAction )
TQGuardedPtr<TDEAccelPrivate> me = this;
TQRegExp reg( "([ ]*TDEAccelAction.*)" );
if( reg.search( pAction->methodSlotPtr()) >= 0 ) {
connect( this, TQT_SIGNAL(menuItemActivated(TDEAccelAction*)),
connect( this, TQ_SIGNAL(menuItemActivated(TDEAccelAction*)),
pAction->objSlotPtr(), pAction->methodSlotPtr() );
emit menuItemActivated( pAction );
if (me)
disconnect( me, TQT_SIGNAL(menuItemActivated(TDEAccelAction*)),
disconnect( me, TQ_SIGNAL(menuItemActivated(TDEAccelAction*)),
pAction->objSlotPtr(), pAction->methodSlotPtr() );
} else {
connect( this, TQT_SIGNAL(menuItemActivated()),
connect( this, TQ_SIGNAL(menuItemActivated()),
pAction->objSlotPtr(), pAction->methodSlotPtr() );
emit menuItemActivated();
if (me)
disconnect( me, TQT_SIGNAL(menuItemActivated()),
disconnect( me, TQ_SIGNAL(menuItemActivated()),
pAction->objSlotPtr(), pAction->methodSlotPtr() );
}

@ -74,9 +74,9 @@ class TDEAccelPrivate;
* // Insert an action "Scroll Up" which is associated with the "Up" key:
* pAccel->insert( "Scroll Up", i18n("Scroll up"),
* i18n("Scroll up the current document by one line."),
* TQt::Key_Up, this, TQT_SLOT(slotScrollUp()) );
* TQt::Key_Up, this, TQ_SLOT(slotScrollUp()) );
* // Insert an standard acclerator action.
* pAccel->insert( TDEStdAccel::Print, this, TQT_SLOT(slotPrint()) );
* pAccel->insert( TDEStdAccel::Print, this, TQ_SLOT(slotPrint()) );
*
* // Update the shortcuts by read any user-defined settings from the
* // application's config file.
@ -159,7 +159,7 @@ class TDECORE_EXPORT TDEAccel : public TQAccel
* insert( "Do Something", i18n("Do Something"),
* i18n("This action allows you to do something really great with this program to "
* "the currently open document."),
* ALT+Key_D, this, TQT_SLOT(slotDoSomething()) );
* ALT+Key_D, this, TQ_SLOT(slotDoSomething()) );
*\endcode
*
* @param sAction The internal name of the action.
@ -191,7 +191,7 @@ class TDECORE_EXPORT TDEAccel : public TQAccel
*
* Usage:
* \code
* insert( i18n("Do Something"), ALT+Key_D, this, TQT_SLOT(slotDoSomething()) );
* insert( i18n("Do Something"), ALT+Key_D, this, TQ_SLOT(slotDoSomething()) );
* \endcode
*
* @param psAction The name AND label of the action.

@ -79,11 +79,11 @@ class TQWidget;
* a->insertItem( i18n("Scroll Up"), "Scroll Up", "Up" );
* // Insert an action "Scroll Down" which is not associated with any key:
* a->insertItem( i18n("Scroll Down"), "Scroll Down", 0);
* a->connectItem( "Scroll up", myWindow, TQT_SLOT( scrollUp() ) );
* a->connectItem( "Scroll up", myWindow, TQ_SLOT( scrollUp() ) );
* // a->insertStdItem( TDEStdAccel::Print ); //not necessary, since it
* // is done automatially with the
* // connect below!
* a->connectItem(TDEStdAccel::Print, myWindow, TQT_SLOT( printDoc() ) );
* a->connectItem(TDEStdAccel::Print, myWindow, TQ_SLOT( printDoc() ) );
*
* a->readSettings();
*\endcode
@ -93,12 +93,12 @@ class TQWidget;
*
* \code
* int id;
* id = popup->insertItem("&Print",this, TQT_SLOT(printDoc()));
* id = popup->insertItem("&Print",this, TQ_SLOT(printDoc()));
* a->changeMenuAccel(popup, id, TDEStdAccel::Print );
* \endcode
*
* If you want a somewhat "exotic" name for your standard print action, like
* id = popup->insertItem(i18n("Print &Document"),this, TQT_SLOT(printDoc()));
* id = popup->insertItem(i18n("Print &Document"),this, TQ_SLOT(printDoc()));
* it might be a good idea to insert the standard action before as
* a->insertStdItem( TDEStdAccel::Print, i18n("Print Document") )
* as well, so that the user can easily find the corresponding function.
@ -107,7 +107,7 @@ class TQWidget;
* in a menu could be done with
*
* \code
* id = popup->insertItem(i18n"Scroll &up",this, TQT_SLOT(scrollUp()));
* id = popup->insertItem(i18n"Scroll &up",this, TQ_SLOT(scrollUp()));
* a->changeMenuAccel(popup, id, "Scroll Up" );
* \endcode
*

@ -734,7 +734,7 @@ TDEPopupAccelManager::TDEPopupAccelManager(TQPopupMenu *popup)
: TQObject(popup), m_popup(popup), m_count(-1)
{
aboutToShow(); // do one check and then connect to show
connect(popup, TQT_SIGNAL(aboutToShow()), TQT_SLOT(aboutToShow()));
connect(popup, TQ_SIGNAL(aboutToShow()), TQ_SLOT(aboutToShow()));
}
@ -840,7 +840,7 @@ QWidgetStackAccelManager::QWidgetStackAccelManager(TQWidgetStack *stack)
: TQObject(stack), m_stack(stack)
{
aboutToShow(stack->visibleWidget()); // do one check and then connect to show
connect(stack, TQT_SIGNAL(aboutToShow(TQWidget *)), TQT_SLOT(aboutToShow(TQWidget *)));
connect(stack, TQ_SIGNAL(aboutToShow(TQWidget *)), TQ_SLOT(aboutToShow(TQWidget *)));
}
bool QWidgetStackAccelManager::eventFilter ( TQObject * watched, TQEvent * e )

@ -522,7 +522,7 @@ void TDEApplication::installX11EventFilter( TQWidget* filter )
return;
if (!x11Filter)
x11Filter = new TQPtrList<TQWidget>;
connect ( filter, TQT_SIGNAL( destroyed() ), this, TQT_SLOT( x11FilterDestroyed() ) );
connect ( filter, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( x11FilterDestroyed() ) );
x11Filter->append( filter );
}
@ -636,7 +636,7 @@ bool TDEApplication::notify(TQObject *receiver, TQEvent *event)
if( d->app_started_timer == NULL )
{
d->app_started_timer = new TQTimer( this, "app_started_timer" );
connect( d->app_started_timer, TQT_SIGNAL( timeout()), TQT_SLOT( checkAppStartedSlot()));
connect( d->app_started_timer, TQ_SIGNAL( timeout()), TQ_SLOT( checkAppStartedSlot()));
}
if( !d->app_started_timer->isActive())
d->app_started_timer->start( 0, true );
@ -1065,7 +1065,7 @@ void TDEApplication::init(bool GUIenabled)
d->oldXIOErrorHandler = XSetIOErrorHandler( kde_xio_errhandler );
#endif
connect( this, TQT_SIGNAL( aboutToQuit() ), this, TQT_SIGNAL( shutDown() ) );
connect( this, TQ_SIGNAL( aboutToQuit() ), this, TQ_SIGNAL( shutDown() ) );
#ifdef Q_WS_X11 //FIXME(E)
display = desktop()->x11Display();
@ -1196,10 +1196,10 @@ DCOPClient *TDEApplication::dcopClient()
s_DCOPClient->setServerAddress( args->getOption("dcopserver"));
}
if( kapp ) {
connect(s_DCOPClient, TQT_SIGNAL(attachFailed(const TQString &)),
kapp, TQT_SLOT(dcopFailure(const TQString &)));
connect(s_DCOPClient, TQT_SIGNAL(blockUserInput(bool) ),
kapp, TQT_SLOT(dcopBlockUserInput(bool)) );
connect(s_DCOPClient, TQ_SIGNAL(attachFailed(const TQString &)),
kapp, TQ_SLOT(dcopFailure(const TQString &)));
connect(s_DCOPClient, TQ_SIGNAL(blockUserInput(bool) ),
kapp, TQ_SLOT(dcopBlockUserInput(bool)) );
}
else
s_dcopClientNeedsPostInit = true;
@ -1213,8 +1213,8 @@ void TDEApplication::dcopClientPostInit()
if( s_dcopClientNeedsPostInit )
{
s_dcopClientNeedsPostInit = false;
connect(s_DCOPClient, TQT_SIGNAL(blockUserInput(bool) ),
TQT_SLOT(dcopBlockUserInput(bool)) );
connect(s_DCOPClient, TQ_SIGNAL(blockUserInput(bool) ),
TQ_SLOT(dcopBlockUserInput(bool)) );
s_DCOPClient->bindToApp(); // Make sure we get events from the DCOPClient.
}
}
@ -3021,27 +3021,27 @@ void TDEApplication::invokeBrowser( const TQString &url, const TQCString& startu
void TDEApplication::cut()
{
invokeEditSlot( TQT_SLOT( cut() ) );
invokeEditSlot( TQ_SLOT( cut() ) );
}
void TDEApplication::copy()
{
invokeEditSlot( TQT_SLOT( copy() ) );
invokeEditSlot( TQ_SLOT( copy() ) );
}
void TDEApplication::paste()
{
invokeEditSlot( TQT_SLOT( paste() ) );
invokeEditSlot( TQ_SLOT( paste() ) );
}
void TDEApplication::clear()
{
invokeEditSlot( TQT_SLOT( clear() ) );
invokeEditSlot( TQ_SLOT( clear() ) );
}
void TDEApplication::selectAll()
{
invokeEditSlot( TQT_SLOT( selectAll() ) );
invokeEditSlot( TQ_SLOT( selectAll() ) );
}
void TDEApplication::broadcastKeyCode(unsigned int keyCode)

@ -621,7 +621,7 @@ public slots:
* If the widget with focus provides a cut() slot, call that slot. Thus for a
* simple application cut can be implemented as:
* \code
* KStdAction::cut( kapp, TQT_SLOT( cut() ), actionCollection() );
* KStdAction::cut( kapp, TQ_SLOT( cut() ), actionCollection() );
* \endcode
*/
void cut();
@ -630,7 +630,7 @@ public slots:
* If the widget with focus provides a copy() slot, call that slot. Thus for a
* simple application copy can be implemented as:
* \code
* KStdAction::copy( kapp, TQT_SLOT( copy() ), actionCollection() );
* KStdAction::copy( kapp, TQ_SLOT( copy() ), actionCollection() );
* \endcode
*/
void copy();
@ -639,7 +639,7 @@ public slots:
* If the widget with focus provides a paste() slot, call that slot. Thus for a
* simple application copy can be implemented as:
* \code
* KStdAction::paste( kapp, TQT_SLOT( paste() ), actionCollection() );
* KStdAction::paste( kapp, TQ_SLOT( paste() ), actionCollection() );
* \endcode
*/
void paste();
@ -648,7 +648,7 @@ public slots:
* If the widget with focus provides a clear() slot, call that slot. Thus for a
* simple application clear() can be implemented as:
* \code
* new TDEAction( i18n( "Clear" ), "edit-clear", 0, kapp, TQT_SLOT( clear() ), actionCollection(), "clear" );
* new TDEAction( i18n( "Clear" ), "edit-clear", 0, kapp, TQ_SLOT( clear() ), actionCollection(), "clear" );
* \endcode
*
* Note that for some widgets, this may not provide the intended bahavior. For
@ -675,7 +675,7 @@ public slots:
* If the widget with focus provides a selectAll() slot, call that slot. Thus for a
* simple application select all can be implemented as:
* \code
* KStdAction::selectAll( kapp, TQT_SLOT( selectAll() ), actionCollection() );
* KStdAction::selectAll( kapp, TQ_SLOT( selectAll() ), actionCollection() );
* \endcode
*/
void selectAll();
@ -1287,7 +1287,7 @@ protected:
* This method is used internally to determine which edit slots are implemented
* by the widget that has the focus, and to invoke those slots if available.
*
* @param slot is the slot as returned using the TQT_SLOT() macro, for example TQT_SLOT( cut() )
* @param slot is the slot as returned using the TQ_SLOT() macro, for example TQ_SLOT( cut() )
*
* This method can be used in TDEApplication subclasses to implement application wide
* edit actions not supported by the TDEApplication class. For example (in your subclass):
@ -1295,7 +1295,7 @@ protected:
* \code
* void MyApplication::deselect()
* {
* invokeEditSlot( TQT_SLOT( deselect() ) );
* invokeEditSlot( TQ_SLOT( deselect() ) );
* }
* \endcode
*
@ -1303,7 +1303,7 @@ protected:
* focused widget if it provides this slot. You can combine this with TDEAction with:
*
* \code
* KStdAction::deselect( static_cast<MyApplication *>( kapp ), TQT_SLOT( cut() ), actionCollection() );
* KStdAction::deselect( static_cast<MyApplication *>( kapp ), TQ_SLOT( cut() ), actionCollection() );
* \endcode
*
* @see cut()

@ -69,52 +69,52 @@ void TDEConfigDialogManager::init(bool trackChanges)
if(trackChanges)
{
// QT
changedMap.insert("TQButton", TQT_SIGNAL(stateChanged(int)));
changedMap.insert("TQCheckBox", TQT_SIGNAL(stateChanged(int)));
changedMap.insert("TQPushButton", TQT_SIGNAL(stateChanged(int)));
changedMap.insert("TQRadioButton", TQT_SIGNAL(stateChanged(int)));
changedMap.insert("TQButton", TQ_SIGNAL(stateChanged(int)));
changedMap.insert("TQCheckBox", TQ_SIGNAL(stateChanged(int)));
changedMap.insert("TQPushButton", TQ_SIGNAL(stateChanged(int)));
changedMap.insert("TQRadioButton", TQ_SIGNAL(stateChanged(int)));
// We can only store one thing, so you can't have
// a ButtonGroup that is checkable.
changedMap.insert("TQButtonGroup", TQT_SIGNAL(clicked(int)));
changedMap.insert("TQGroupBox", TQT_SIGNAL(toggled(bool)));
changedMap.insert("TQComboBox", TQT_SIGNAL(activated (int)));
changedMap.insert("TQButtonGroup", TQ_SIGNAL(clicked(int)));
changedMap.insert("TQGroupBox", TQ_SIGNAL(toggled(bool)));
changedMap.insert("TQComboBox", TQ_SIGNAL(activated (int)));
//qsqlproperty map doesn't store the text, but the value!
//changedMap.insert("TQComboBox", TQT_SIGNAL(textChanged(const TQString &)));
changedMap.insert("TQDateEdit", TQT_SIGNAL(valueChanged(const TQDate &)));
changedMap.insert("TQDateTimeEdit", TQT_SIGNAL(valueChanged(const TQDateTime &)));
changedMap.insert("TQDial", TQT_SIGNAL(valueChanged (int)));
changedMap.insert("TQLineEdit", TQT_SIGNAL(textChanged(const TQString &)));
changedMap.insert("TQSlider", TQT_SIGNAL(valueChanged(int)));
changedMap.insert("TQSpinBox", TQT_SIGNAL(valueChanged(int)));
changedMap.insert("TQTimeEdit", TQT_SIGNAL(valueChanged(const TQTime &)));
changedMap.insert("TQTextEdit", TQT_SIGNAL(textChanged()));
changedMap.insert("TQTextBrowser", TQT_SIGNAL(sourceChanged(const TQString &)));
changedMap.insert("TQMultiLineEdit", TQT_SIGNAL(textChanged()));
changedMap.insert("TQListBox", TQT_SIGNAL(selectionChanged()));
changedMap.insert("TQTabWidget", TQT_SIGNAL(currentChanged(TQWidget *)));
//changedMap.insert("TQComboBox", TQ_SIGNAL(textChanged(const TQString &)));
changedMap.insert("TQDateEdit", TQ_SIGNAL(valueChanged(const TQDate &)));
changedMap.insert("TQDateTimeEdit", TQ_SIGNAL(valueChanged(const TQDateTime &)));
changedMap.insert("TQDial", TQ_SIGNAL(valueChanged (int)));
changedMap.insert("TQLineEdit", TQ_SIGNAL(textChanged(const TQString &)));
changedMap.insert("TQSlider", TQ_SIGNAL(valueChanged(int)));
changedMap.insert("TQSpinBox", TQ_SIGNAL(valueChanged(int)));
changedMap.insert("TQTimeEdit", TQ_SIGNAL(valueChanged(const TQTime &)));
changedMap.insert("TQTextEdit", TQ_SIGNAL(textChanged()));
changedMap.insert("TQTextBrowser", TQ_SIGNAL(sourceChanged(const TQString &)));
changedMap.insert("TQMultiLineEdit", TQ_SIGNAL(textChanged()));
changedMap.insert("TQListBox", TQ_SIGNAL(selectionChanged()));
changedMap.insert("TQTabWidget", TQ_SIGNAL(currentChanged(TQWidget *)));
// KDE
changedMap.insert( "KComboBox", TQT_SIGNAL(activated (int)));
changedMap.insert( "TDEFontCombo", TQT_SIGNAL(activated (int)));
changedMap.insert( "TDEFontRequester", TQT_SIGNAL(fontSelected(const TQFont &)));
changedMap.insert( "TDEFontChooser", TQT_SIGNAL(fontSelected(const TQFont &)));
changedMap.insert( "KHistoryCombo", TQT_SIGNAL(activated (int)));
changedMap.insert( "KColorButton", TQT_SIGNAL(changed(const TQColor &)));
changedMap.insert( "KDatePicker", TQT_SIGNAL(dateSelected (TQDate)));
changedMap.insert( "KDateWidget", TQT_SIGNAL(changed (TQDate)));
changedMap.insert( "KDateTimeWidget", TQT_SIGNAL(valueChanged (const TQDateTime &)));
changedMap.insert( "KEditListBox", TQT_SIGNAL(changed()));