Removed unnecessary and/or TDE-unrelated code.

Signed-off-by: Michele Calgaro <[email protected]>
Signed-off-by: Slávek Banko <[email protected]>

1 files changed, 0 insertions, 360 deletions

diff --git a/tqtinterface/qt4/src/kernel/tqasyncio.cpp b/tqtinterface/qt4/src/kernel/tqasyncio.cpp
deleted file mode 100644
index ee479e0..0000000
--- a/tqtinterface/qt4/src/kernel/tqasyncio.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-/****************************************************************************
-**
-** Implementation of asynchronous I/O classes
-**
-** Created : 970617
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the kernel module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at [email protected].
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#include "tqasyncio.h"
-#include "tqiodevice.h"
-#include <stdlib.h>
-
-#ifndef TQT_NO_ASYNC_IO
-
-/*!
-  \class TQAsyncIO tqasyncio.h
-  \obsolete
-  \brief The TQAsyncIO class encapsulates I/O asynchronicity.
-
-  The TQt classes for asynchronous input/output provide a simple
-  mechanism to allow large files or slow data sources to be processed
-  without using large amounts of memory or blocking the user interface.
-
-  This facility is used in TQt to drive animated images.  See TQImageConsumer.
-*/
-
-
-/*!
-  Destroys the async IO object.
-*/
-TQAsyncIO::~TQAsyncIO()
-{
-}
-
-/*!
-  Ensures that only one object, \a obj and function, \a member, can
-  respond to changes in readiness.
-*/
-void TQAsyncIO::connect(TQObject* obj, const char *member)
-{
-    signal.disconnect(0, 0);
-    signal.connect(obj, member);
-}
-
-/*!
-  Derived classes should call this when they change from being
-  unready to ready.
-*/
-void TQAsyncIO::ready()
-{
-    signal.activate();
-}
-
-
-
-/*!
-  \class TQDataSink tqasyncio.h
-  \obsolete
-  \brief The TQDataSink class is an asynchronous consumer of data.
-
-  A data sink is an object which receives data from some source in an
-  asynchronous manner.  This means that at some time not determined by
-  the data sink, blocks of data are given to it from processing.  The
-  data sink is able to limit the maximum size of such blocks which it
-  is currently able to process.
-
-  \sa TQAsyncIO, TQDataSource, TQDataPump
-*/
-
-/*!
-  \fn int TQDataSink::readyToReceive()
-
-  The data sink should return a value indicating how much data it is ready
-  to consume.  This may be 0.
-*/
-
-/*!
-  This should be called whenever readyToReceive() might have become non-zero.
-  It is merely calls TQAsyncIO::ready() if readyToReceive() is non-zero.
-*/
-void TQDataSink::maybeReady()
-{
-    if (readyToReceive()) ready();
-}
-
-/*!
-  \fn void TQDataSink::receive(const uchar*, int count)
-
-  This function is called to provide data for the data sink.  The \a count
-  will be no more than the amount indicated by the most recent call to
-  readyToReceive().  The sink must use all the provided data.
-*/
-
-/*!
-  \fn void TQDataSink::eof()
-
-  This function will be called when no more data is available for
-  processing.
-*/
-
-
-/*!
-  \class TQDataSource tqasyncio.h
-  \obsolete
-  \brief The TQDataSource class is an asynchronous producer of data.
-
-  A data source is an object which provides data from some source in an
-  asynchronous manner.  This means that at some time not determined by
-  the data source, blocks of data will be taken from it for processing.
-  The data source is able to limit the maximum size of such blocks which
-  it is currently able to provide.
-
-  \sa TQAsyncIO, TQDataSink, TQDataPump
-*/
-
-/*!
-  \fn int TQDataSource::readyToSend()
-
-  The data source should return a value indicating how much data it is ready
-  to provide.  This may be 0.  If the data source knows it will never be
-  able to provide any more data (until after a rewind()), it may return -1.
-*/
-
-/*!
-  This should be called whenever readyToSend() might have become non-zero.
-  It is merely calls TQAsyncIO::ready() if readyToSend() is non-zero.
-*/
-void TQDataSource::maybeReady()
-{
-    if (readyToSend()) ready();
-}
-
-/*!
-  \fn void TQDataSource::sendTo(TQDataSink*, int count)
-
-  This function is called to extract data from the source, by sending
-  it to the given data sink.  The \a count will be no more than the amount
-  indicated by the most recent call to readyToSend().  The source must
-  use all the provided data, and the sink will be prepared to accept at
-  least this much data.
-*/
-
-/*!
-  This function should return TRUE if the data source can be rewound.
-
-  The default returns FALSE.
-*/
-bool TQDataSource::rewindable() const
-{
-    return FALSE;
-}
-
-/*!
-  If this function is called with \a on set to TRUE, and rewindable()
-  is TRUE, then the data source must take measures to allow the rewind()
-  function to subsequently operate as described.  If rewindable() is FALSE,
-  the function should call TQDataSource::enableRewind(), which aborts with
-  a qFatal() error.
-
-  For example, a network connection may choose to use a disk cache
-  of input only if rewinding is enabled before the first buffer-full of
-  data is discarded, returning FALSE in rewindable() if that first buffer
-  is discarded.
-*/
-void TQDataSource::enableRewind( bool /* on */ )
-{
-    qFatal( "Attempted to make unrewindable TQDataSource rewindable" );
-}
-
-/*!
-  This function rewinds the data source.  This may only be called if
-  enableRewind(TRUE) has been previously called.
-*/
-void TQDataSource::rewind()
-{
-    qFatal("Attempted to rewind unrewindable TQDataSource");
-}
-
-/*!
-  \class TQIODeviceSource tqasyncio.h
-  \obsolete
-  \brief The TQIODeviceSource class is a TQDataSource that draws data from a TQIODevice.
-
-  This class encapsulates retrieving data from a TQIODevice (such as a TQFile).
-*/
-
-/*!
-  Constructs a TQIODeviceSource from the TQIODevice \a tqdevice.  The TQIODevice
-  \e must be dynamically allocated, becomes owned by the TQIODeviceSource,
-  and will be deleted when the TQIODeviceSource is destroyed. \a buffer_size
-  determines the size of buffering to use between asynchronous operations.
-  The higher the \a buffer_size, the more efficient, but the less interleaved
-  the operation will be with other processing.
-*/
-TQIODeviceSource::TQIODeviceSource(TQIODevice* tqdevice, int buffer_size) :
-    buf_size(buffer_size),
-    buffer(new uchar[buf_size]),
-    iod(tqdevice),
-    rew(FALSE)
-{
-}
-
-/*!
-  Destroys the TQIODeviceSource, deleting the TQIODevice from which it was
-  constructed.
-*/
-TQIODeviceSource::~TQIODeviceSource()
-{
-    delete iod;
-    delete [] buffer;
-}
-
-/*!
-  Ready until end-of-file.
-*/
-int TQIODeviceSource::readyToSend()
-{
-    if ( iod->status() != IO_Ok || !(iod->state() & IO_Open) )
-	return -1;
-
-    int n = TQMIN((uint)buf_size, iod->size()-iod->at()); // ### not 64-bit safe
-                                                         // ### not large file safe
-    return n ? n : -1;
-}
-
-/*!
-  Reads a block of data and sends up to \a n bytes to the \a sink.
-*/
-void TQIODeviceSource::sendTo(TQDataSink* sink, int n)
-{
-    iod->readBlock((char*)buffer, n);
-    sink->receive(buffer, n);
-}
-
-/*!
-  All TQIODeviceSource's are rewindable.
-*/
-bool TQIODeviceSource::rewindable() const
-{
-    return TRUE;
-}
-
-/*!
-  If \a on is set to TRUE then rewinding is enabled.  
-  No special action is taken.  If \a on is set to 
-  FALSE then rewinding is disabled.
-*/
-void TQIODeviceSource::enableRewind(bool on)
-{
-    rew = on;
-}
-
-/*!
-  Calls reset() on the TQIODevice.
-*/
-void TQIODeviceSource::rewind()
-{
-    if (!rew) {
-	TQDataSource::rewind();
-    } else {
-	iod->reset();
-	ready();
-    }
-}
-
-
-/*!
-  \class TQDataPump tqasyncio.h
-  \obsolete
-  \brief The TQDataPump class moves data from a TQDataSource to a TQDataSink during event processing.
-
-  For a TQDataSource to provide data to a TQDataSink, a controller must exist
-  to examine the TQDataSource::readyToSend() and TQDataSink::readyToReceive()
-  methods and respond to the TQASyncIO::activate() signal of the source and
-  sink.  One very useful way to do this is interleaved with other event
-  processing.  TQDataPump provides this - create a pipe between a source
-  and a sink, and data will be moved during subsequent event processing.
-
-  Note that each source can only provide data to one sink and each sink
-  can only receive data from one source (although it is quite possible
-  to write a multiplexing sink that is multiple sources).
-*/
-
-/*!
-  Constructs a TQDataPump to move data from a given \a data_source
-  to a given \a data_sink.
-*/
-TQDataPump::TQDataPump(TQDataSource* data_source, TQDataSink* data_sink) :
-    source(data_source), sink(data_sink)
-{
-    source->connect(this, TQT_SLOT(kickStart()));
-    sink->connect(this, TQT_SLOT(kickStart()));
-    connect(&timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(tryToPump()));
-    timer.start(0, TRUE);
-}
-
-void TQDataPump::kickStart()
-{
-    if (!timer.isActive()) {
-	interval = 0;
-	timer.start(0, TRUE);
-    }
-}
-
-void TQDataPump::tryToPump()
-{
-    int supply, demand;
-
-    supply = source->readyToSend();
-    demand = sink->readyToReceive();
-    if (demand <= 0) {
-	return;
-    }
-    interval = 0;
-    if (supply < 0) {
-	// All done (until source Q_SIGNALS change in readiness)
-	sink->eof();
-	return;
-    }
-    if (!supply)
-	return;
-    source->sendTo(sink, TQMIN(supply, demand));
-
-    timer.start(0, TRUE);
-}
-
-#endif // TQT_NO_ASYNC_IO
-