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, 2384 deletions

diff --git a/tqtinterface/qt4/src/network/tqhttp.cpp b/tqtinterface/qt4/src/network/tqhttp.cpp
deleted file mode 100644
index 6b1f061..0000000
--- a/tqtinterface/qt4/src/network/tqhttp.cpp
+++ /dev/null
@@ -1,2384 +0,0 @@
-/****************************************************************************
-**
-** Implementation of TQHttp and related classes.
-**
-** Created : 970521
-**
-** Copyright (C) 1997-2008 Trolltech ASA.  All rights reserved.
-**
-** This file is part of the network 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 "tqhttp.h"
-
-#ifndef TQT_NO_NETWORKPROTOCOL_HTTP
-
-#include "tqsocket.h"
-#include "tqtextstream.h"
-#include "tqmap.h"
-#include "tqstring.h"
-#include "tqstringlist.h"
-#include "tqcstring.h"
-#include "tqbuffer.h"
-#include "tqurloperator.h"
-#include "tqtimer.h"
-#include "private/tqinternal_p.h"
-
-//#define TQHTTP_DEBUG
-
-class TQHttpPrivate
-{
-public:
-    TQHttpPrivate() :
-	state( TQHttp::Unconnected ),
-	error( TQHttp::NoError ),
-	hostname( TQString::null ),
-	port( 0 ),
-	toDevice( 0 ),
-	postDevice( 0 ),
-	bytesDone( 0 ),
-	chunkedSize( -1 ),
-	idleTimer( 0 )
-    {
-	pending.setAutoDelete( TRUE );
-    }
-
-    TQSocket socket;
-    TQPtrList<TQHttpRequest> pending;
-
-    TQHttp::State state;
-    TQHttp::Error error;
-    TQString errorString;
-
-    TQString hostname;
-    TQ_UINT16 port;
-
-    TQByteArray buffer;
-    TQIODevice* toDevice;
-    TQIODevice* postDevice;
-
-    uint bytesDone;
-    uint bytesTotal;
-    TQ_LONG chunkedSize;
-
-    TQHttpRequestHeader header;
-
-    bool readHeader;
-    TQString headerStr;
-    TQHttpResponseHeader response;
-
-    int idleTimer;
-
-    TQMembuf rba;
-};
-
-class TQHttpRequest
-{
-public:
-    TQHttpRequest()
-    {
-	id = ++idCounter;
-    }
-    virtual ~TQHttpRequest()
-    { }
-
-    virtual void start( TQHttp * ) = 0;
-    virtual bool hasRequestHeader();
-    virtual TQHttpRequestHeader requestHeader();
-
-    virtual TQIODevice* sourceDevice() = 0;
-    virtual TQIODevice* destinationDevice() = 0;
-
-    int id;
-
-private:
-    static int idCounter;
-};
-
-int TQHttpRequest::idCounter = 0;
-
-bool TQHttpRequest::hasRequestHeader()
-{
-    return FALSE;
-}
-
-TQHttpRequestHeader TQHttpRequest::requestHeader()
-{
-    return TQHttpRequestHeader();
-}
-
-/****************************************************
- *
- * TQHttpNormalRequest
- *
- ****************************************************/
-
-class TQHttpNormalRequest : public TQHttpRequest
-{
-public:
-    TQHttpNormalRequest( const TQHttpRequestHeader &h, TQIODevice *d, TQIODevice *t ) :
-	header(h), to(t)
-    {
-	is_ba = FALSE;
-	data.dev = d;
-    }
-
-    TQHttpNormalRequest( const TQHttpRequestHeader &h, TQByteArray *d, TQIODevice *t ) :
-	header(h), to(t)
-    {
-	is_ba = TRUE;
-	data.ba = d;
-    }
-
-    ~TQHttpNormalRequest()
-    {
-	if ( is_ba )
-	    delete data.ba;
-    }
-
-    void start( TQHttp * );
-    bool hasRequestHeader();
-    TQHttpRequestHeader requestHeader();
-
-    TQIODevice* sourceDevice();
-    TQIODevice* destinationDevice();
-
-protected:
-    TQHttpRequestHeader header;
-
-private:
-    union {
-	TQByteArray *ba;
-	TQIODevice *dev;
-    } data;
-    bool is_ba;
-    TQIODevice *to;
-};
-
-void TQHttpNormalRequest::start( TQHttp *http )
-{
-    http->d->header = header;
-
-    if ( is_ba ) {
-	http->d->buffer = *data.ba;
-	if ( http->d->buffer.size() > 0 )
-	    http->d->header.setContentLength( http->d->buffer.size() );
-
-	http->d->postDevice = 0;
-    } else {
-	http->d->buffer = TQByteArray();
-
-	if ( data.dev && ( data.dev->isOpen() || data.dev->open(IO_ReadOnly) ) ) {
-	    http->d->postDevice = data.dev;
-	    if ( http->d->postDevice->size() > 0 )
-		http->d->header.setContentLength( http->d->postDevice->size() );
-	} else {
-	    http->d->postDevice = 0;
-	}
-    }
-
-    if ( to && ( to->isOpen() || to->open(IO_WriteOnly) ) )
-	http->d->toDevice = to;
-    else
-	http->d->toDevice = 0;
-
-    http->sendRequest();
-}
-
-bool TQHttpNormalRequest::hasRequestHeader()
-{
-    return TRUE;
-}
-
-TQHttpRequestHeader TQHttpNormalRequest::requestHeader()
-{
-    return header;
-}
-
-TQIODevice* TQHttpNormalRequest::sourceDevice()
-{
-    if ( is_ba )
-	return 0;
-    return data.dev;
-}
-
-TQIODevice* TQHttpNormalRequest::destinationDevice()
-{
-    return to;
-}
-
-/****************************************************
- *
- * TQHttpPGHRequest
- * (like a TQHttpNormalRequest, but for the convenience
- * functions put(), get() and head() -- i.e. set the
- * host header field correctly before sending the
- * request)
- *
- ****************************************************/
-
-class TQHttpPGHRequest : public TQHttpNormalRequest
-{
-public:
-    TQHttpPGHRequest( const TQHttpRequestHeader &h, TQIODevice *d, TQIODevice *t ) :
-	TQHttpNormalRequest( h, d, t )
-    { }
-
-    TQHttpPGHRequest( const TQHttpRequestHeader &h, TQByteArray *d, TQIODevice *t ) :
-	TQHttpNormalRequest( h, d, t )
-    { }
-
-    ~TQHttpPGHRequest()
-    { }
-
-    void start( TQHttp * );
-};
-
-void TQHttpPGHRequest::start( TQHttp *http )
-{
-    header.setValue( "Host", http->d->hostname );
-    TQHttpNormalRequest::start( http );
-}
-
-/****************************************************
- *
- * TQHttpSetHostRequest
- *
- ****************************************************/
-
-class TQHttpSetHostRequest : public TQHttpRequest
-{
-public:
-    TQHttpSetHostRequest( const TQString &h, TQ_UINT16 p ) :
-	hostname(h), port(p)
-    { }
-
-    void start( TQHttp * );
-
-    TQIODevice* sourceDevice()
-    { return 0; }
-    TQIODevice* destinationDevice()
-    { return 0; }
-
-private:
-    TQString hostname;
-    TQ_UINT16 port;
-};
-
-void TQHttpSetHostRequest::start( TQHttp *http )
-{
-    http->d->hostname = hostname;
-    http->d->port = port;
-    http->finishedWithSuccess();
-}
-
-/****************************************************
- *
- * TQHttpCloseRequest
- *
- ****************************************************/
-
-class TQHttpCloseRequest : public TQHttpRequest
-{
-public:
-    TQHttpCloseRequest()
-    { }
-    void start( TQHttp * );
-
-    TQIODevice* sourceDevice()
-    { return 0; }
-    TQIODevice* destinationDevice()
-    { return 0; }
-};
-
-void TQHttpCloseRequest::start( TQHttp *http )
-{
-    http->close();
-}
-
-/****************************************************
- *
- * TQHttpHeader
- *
- ****************************************************/
-
-/*!
-    \class TQHttpHeader tqhttp.h
-    \brief The TQHttpHeader class contains header information for HTTP.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \ingroup io
-    \module network
-
-    In most cases you should use the more specialized derivatives of
-    this class, TQHttpResponseHeader and TQHttpRequestHeader, rather
-    than directly using TQHttpHeader.
-
-    TQHttpHeader provides the HTTP header fields. A HTTP header field
-    consists of a name followed by a colon, a single space, and the
-    field value. (See RFC 1945.) Field names are case-insensitive. A
-    typical header field looks like this:
-    \code
-    content-type: text/html
-    \endcode
-
-    In the API the header field name is called the "key" and the
-    content is called the "value". You can get and set a header
-    field's value by using its key with value() and setValue(), e.g.
-    \code
-    header.setValue( "content-type", "text/html" );
-    TQString contentType = header.value( "content-type" );
-    \endcode
-
-    Some fields are so common that getters and setters are provided
-    for them as a convenient alternative to using \l value() and
-    \l setValue(), e.g. contentLength() and contentType(),
-    setContentLength() and setContentType().
-
-    Each header key has a \e single value associated with it. If you
-    set the value for a key which already exists the previous value
-    will be discarded.
-
-    \sa TQHttpRequestHeader TQHttpResponseHeader
-*/
-
-/*!
-    \fn int TQHttpHeader::majorVersion() const
-
-    Returns the major protocol-version of the HTTP header.
-*/
-
-/*!
-    \fn int TQHttpHeader::minorVersion() const
-
-    Returns the minor protocol-version of the HTTP header.
-*/
-
-/*!
-	Constructs an empty HTTP header.
-*/
-TQHttpHeader::TQHttpHeader()
-    : valid( TRUE )
-{
-}
-
-/*!
-	Constructs a copy of \a header.
-*/
-TQHttpHeader::TQHttpHeader( const TQHttpHeader& header )
-    : valid( header.valid )
-{
-    values = header.values;
-}
-
-/*!
-    Constructs a HTTP header for \a str.
-
-    This constructor parses the string \a str for header fields and
-    adds this information. The \a str should consist of one or more
-    "\r\n" delimited lines; each of these lines should have the format
-    key, colon, space, value.
-*/
-TQHttpHeader::TQHttpHeader( const TQString& str )
-    : valid( TRUE )
-{
-    parse( str );
-}
-
-/*!
-    Destructor.
-*/
-TQHttpHeader::~TQHttpHeader()
-{
-}
-
-/*!
-    Assigns \a h and returns a reference to this http header.
-*/
-TQHttpHeader& TQHttpHeader::operator=( const TQHttpHeader& h )
-{
-    values = h.values;
-    valid = h.valid;
-    return *this;
-}
-
-/*!
-    Returns TRUE if the HTTP header is valid; otherwise returns FALSE.
-
-    A TQHttpHeader is invalid if it was created by parsing a malformed string.
-*/
-bool TQHttpHeader::isValid() const
-{
-    return valid;
-}
-
-/*! \internal
-    Parses the HTTP header string \a str for header fields and adds
-    the keys/values it finds. If the string is not parsed successfully
-    the TQHttpHeader becomes \link isValid() invalid\endlink.
-
-    Returns TRUE if \a str was successfully parsed; otherwise returns FALSE.
-
-    \sa toString()
-*/
-bool TQHttpHeader::parse( const TQString& str )
-{
-    TQStringList lst;
-    int pos = str.find( '\n' );
-    if ( pos > 0 && str.at( pos - 1 ) == '\r' )
-	lst = TQStringList::split( "\r\n", str.stripWhiteSpace(), FALSE );
-    else
-	lst = TQStringList::split( "\n", str.stripWhiteSpace(), FALSE );
-
-    if ( lst.isEmpty() )
-	return TRUE;
-
-    TQStringList lines;
-    TQStringList::Iterator it = lst.begin();
-    for( ; it != lst.end(); ++it ) {
-	if ( !(*it).isEmpty() ) {
-	    if ( (*it)[0].isSpace() ) {
-		if ( !lines.isEmpty() ) {
-		    lines.last() += " ";
-		    lines.last() += (*it).stripWhiteSpace();
-		}
-	    } else {
-		lines.append( (*it) );
-	    }
-	}
-    }
-
-    int number = 0;
-    it = lines.begin();
-    for( ; it != lines.end(); ++it ) {
-	if ( !parseLine( *it, number++ ) ) {
-	    valid = FALSE;
-	    return FALSE;
-	}
-    }
-    return TRUE;
-}
-
-/*! \internal
-*/
-void TQHttpHeader::setValid( bool v )
-{
-    valid = v;
-}
-
-/*!
-    Returns the value for the entry with the given \a key. If no entry
-    has this \a key, an empty string is returned.
-
-    \sa setValue() removeValue() hasKey() keys()
-*/
-TQString TQHttpHeader::value( const TQString& key ) const
-{
-    return values[ key.lower() ];
-}
-
-/*!
-    Returns a list of the keys in the HTTP header.
-
-    \sa hasKey()
-*/
-TQStringList TQHttpHeader::keys() const
-{
-    return values.keys();
-}
-
-/*!
-    Returns TRUE if the HTTP header has an entry with the given \a
-    key; otherwise returns FALSE.
-
-    \sa value() setValue() keys()
-*/
-bool TQHttpHeader::hasKey( const TQString& key ) const
-{
-    return values.contains( key.lower() );
-}
-
-/*!
-    Sets the value of the entry with the \a key to \a value.
-
-    If no entry with \a key exists, a new entry with the given \a key
-    and \a value is created. If an entry with the \a key already
-    exists, its value is discarded and replaced with the given \a
-    value.
-
-    \sa value() hasKey() removeValue()
-*/
-void TQHttpHeader::setValue( const TQString& key, const TQString& value )
-{
-    values[ key.lower() ] = value;
-}
-
-/*!
-    Removes the entry with the key \a key from the HTTP header.
-
-    \sa value() setValue()
-*/
-void TQHttpHeader::removeValue( const TQString& key )
-{
-    values.remove( key.lower() );
-}
-
-/*! \internal
-    Parses the single HTTP header line \a line which has the format
-    key, colon, space, value, and adds key/value to the headers. The
-    linenumber is \a number. Returns TRUE if the line was successfully
-    parsed and the key/value added; otherwise returns FALSE.
-
-    \sa parse()
-*/
-bool TQHttpHeader::parseLine( const TQString& line, int )
-{
-    int i = line.find( ":" );
-    if ( i == -1 )
-	return FALSE;
-
-    values.insert( TQT_TQSTRING(line.left( i )).stripWhiteSpace().lower(), TQT_TQSTRING(line.mid( i + 1 )).stripWhiteSpace() );
-
-    return TRUE;
-}
-
-/*!
-    Returns a string representation of the HTTP header.
-
-    The string is suitable for use by the constructor that takes a
-    TQString. It consists of lines with the format: key, colon, space,
-    value, "\r\n".
-*/
-TQString TQHttpHeader::toString() const
-{
-    if ( !isValid() )
-	return "";
-
-    TQString ret = "";
-
-    TQMap<TQString,TQString>::ConstIterator it = values.begin();
-    for( ; it != values.end(); ++it )
-	ret += it.key() + ": " + it.data() + "\r\n";
-
-    return ret;
-}
-
-/*!
-    Returns TRUE if the header has an entry for the special HTTP
-    header field \c content-length; otherwise returns FALSE.
-
-    \sa contentLength() setContentLength()
-*/
-bool TQHttpHeader::hasContentLength() const
-{
-    return hasKey( "content-length" );
-}
-
-/*!
-    Returns the value of the special HTTP header field \c
-    content-length.
-
-    \sa setContentLength() hasContentLength()
-*/
-uint TQHttpHeader::contentLength() const
-{
-    return values[ "content-length" ].toUInt();
-}
-
-/*!
-    Sets the value of the special HTTP header field \c content-length
-    to \a len.
-
-    \sa contentLength() hasContentLength()
-*/
-void TQHttpHeader::setContentLength( int len )
-{
-    values[ "content-length" ] = TQString::number( len );
-}
-
-/*!
-    Returns TRUE if the header has an entry for the the special HTTP
-    header field \c content-type; otherwise returns FALSE.
-
-    \sa contentType() setContentType()
-*/
-bool TQHttpHeader::hasContentType() const
-{
-    return hasKey( "content-type" );
-}
-
-/*!
-    Returns the value of the special HTTP header field \c content-type.
-
-    \sa setContentType() hasContentType()
-*/
-TQString TQHttpHeader::contentType() const
-{
-    TQString type = values[ "content-type" ];
-    if ( type.isEmpty() )
-	return TQString::null;
-
-    int pos = type.find( ";" );
-    if ( pos == -1 )
-	return type;
-
-    return TQT_TQSTRING(type.left( pos )).stripWhiteSpace();
-}
-
-/*!
-    Sets the value of the special HTTP header field \c content-type to
-    \a type.
-
-    \sa contentType() hasContentType()
-*/
-void TQHttpHeader::setContentType( const TQString& type )
-{
-    values[ "content-type" ] = type;
-}
-
-/****************************************************
- *
- * TQHttpResponseHeader
- *
- ****************************************************/
-
-/*!
-    \class TQHttpResponseHeader tqhttp.h
-    \brief The TQHttpResponseHeader class contains response header information for HTTP.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \ingroup io
-    \module network
-
-    This class is used by the TQHttp class to report the header
-    information that the client received from the server.
-
-    HTTP responses have a status code that indicates the status of the
-    response. This code is a 3-digit integer result code (for details
-    see to RFC 1945). In addition to the status code, you can also
-    specify a human-readable text that describes the reason for the
-    code ("reason phrase"). This class allows you to get the status
-    code and the reason phrase.
-
-    \sa TQHttpRequestHeader TQHttp
-*/
-
-/*!
-    Constructs an empty HTTP response header.
-*/
-TQHttpResponseHeader::TQHttpResponseHeader()
-{
-    setValid( FALSE );
-}
-
-/*!
-    Constructs a HTTP response header with the status code \a code,
-    the reason phrase \a text and the protocol-version \a majorVer and
-    \a minorVer.
-*/
-TQHttpResponseHeader::TQHttpResponseHeader( int code, const TQString& text, int majorVer, int minorVer )
-    : TQHttpHeader(), statCode( code ), reasonPhr( text ), majVer( majorVer ), minVer( minorVer )
-{
-}
-
-/*!
-    Constructs a copy of \a header.
-*/
-TQHttpResponseHeader::TQHttpResponseHeader( const TQHttpResponseHeader& header )
-    : TQHttpHeader( header ), statCode( header.statCode ), reasonPhr( header.reasonPhr ), majVer( header.majVer ), minVer( header.minVer )
-{
-}
-
-/*!
-    Constructs a HTTP response header from the string \a str. The
-    string is parsed and the information is set. The \a str should
-    consist of one or more "\r\n" delimited lines; the first line should be the
-    status-line (format: HTTP-version, space, status-code, space,
-    reason-phrase); each of remaining lines should have the format key, colon,
-    space, value.
-*/
-TQHttpResponseHeader::TQHttpResponseHeader( const TQString& str )
-    : TQHttpHeader()
-{
-    parse( str );
-}
-
-/*!
-    Sets the status code to \a code, the reason phrase to \a text and
-    the protocol-version to \a majorVer and \a minorVer.
-
-    \sa statusCode() reasonPhrase() majorVersion() minorVersion()
-*/
-void TQHttpResponseHeader::setqStatusLine( int code, const TQString& text, int majorVer, int minorVer )
-{
-    setValid( TRUE );
-    statCode = code;
-    reasonPhr = text;
-    majVer = majorVer;
-    minVer = minorVer;
-}
-
-/*!
-    Returns the status code of the HTTP response header.
-
-    \sa reasonPhrase() majorVersion() minorVersion()
-*/
-int TQHttpResponseHeader::statusCode() const
-{
-    return statCode;
-}
-
-/*!
-    Returns the reason phrase of the HTTP response header.
-
-    \sa statusCode() majorVersion() minorVersion()
-*/
-TQString TQHttpResponseHeader::reasonPhrase() const
-{
-    return reasonPhr;
-}
-
-/*!
-    Returns the major protocol-version of the HTTP response header.
-
-    \sa minorVersion() statusCode() reasonPhrase()
-*/
-int TQHttpResponseHeader::majorVersion() const
-{
-    return majVer;
-}
-
-/*!
-    Returns the minor protocol-version of the HTTP response header.
-
-    \sa majorVersion() statusCode() reasonPhrase()
-*/
-int TQHttpResponseHeader::minorVersion() const
-{
-    return minVer;
-}
-
-/*! \reimp
-*/
-bool TQHttpResponseHeader::parseLine( const TQString& line, int number )
-{
-    if ( number != 0 )
-	return TQHttpHeader::parseLine( line, number );
-
-    TQString l = line.simplifyWhiteSpace();
-    if ( l.length() < 10 )
-	return FALSE;
-
-    if ( l.left( 5 ) == "HTTP/" && l[5].isDigit() && l[6] == '.' &&
-	    l[7].isDigit() && l[8] == ' ' && l[9].isDigit() ) {
-	majVer = l[5].latin1() - '0';
-	minVer = l[7].latin1() - '0';
-
-	int pos = l.find( ' ', 9 );
-	if ( pos != -1 ) {
-	    reasonPhr = l.mid( pos + 1 );
-	    statCode = l.mid( 9, pos - 9 ).toInt();
-	} else {
-	    statCode = l.mid( 9 ).toInt();
-	    reasonPhr = TQString::null;
-	}
-    } else {
-	return FALSE;
-    }
-
-    return TRUE;
-}
-
-/*! \reimp
-*/
-TQString TQHttpResponseHeader::toString() const
-{
-    TQString ret( "HTTP/%1.%2 %3 %4\r\n%5\r\n" );
-    return ret.arg( majVer ).arg ( minVer ).arg( statCode ).arg( reasonPhr ).arg( TQHttpHeader::toString() );
-}
-
-/****************************************************
- *
- * TQHttpRequestHeader
- *
- ****************************************************/
-
-/*!
-    \class TQHttpRequestHeader tqhttp.h
-    \brief The TQHttpRequestHeader class contains request header information for
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-    HTTP.
-\if defined(commercial_edition)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \ingroup io
-    \module network
-
-    This class is used in the TQHttp class to report the header
-    information if the client requests something from the server.
-
-    HTTP requests have a method which describes the request's action.
-    The most common requests are "GET" and "POST". In addition to the
-    request method the header also includes a request-URI to specify
-    the location for the method to use.
-
-    The method, request-URI and protocol-version can be set using a
-    constructor or later using setRequest(). The values can be
-    obtained using method(), path(), majorVersion() and
-    minorVersion().
-
-    This class is a TQHttpHeader subclass so that class's functions,
-    e.g. \link TQHttpHeader::setValue() setValue()\endlink, \link
-    TQHttpHeader::value() value()\endlink, etc. are also available.
-
-    \sa TQHttpResponseHeader TQHttp
-
-    \important value() setValue()
-*/
-
-/*!
-    Constructs an empty HTTP request header.
-*/
-TQHttpRequestHeader::TQHttpRequestHeader()
-    : TQHttpHeader()
-{
-    setValid( FALSE );
-}
-
-/*!
-    Constructs a HTTP request header for the method \a method, the
-    request-URI \a path and the protocol-version \a majorVer and \a minorVer.
-*/
-TQHttpRequestHeader::TQHttpRequestHeader( const TQString& method, const TQString& path, int majorVer, int minorVer )
-    : TQHttpHeader(), m( method ), p( path ), majVer( majorVer ), minVer( minorVer )
-{
-}
-
-/*!
-    Constructs a copy of \a header.
-*/
-TQHttpRequestHeader::TQHttpRequestHeader( const TQHttpRequestHeader& header )
-    : TQHttpHeader( header ), m( header.m ), p( header.p ), majVer( header.majVer ), minVer( header.minVer )
-{
-}
-
-/*!
-    Constructs a HTTP request header from the string \a str. The \a
-    str should consist of one or more "\r\n" delimited lines; the first line
-    should be the request-line (format: method, space, request-URI, space
-    HTTP-version); each of the remaining lines should have the format key,
-    colon, space, value.
-*/
-TQHttpRequestHeader::TQHttpRequestHeader( const TQString& str )
-    : TQHttpHeader()
-{
-    parse( str );
-}
-
-/*!
-    This function sets the request method to \a method, the
-    request-URI to \a path and the protocol-version to \a majorVer and
-    \a minorVer.
-
-    \sa method() path() majorVersion() minorVersion()
-*/
-void TQHttpRequestHeader::setRequest( const TQString& method, const TQString& path, int majorVer, int minorVer )
-{
-    setValid( TRUE );
-    m = method;
-    p = path;
-    majVer = majorVer;
-    minVer = minorVer;
-}
-
-/*!
-    Returns the method of the HTTP request header.
-
-    \sa path() majorVersion() minorVersion() setRequest()
-*/
-TQString TQHttpRequestHeader::method() const
-{
-    return m;
-}
-
-/*!
-    Returns the request-URI of the HTTP request header.
-
-    \sa method() majorVersion() minorVersion() setRequest()
-*/
-TQString TQHttpRequestHeader::path() const
-{
-    return p;
-}
-
-/*!
-    Returns the major protocol-version of the HTTP request header.
-
-    \sa minorVersion() method() path() setRequest()
-*/
-int TQHttpRequestHeader::majorVersion() const
-{
-    return majVer;
-}
-
-/*!
-    Returns the minor protocol-version of the HTTP request header.
-
-    \sa majorVersion() method() path() setRequest()
-*/
-int TQHttpRequestHeader::minorVersion() const
-{
-    return minVer;
-}
-
-/*! \reimp
-*/
-bool TQHttpRequestHeader::parseLine( const TQString& line, int number )
-{
-    if ( number != 0 )
-	return TQHttpHeader::parseLine( line, number );
-
-    TQStringList lst = TQStringList::split( " ", line.simplifyWhiteSpace() );
-    if ( lst.count() > 0 ) {
-	m = lst[0];
-	if ( lst.count() > 1 ) {
-	    p = lst[1];
-	    if ( lst.count() > 2 ) {
-		TQString v = lst[2];
-		if ( v.length() >= 8 && v.left( 5 ) == "HTTP/" &&
-			v[5].isDigit() && v[6] == '.' && v[7].isDigit() ) {
-		    majVer = v[5].latin1() - '0';
-		    minVer = v[7].latin1() - '0';
-		    return TRUE;
-		}
-	    }
-	}
-    }
-
-    return FALSE;
-}
-
-/*! \reimp
-*/
-TQString TQHttpRequestHeader::toString() const
-{
-    TQString first( "%1 %2");
-    TQString last(" HTTP/%3.%4\r\n%5\r\n" );
-    return first.arg( m ).arg( p ) +
-	last.arg( majVer ).arg( minVer ).arg( TQHttpHeader::toString());
-}
-
-
-/****************************************************
- *
- * TQHttp
- *
- ****************************************************/
-/*!
-    \class TQHttp tqhttp.h
-    \brief The TQHttp class provides an implementation of the HTTP protocol.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \ingroup io
-    \module network
-
-    This class provides two different interfaces: one is the
-    TQNetworkProtocol interface that allows you to use HTTP through the
-    TQUrlOperator abstraction. The other is a direct interface to HTTP
-    that allows you to have more control over the requests and that
-    allows you to access the response header fields.
-
-    Don't mix the two interfaces, since the behavior is not
-    well-defined.
-
-    If you want to use TQHttp with the TQNetworkProtocol interface, you
-    do not use it directly, but rather through a TQUrlOperator, for
-    example:
-
-    \code
-    TQUrlOperator op( "http://www.trolltech.com" );
-    op.get( "index.html" );
-    \endcode
-
-    This code will only work if the TQHttp class is registered; to
-    register the class, you must call qInitNetworkProtocols() before
-    using a TQUrlOperator with HTTP.
-
-    The TQNetworkProtocol interface for HTTP only supports the
-    operations operationGet() and operationPut(), i.e.
-    TQUrlOperator::get() and TQUrlOperator::put(), if you use it with a
-    TQUrlOperator.
-
-    The rest of this descrption describes the direct interface to
-    HTTP.
-
-    The class works asynchronously, so there are no blocking
-    functions. If an operation cannot be executed immediately, the
-    function will still return straight away and the operation will be
-    scheduled for later execution. The results of scheduled operations
-    are reported via Q_SIGNALS. This approach depends on the event loop
-    being in operation.
-
-    The operations that can be scheduled (they are called "requests"
-    in the rest of the documentation) are the following: setHost(),
-    get(), post(), head() and request().
-
-    All of these requests return a unique identifier that allows you
-    to keep track of the request that is currently executed. When the
-    execution of a request starts, the requestStarted() signal with
-    the identifier is emitted and when the request is finished, the
-    requestFinished() signal is emitted with the identifier and a bool
-    that indicates if the request finished with an error.
-
-    To make an HTTP request you must set up suitable HTTP headers. The
-    following example demonstrates, how to request the main HTML page
-    from the Trolltech home page (i.e. the URL
-    http://www.trolltech.com/index.html):
-
-    \code
-    TQHttpRequestHeader header( "GET", "/index.html" );
-    header.setValue( "Host", "www.trolltech.com" );
-    http->setHost( "www.trolltech.com" );
-    http->request( header );
-    \endcode
-
-    For the common HTTP requests \c GET, \c POST and \c HEAD, TQHttp
-    provides the convenience functions get(), post() and head(). They
-    already use a reasonable header and if you don't have to set
-    special header fields, they are easier to use. The above example
-    can also be written as:
-
-    \code
-    http->setHost( "www.trolltech.com" ); // id == 1
-    http->get( "/index.html" );           // id == 2
-    \endcode
-
-    For this example the following sequence of Q_SIGNALS is emitted
-    (with small variations, depending on network traffic, etc.):
-
-    \code
-    requestStarted( 1 )
-    requestFinished( 1, FALSE )
-
-    requestStarted( 2 )
-    stateChanged( Connecting )
-    stateChanged( Sending )
-    dataSendProgress( 77, 77 )
-    stateChanged( Reading )
-    responseHeaderReceived( responseheader )
-    dataReadProgress( 5388, 0 )
-    readyRead( responseheader )
-    dataReadProgress( 18300, 0 )
-    readyRead( responseheader )
-    stateChanged( Connected )
-    requestFinished( 2, FALSE )
-
-    done( FALSE )
-
-    stateChanged( Closing )
-    stateChanged( Unconnected )
-    \endcode
-
-    The dataSendProgress() and dataReadProgress() Q_SIGNALS in the above
-    example are useful if you want to show a \link TQProgressBar
-    progressbar\endlink to inform the user about the progress of the
-    download. The second argument is the total size of data. In
-    certain cases it is not possible to know the total amount in
-    advance, in which case the second argument is 0. (If you connect
-    to a TQProgressBar a total of 0 results in a busy indicator.)
-
-    When the response header is read, it is reported with the
-    responseHeaderReceived() signal.
-
-    The readyRead() signal tells you that there is data ready to be
-    read. The amount of data can then be queried with the
-    bytesAvailable() function and it can be read with the readBlock()
-    or readAll() functions.
-
-    If an error occurs during the execution of one of the commands in
-    a sequence of commands, all the pending commands (i.e. scheduled,
-    but not yet executed commands) are cleared and no Q_SIGNALS are
-    emitted for them.
-
-    For example, if you have the following sequence of reqeusts
-
-    \code
-    http->setHost( "www.foo.bar" );       // id == 1
-    http->get( "/index.html" );           // id == 2
-    http->post( "register.html", data );  // id == 3
-    \endcode
-
-    and the get() request fails because the host lookup fails, then
-    the post() request is never executed and the Q_SIGNALS would look
-    like this:
-
-    \code
-    requestStarted( 1 )
-    requestFinished( 1, FALSE )
-
-    requestStarted( 2 )
-    stateChanged( HostLookup )
-    requestFinished( 2, TRUE )
-
-    done( TRUE )
-
-    stateChanged( Unconnected )
-    \endcode
-
-    You can then get details about the error with the error() and
-    errorString() functions. Note that only unexpected behaviour, like
-    network failure is considered as an error. If the server response
-    contains an error status, like a 404 response, this is reported as
-    a normal response case. So you should always check the \link
-    TQHttpResponseHeader::statusCode() status code \endlink of the
-    response header.
-
-    The functions currentId() and currentRequest() provide more
-    information about the currently executing request.
-
-    The functions hasPendingRequests() and clearPendingRequests()
-    allow you to query and clear the list of pending requests.
-
-    \sa \link network.html TQt Network Documentation \endlink TQNetworkProtocol, TQUrlOperator TQFtp
-*/
-
-/*!
-    Constructs a TQHttp object.
-*/
-TQHttp::TQHttp()
-{
-    init();
-}
-
-/*!
-    Constructs a TQHttp object. The parameters \a parent and \a name
-    are passed on to the TQObject constructor.
-*/
-TQHttp::TQHttp( TQObject* parent, const char* name )
-{
-    if ( parent )
-	parent->insertChild( this );
-    setName( name );
-    init();
-}
-
-/*!
-    Constructs a TQHttp object. Subsequent requests are done by
-    connecting to the server \a hostname on port \a port. The
-    parameters \a parent and \a name are passed on to the TQObject
-    constructor.
-
-    \sa setHost()
-*/
-TQHttp::TQHttp( const TQString &hostname, TQ_UINT16 port, TQObject* parent, const char* name )
-{
-    if ( parent )
-	parent->insertChild( this );
-    setName( name );
-    init();
-
-    d->hostname = hostname;
-    d->port = port;
-}
-
-void TQHttp::init()
-{
-    bytesRead = 0;
-    d = new TQHttpPrivate;
-    d->errorString = tr( "Unknown error" );
-
-    connect( &d->socket, TQT_SIGNAL( connected() ),
-	    this, TQT_SLOT( slotConnected() ) );
-    connect( &d->socket, TQT_SIGNAL( connectionClosed() ),
-	    this, TQT_SLOT( slotClosed() ) );
-    connect( &d->socket, TQT_SIGNAL( delayedCloseFinished() ),
-	    this, TQT_SLOT( slotClosed() ) );
-    connect( &d->socket, TQT_SIGNAL( readyRead() ),
-	    this, TQT_SLOT( slotReadyRead() ) );
-    connect( &d->socket, TQT_SIGNAL( error(int) ),
-	    this, TQT_SLOT( slotError(int) ) );
-    connect( &d->socket, TQT_SIGNAL( bytesWritten(int) ),
-	    this, TQT_SLOT( slotBytesWritten(int) ) );
-
-    d->idleTimer = startTimer( 0 );
-}
-
-/*!
-    Destroys the TQHttp object. If there is an open connection, it is
-    closed.
-*/
-TQHttp::~TQHttp()
-{
-    abort();
-    delete d;
-}
-
-/*!
-    \enum TQHttp::State
-
-    This enum is used to specify the state the client is in:
-
-    \value Unconnected There is no connection to the host.
-    \value HostLookup A host name lookup is in progress.
-    \value Connecting An attempt to connect to the host is in progress.
-    \value Sending The client is sending its request to the server.
-    \value Reading The client's request has been sent and the client
-    is reading the server's response.
-    \value Connected The connection to the host is open, but the client is
-    neither sending a request, nor waiting for a response.
-    \value Closing The connection is closing down, but is not yet
-    closed. (The state will be \c Unconnected when the connection is
-    closed.)
-
-    \sa stateChanged() state()
-*/
-
-/*!  \enum TQHttp::Error
-
-    This enum identifies the error that occurred.
-
-    \value NoError No error occurred.
-    \value HostNotFound The host name lookup failed.
-    \value ConnectionRefused The server refused the connection.
-    \value UnexpectedClose The server closed the connection unexpectedly.
-    \value InvalidResponseHeader The server sent an invalid response header.
-    \value WrongContentLength The client could not read the content correctly
-    because an error with respect to the content length occurred.
-    \value Aborted The request was aborted with abort().
-    \value UnknownError An error other than those specified above
-    occurred.
-
-    \sa error()
-*/
-
-/*!
-    \fn void TQHttp::stateChanged( int state )
-
-    This signal is emitted when the state of the TQHttp object changes.
-    The argument \a state is the new state of the connection; it is
-    one of the \l State values.
-
-    This usually happens when a request is started, but it can also
-    happen when the server closes the connection or when a call to
-    closeConnection() succeeded.
-
-    \sa get() post() head() request() closeConnection() state() State
-*/
-
-/*!
-    \fn void TQHttp::responseHeaderReceived( const TQHttpResponseHeader& resp )
-
-    This signal is emitted when the HTTP header of a server response
-    is available. The header is passed in \a resp.
-
-    \sa get() post() head() request() readyRead()
-*/
-
-/*!
-    \fn void TQHttp::readyRead( const TQHttpResponseHeader& resp )
-
-    This signal is emitted when there is new response data to read.
-
-    If you specified a tqdevice in the request where the data should be
-    written to, then this signal is \e not emitted; instead the data
-    is written directly to the tqdevice.
-
-    The response header is passed in \a resp.
-
-    You can read the data with the readAll() or readBlock() functions
-
-    This signal is useful if you want to process the data in chunks as
-    soon as it becomes available. If you are only interested in the
-    complete data, just connect to the requestFinished() signal and
-    read the data then instead.
-
-    \sa get() post() request() readAll() readBlock() bytesAvailable()
-*/
-
-/*!
-    \fn void TQHttp::dataSendProgress( int done, int total )
-
-    This signal is emitted when this object sends data to a HTTP
-    server to inform it about the progress of the upload.
-
-    \a done is the amount of data that has already arrived and \a
-    total is the total amount of data. It is possible that the total
-    amount of data that should be transferred cannot be determined, in
-    which case \a total is 0.(If you connect to a TQProgressBar, the
-    progress bar shows a busy indicator if the total is 0).
-
-    \warning \a done and \a total are not necessarily the size in
-    bytes, since for large files these values might need to be
-    "scaled" to avoid overflow.
-
-    \sa dataReadProgress() post() request() TQProgressBar::setProgress()
-*/
-
-/*!
-    \fn void TQHttp::dataReadProgress( int done, int total )
-
-    This signal is emitted when this object reads data from a HTTP
-    server to indicate the current progress of the download.
-
-    \a done is the amount of data that has already arrived and \a
-    total is the total amount of data. It is possible that the total
-    amount of data that should be transferred cannot be determined, in
-    which case \a total is 0.(If you connect to a TQProgressBar, the
-    progress bar shows a busy indicator if the total is 0).
-
-    \warning \a done and \a total are not necessarily the size in
-    bytes, since for large files these values might need to be
-    "scaled" to avoid overflow.
-
-    \sa dataSendProgress() get() post() request() TQProgressBar::setProgress()
-*/
-
-/*!
-    \fn void TQHttp::requestStarted( int id )
-
-    This signal is emitted when processing the request identified by
-    \a id starts.
-
-    \sa requestFinished() done()
-*/
-
-/*!
-    \fn void TQHttp::requestFinished( int id, bool error )
-
-    This signal is emitted when processing the request identified by
-    \a id has finished. \a error is TRUE if an error occurred during
-    the processing; otherwise \a error is FALSE.
-
-    \sa requestStarted() done() error() errorString()
-*/
-
-/*!
-    \fn void TQHttp::done( bool error )
-
-    This signal is emitted when the last pending request has finished;
-    (it is emitted after the last request's requestFinished() signal).
-    \a error is TRUE if an error occurred during the processing;
-    otherwise \a error is FALSE.
-
-    \sa requestFinished() error() errorString()
-*/
-
-/*!
-    Aborts the current request and deletes all scheduled requests.
-
-    For the current request, the requestFinished() signal with the \c
-    error argument \c TRUE is emitted. For all other requests that are
-    affected by the abort(), no Q_SIGNALS are emitted.
-
-    Since this slot also deletes the scheduled requests, there are no
-    requests left and the done() signal is emitted (with the \c error
-    argument \c TRUE).
-
-    \sa clearPendingRequests()
-*/
-void TQHttp::abort()
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( r == 0 )
-	return;
-
-    finishedWithError( tr("Request aborted"), Aborted );
-    clearPendingRequests();
-    d->socket.clearPendingData();
-    close();
-}
-
-/*!
-    Returns the number of bytes that can be read from the response
-    content at the moment.
-
-    \sa get() post() request() readyRead() readBlock() readAll()
-*/
-TQ_ULONG TQHttp::bytesAvailable() const
-{
-#if defined(TQHTTP_DEBUG)
-    qDebug( "TQHttp::bytesAvailable(): %d bytes", (int)d->rba.size() );
-#endif
-    return d->rba.size();
-}
-
-/*!
-    Reads \a maxlen bytes from the response content into \a data and
-    returns the number of bytes read. Returns -1 if an error occurred.
-
-    \sa get() post() request() readyRead() bytesAvailable() readAll()
-*/
-TQ_LONG TQHttp::readBlock( char *data, TQ_ULONG maxlen )
-{
-    if ( data == 0 && maxlen != 0 ) {
-#if defined(TQT_CHECK_NULL)
-	qWarning( "TQHttp::readBlock: Null pointer error" );
-#endif
-	return -1;
-    }
-    if ( maxlen >= d->rba.size() )
-	maxlen = d->rba.size();
-    d->rba.consumeBytes( maxlen, data );
-
-    d->bytesDone += maxlen;
-#if defined(TQHTTP_DEBUG)
-    qDebug( "TQHttp::readBlock(): read %d bytes (%d bytes done)", (int)maxlen, d->bytesDone );
-#endif
-    return maxlen;
-}
-
-/*!
-    Reads all the bytes from the response content and returns them.
-
-    \sa get() post() request() readyRead() bytesAvailable() readBlock()
-*/
-TQByteArray TQHttp::readAll()
-{
-    TQ_ULONG avail = bytesAvailable();
-    TQByteArray tmp( avail );
-    TQ_LONG read = readBlock( tmp.data(), avail );
-    tmp.resize( read );
-    return tmp;
-}
-
-/*!
-    Returns the identifier of the HTTP request being executed or 0 if
-    there is no request being executed (i.e. they've all finished).
-
-    \sa currentRequest()
-*/
-int TQHttp::currentId() const
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( r == 0 )
-	return 0;
-    return r->id;
-}
-
-/*!
-    Returns the request header of the HTTP request being executed. If
-    the request is one issued by setHost() or closeConnection(), it
-    returns an invalid request header, i.e.
-    TQHttpRequestHeader::isValid() returns FALSE.
-
-    \sa currentId()
-*/
-TQHttpRequestHeader TQHttp::currentRequest() const
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( r != 0 && r->hasRequestHeader() )
-	return r->requestHeader();
-    return TQHttpRequestHeader();
-}
-
-/*!
-    Returns the TQIODevice pointer that is used as the data source of the HTTP
-    request being executed. If there is no current request or if the request
-    does not use an IO tqdevice as the data source, this function returns 0.
-
-    This function can be used to delete the TQIODevice in the slot connected to
-    the requestFinished() signal.
-
-    \sa currentDestinationDevice() post() request()
-*/
-TQIODevice* TQHttp::currentSourceDevice() const
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( !r )
-	return 0;
-    return r->sourceDevice();
-}
-
-/*!
-    Returns the TQIODevice pointer that is used as to store the data of the HTTP
-    request being executed. If there is no current request or if the request
-    does not store the data to an IO tqdevice, this function returns 0.
-
-    This function can be used to delete the TQIODevice in the slot connected to
-    the requestFinished() signal.
-
-    \sa currentDestinationDevice() get() post() request()
-*/
-TQIODevice* TQHttp::currentDestinationDevice() const
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( !r )
-	return 0;
-    return r->destinationDevice();
-}
-
-/*!
-    Returns TRUE if there are any requests scheduled that have not yet
-    been executed; otherwise returns FALSE.
-
-    The request that is being executed is \e not considered as a
-    scheduled request.
-
-    \sa clearPendingRequests() currentId() currentRequest()
-*/
-bool TQHttp::hasPendingRequests() const
-{
-    return d->pending.count() > 1;
-}
-
-/*!
-    Deletes all pending requests from the list of scheduled requests.
-    This does not affect the request that is being executed. If
-    you want to stop this this as well, use abort().
-
-    \sa hasPendingRequests() abort()
-*/
-void TQHttp::clearPendingRequests()
-{
-    TQHttpRequest *r = 0;
-    if ( d->pending.count() > 0 )
-	r = d->pending.take( 0 );
-    d->pending.clear();
-    if ( r )
-	d->pending.append( r );
-}
-
-/*!
-    Sets the HTTP server that is used for requests to \a hostname on
-    port \a port.
-
-    The function does not block and returns immediately. The request
-    is scheduled, and its execution is performed asynchronously. The
-    function returns a unique identifier which is passed by
-    requestStarted() and requestFinished().
-
-    When the request is started the requestStarted() signal is
-    emitted. When it is finished the requestFinished() signal is
-    emitted.
-
-    \sa get() post() head() request() requestStarted() requestFinished() done()
-*/
-int TQHttp::setHost(const TQString &hostname, TQ_UINT16 port )
-{
-    return addRequest( new TQHttpSetHostRequest( hostname, port ) );
-}
-
-/*!
-    Sends a get request for \a path to the server set by setHost() or
-    as specified in the constructor.
-
-    \a path must be an absolute path like \c /index.html or an
-    absolute URI like \c http://www.trolltech.com/index.html.
-
-    If the IO tqdevice \a to is 0 the readyRead() signal is emitted
-    every time new content data is available to read.
-
-    If the IO tqdevice \a to is not 0, the content data of the response
-    is written directly to the tqdevice. Make sure that the \a to
-    pointer is valid for the duration of the operation (it is safe to
-    delete it when the requestFinished() signal is emitted).
-
-    The function does not block and returns immediately. The request
-    is scheduled, and its execution is performed asynchronously. The
-    function returns a unique identifier which is passed by
-    requestStarted() and requestFinished().
-
-    When the request is started the requestStarted() signal is
-    emitted. When it is finished the requestFinished() signal is
-    emitted.
-
-    \sa setHost() post() head() request() requestStarted() requestFinished() done()
-*/
-int TQHttp::get( const TQString& path, TQIODevice* to )
-{
-    TQHttpRequestHeader header( "GET", path );
-    header.setValue( "Connection", "Keep-Alive" );
-    return addRequest( new TQHttpPGHRequest( header, (TQIODevice*)0, to ) );
-}
-
-/*!
-    Sends a post request for \a path to the server set by setHost() or
-    as specified in the constructor.
-
-    \a path must be an absolute path like \c /index.html or an
-    absolute URI like \c http://www.trolltech.com/index.html.
-
-    The incoming data comes via the \a data IO tqdevice.
-
-    If the IO tqdevice \a to is 0 the readyRead() signal is emitted
-    every time new content data is available to read.
-
-    If the IO tqdevice \a to is not 0, the content data of the response
-    is written directly to the tqdevice. Make sure that the \a to
-    pointer is valid for the duration of the operation (it is safe to
-    delete it when the requestFinished() signal is emitted).
-
-    The function does not block and returns immediately. The request
-    is scheduled, and its execution is performed asynchronously. The
-    function returns a unique identifier which is passed by
-    requestStarted() and requestFinished().
-
-    When the request is started the requestStarted() signal is
-    emitted. When it is finished the requestFinished() signal is
-    emitted.
-
-    \sa setHost() get() head() request() requestStarted() requestFinished() done()
-*/
-int TQHttp::post( const TQString& path, TQIODevice* data, TQIODevice* to  )
-{
-    TQHttpRequestHeader header( "POST", path );
-    header.setValue( "Connection", "Keep-Alive" );
-    return addRequest( new TQHttpPGHRequest( header, data, to ) );
-}
-
-/*!
-    \overload
-
-    \a data is used as the content data of the HTTP request.
-*/
-int TQHttp::post( const TQString& path, const TQByteArray& data, TQIODevice* to )
-{
-    TQHttpRequestHeader header( "POST", path );
-    header.setValue( "Connection", "Keep-Alive" );
-    return addRequest( new TQHttpPGHRequest( header, new TQByteArray(data), to ) );
-}
-
-/*!
-    Sends a header request for \a path to the server set by setHost()
-    or as specified in the constructor.
-
-    \a path must be an absolute path like \c /index.html or an
-    absolute URI like \c http://www.trolltech.com/index.html.
-
-    The function does not block and returns immediately. The request
-    is scheduled, and its execution is performed asynchronously. The
-    function returns a unique identifier which is passed by
-    requestStarted() and requestFinished().
-
-    When the request is started the requestStarted() signal is
-    emitted. When it is finished the requestFinished() signal is
-    emitted.
-
-    \sa setHost() get() post() request() requestStarted() requestFinished() done()
-*/
-int TQHttp::head( const TQString& path )
-{
-    TQHttpRequestHeader header( "HEAD", path );
-    header.setValue( "Connection", "Keep-Alive" );
-    return addRequest( new TQHttpPGHRequest( header, (TQIODevice*)0, 0 ) );
-}
-
-/*!
-    Sends a request to the server set by setHost() or as specified in
-    the constructor. Uses the \a header as the HTTP request header.
-    You are responsible for setting up a header that is appropriate
-    for your request.
-
-    The incoming data comes via the \a data IO tqdevice.
-
-    If the IO tqdevice \a to is 0 the readyRead() signal is emitted
-    every time new content data is available to read.
-
-    If the IO tqdevice \a to is not 0, the content data of the response
-    is written directly to the tqdevice. Make sure that the \a to
-    pointer is valid for the duration of the operation (it is safe to
-    delete it when the requestFinished() signal is emitted).
-
-    The function does not block and returns immediately. The request
-    is scheduled, and its execution is performed asynchronously. The
-    function returns a unique identifier which is passed by
-    requestStarted() and requestFinished().
-
-    When the request is started the requestStarted() signal is
-    emitted. When it is finished the requestFinished() signal is
-    emitted.
-
-    \sa setHost() get() post() head() requestStarted() requestFinished() done()
-*/
-int TQHttp::request( const TQHttpRequestHeader &header, TQIODevice *data, TQIODevice *to )
-{
-    return addRequest( new TQHttpNormalRequest( header, data, to ) );
-}
-
-/*!
-    \overload
-
-    \a data is used as the content data of the HTTP request.
-*/
-int TQHttp::request( const TQHttpRequestHeader &header, const TQByteArray &data, TQIODevice *to  )
-{
-    return addRequest( new TQHttpNormalRequest( header, new TQByteArray(data), to ) );
-}
-
-/*!
-    Closes the connection; this is useful if you have a keep-alive
-    connection and want to close it.
-
-    For the requests issued with get(), post() and head(), TQHttp sets
-    the connection to be keep-alive. You can also do this using the
-    header you pass to the request() function. TQHttp only closes the
-    connection to the HTTP server if the response header requires it
-    to do so.
-
-    The function does not block and returns immediately. The request
-    is scheduled, and its execution is performed asynchronously. The
-    function returns a unique identifier which is passed by
-    requestStarted() and requestFinished().
-
-    When the request is started the requestStarted() signal is
-    emitted. When it is finished the requestFinished() signal is
-    emitted.
-
-    If you want to close the connection immediately, you have to use
-    abort() instead.
-
-    \sa stateChanged() abort() requestStarted() requestFinished() done()
-*/
-int TQHttp::closeConnection()
-{
-    return addRequest( new TQHttpCloseRequest() );
-}
-
-int TQHttp::addRequest( TQHttpRequest *req )
-{
-    d->pending.append( req );
-
-    if ( d->pending.count() == 1 )
-	// don't emit the requestStarted() signal before the id is returned
-	TQTimer::singleShot( 0, this, TQT_SLOT(startNextRequest()) );
-
-    return req->id;
-}
-
-void TQHttp::startNextRequest()
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( r == 0 )
-	return;
-
-    d->error = NoError;
-    d->errorString = tr( "Unknown error" );
-
-    if ( bytesAvailable() )
-	readAll(); // clear the data
-    emit requestStarted( r->id );
-    r->start( this );
-}
-
-void TQHttp::sendRequest()
-{
-    if ( d->hostname.isNull() ) {
-	finishedWithError( tr("No server set to connect to"), UnknownError );
-	return;
-    }
-
-    killIdleTimer();
-
-    // Do we need to setup a new connection or can we reuse an
-    // existing one ?
-    if ( d->socket.peerName() != d->hostname || d->socket.peerPort() != d->port
-        || d->socket.state() != TQSocket::Connection ) {
-	setState( TQHttp::Connecting );
-	d->socket.connectToHost( d->hostname, d->port );
-    } else {
-        slotConnected();
-    }
-
-}
-
-void TQHttp::finishedWithSuccess()
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( r == 0 )
-	return;
-
-    emit requestFinished( r->id, FALSE );
-    d->pending.removeFirst();
-    if ( d->pending.isEmpty() ) {
-	emit done( FALSE );
-    } else {
-	startNextRequest();
-    }
-}
-
-void TQHttp::finishedWithError( const TQString& detail, int errorCode )
-{
-    TQHttpRequest *r = d->pending.getFirst();
-    if ( r == 0 )
-	return;
-
-    d->error = (Error)errorCode;
-    d->errorString = detail;
-    emit requestFinished( r->id, TRUE );
-
-    d->pending.clear();
-    emit done( TRUE );
-}
-
-void TQHttp::slotClosed()
-{
-    if ( d->state == Closing )
-	return;
-
-    if ( d->state == Reading ) {
-	if ( d->response.hasKey( "content-length" ) ) {
-	    // We got Content-Length, so did we get all bytes?
-	    if ( d->bytesDone+bytesAvailable() != d->response.contentLength() ) {
-		finishedWithError( tr("Wrong content length"), WrongContentLength );
-	    }
-	}
-    } else if ( d->state == Connecting || d->state == Sending ) {
-	finishedWithError( tr("Server closed connection unexpectedly"), UnexpectedClose );
-    }
-
-    d->postDevice = 0;
-    setState( Closing );
-    d->idleTimer = startTimer( 0 );
-}
-
-void TQHttp::slotConnected()
-{
-    if ( d->state != Sending ) {
-	d->bytesDone = 0;
-	setState( Sending );
-    }
-
-    TQString str = d->header.toString();
-    d->bytesTotal = str.length();
-    d->socket.writeBlock( str.latin1(), d->bytesTotal );
-#if defined(TQHTTP_DEBUG)
-    qDebug( "TQHttp: write request header:\n---{\n%s}---", str.latin1() );
-#endif
-
-    if ( d->postDevice ) {
-	d->bytesTotal += d->postDevice->size();
-    } else {
-	d->bytesTotal += d->buffer.size();
-	d->socket.writeBlock( d->buffer.data(), d->buffer.size() );
-	d->buffer = TQByteArray(); // save memory
-    }
-}
-
-void TQHttp::slotError( int err )
-{
-    d->postDevice = 0;
-
-    if ( d->state == Connecting || d->state == Reading || d->state == Sending ) {
-	switch ( err ) {
-	    case TQSocket::ErrConnectionRefused:
-		finishedWithError( tr("Connection refused"), ConnectionRefused );
-		break;
-	    case TQSocket::ErrHostNotFound:
-		finishedWithError( tr("Host %1 not found").arg(d->socket.peerName()), HostNotFound );
-		break;
-	    default:
-		finishedWithError( tr("HTTP request failed"), UnknownError );
-		break;
-	}
-    }
-
-    close();
-}
-
-void TQHttp::slotBytesWritten( int written )
-{
-    d->bytesDone += written;
-    emit dataSendProgress( d->bytesDone, d->bytesTotal );
-
-    if ( !d->postDevice )
-	return;
-
-    if ( d->socket.bytesToWrite() == 0 ) {
-	int max = TQMIN( 4096, d->postDevice->size() - d->postDevice->at() );
-	TQByteArray arr( max );
-
-	int n = d->postDevice->readBlock( arr.data(), max );
-	if ( n != max ) {
-	    qWarning("Could not read enough bytes from the tqdevice");
-	    close();
-	    return;
-	}
-	if ( d->postDevice->atEnd() ) {
-	    d->postDevice = 0;
-	}
-
-	d->socket.writeBlock( arr.data(), max );
-    }
-}
-
-void TQHttp::slotReadyRead()
-{
-    if ( d->state != Reading ) {
-	setState( Reading );
-	d->buffer = TQByteArray();
-	d->readHeader = TRUE;
-	d->headerStr = "";
-	d->bytesDone = 0;
-	d->chunkedSize = -1;
-    }
-
-    while ( d->readHeader ) {
-	bool end = FALSE;
-	TQString tmp;
-	while ( !end && d->socket.canReadLine() ) {
-	    tmp = d->socket.readLine();
-	    if ( tmp == "\r\n" || tmp == "\n" )
-		end = TRUE;
-	    else
-		d->headerStr += tmp;
-	}
-
-	if ( !end )
-	    return;
-
-#if defined(TQHTTP_DEBUG)
-	qDebug( "TQHttp: read response header:\n---{\n%s}---", d->headerStr.latin1() );
-#endif
-	d->response = TQHttpResponseHeader( d->headerStr );
-	d->headerStr = "";
-#if defined(TQHTTP_DEBUG)
-	qDebug( "TQHttp: read response header:\n---{\n%s}---", d->response.toString().latin1() );
-#endif
-	// Check header
-	if ( !d->response.isValid() ) {
-	    finishedWithError( tr("Invalid HTTP response header"), InvalidResponseHeader );
-	    close();
-	    return;
-	}
-
-	// The 100-continue header is ignored, because when using the
-	// POST method, we send both the request header and data in
-	// one chunk.
-	if (d->response.statusCode() != 100) {
-	    d->readHeader = FALSE;
-	    if ( d->response.hasKey( "transfer-encoding" ) &&
-		 d->response.value( "transfer-encoding" ).lower().contains( "chunked" ) )
-		d->chunkedSize = 0;
-
-	    emit responseHeaderReceived( d->response );
-	}
-    }
-
-    if ( !d->readHeader ) {
-	bool everythingRead = FALSE;
-
-	if ( currentRequest().method() == "HEAD" ) {
-	    everythingRead = TRUE;
-	} else {
-	    TQ_ULONG n = d->socket.bytesAvailable();
-	    TQByteArray *arr = 0;
-	    if ( d->chunkedSize != -1 ) {
-		// transfer-encoding is chunked
-		for ( ;; ) {
-		    // get chunk size
-		    if ( d->chunkedSize == 0 ) {
-			if ( !d->socket.canReadLine() )
-			    break;
-			TQString sizeString = d->socket.readLine();
-			int tPos = sizeString.find( ';' );
-			if ( tPos != -1 )
-			    sizeString.truncate( tPos );
-			bool ok;
-			d->chunkedSize = sizeString.toInt( &ok, 16 );
-			if ( !ok ) {
-			    finishedWithError( tr("Invalid HTTP chunked body"), WrongContentLength );
-			    close();
-                            delete arr;
-			    return;
-			}
-			if ( d->chunkedSize == 0 ) // last-chunk
-			    d->chunkedSize = -2;
-		    }
-
-		    // read trailer
-		    while ( d->chunkedSize == -2 && d->socket.canReadLine() ) {
-			TQString read = d->socket.readLine();
-			if ( read == "\r\n" || read == "\n" )
-			    d->chunkedSize = -1;
-		    }
-		    if ( d->chunkedSize == -1 ) {
-			everythingRead = TRUE;
-			break;
-		    }
-
-		    // make sure that you can read the terminating CRLF,
-		    // otherwise wait until next time...
-		    n = d->socket.bytesAvailable();
-		    if ( n == 0 )
-			break;
-		    if ( (TQ_LONG)n == d->chunkedSize || (TQ_LONG)n == d->chunkedSize+1 ) {
-			n = d->chunkedSize - 1;
-			if ( n == 0 )
-			    break;
-		    }
-
-		    // read data
-		    uint toRead = TQMIN( (TQ_LONG)n, (d->chunkedSize < 0 ? (TQ_LONG)n : d->chunkedSize) );
-		    if ( !arr )
-			arr = new TQByteArray( 0 );
-		    uint oldArrSize = arr->size();
-		    arr->resize( oldArrSize + toRead );
-		    TQ_LONG read = d->socket.readBlock( arr->data()+oldArrSize, toRead );
-		    arr->resize( oldArrSize + read );
-
-		    d->chunkedSize -= read;
-
-		    if ( d->chunkedSize == 0 && n - read >= 2 ) {
-			// read terminating CRLF
-			char tmp[2];
-			d->socket.readBlock( tmp, 2 );
-			if ( tmp[0] != '\r' || tmp[1] != '\n' ) {
-			    finishedWithError( tr("Invalid HTTP chunked body"), WrongContentLength );
-			    close();
-			    return;
-			}
-		    }
-		}
-	    } else if ( d->response.hasContentLength() ) {
-		n = TQMIN( d->response.contentLength() - d->bytesDone, n );
-		if ( n > 0 ) {
-		    arr = new TQByteArray( n );
-		    TQ_LONG read = d->socket.readBlock( arr->data(), n );
-		    arr->resize( read );
-		}
-		if ( d->bytesDone + bytesAvailable() + n == d->response.contentLength() )
-		    everythingRead = TRUE;
-	    } else if ( n > 0 ) {
-		// workaround for VC++ bug
-		TQByteArray temp = TQT_TQBYTEARRAY_OBJECT(d->socket.readAll());
-		arr = new TQByteArray( temp );
-	    }
-
-	    if ( arr ) {
-		n = arr->size();
-		if ( d->toDevice ) {
-		    d->toDevice->writeBlock( arr->data(), n );
-		    delete arr;
-		    d->bytesDone += n;
-#if defined(TQHTTP_DEBUG)
-		    qDebug( "TQHttp::slotReadyRead(): read %ld bytes (%d bytes done)", n, d->bytesDone );
-#endif
-		    if ( d->response.hasContentLength() )
-			emit dataReadProgress( d->bytesDone, d->response.contentLength() );
-		    else
-			emit dataReadProgress( d->bytesDone, 0 );
-		} else {
-		    d->rba.append( arr );
-#if defined(TQHTTP_DEBUG)
-		    qDebug( "TQHttp::slotReadyRead(): read %ld bytes (%ld bytes done)", n, d->bytesDone + bytesAvailable() );
-#endif
-		    if ( d->response.hasContentLength() )
-			emit dataReadProgress( d->bytesDone + bytesAvailable(), d->response.contentLength() );
-		    else
-			emit dataReadProgress( d->bytesDone + bytesAvailable(), 0 );
-		    emit readyRead( d->response );
-		}
-	    }
-	}
-
-	if ( everythingRead ) {
-	    // Handle "Connection: close"
-	    if ( d->response.value("connection").lower() == "close" ) {
-		close();
-	    } else {
-		setState( Connected );
-		// Start a timer, so that we emit the keep alive signal
-		// "after" this method returned.
-		d->idleTimer = startTimer( 0 );
-	    }
-	}
-    }
-}
-
-/*!
-    Returns the current state of the object. When the state changes,
-    the stateChanged() signal is emitted.
-
-    \sa State stateChanged()
-*/
-TQHttp::State TQHttp::state() const
-{
-    return d->state;
-}
-
-/*!
-    Returns the last error that occurred. This is useful to find out
-    what happened when receiving a requestFinished() or a done()
-    signal with the \c error argument \c TRUE.
-
-    If you start a new request, the error status is reset to \c NoError.
-*/
-TQHttp::Error TQHttp::error() const
-{
-    return d->error;
-}
-
-/*!
-    Returns a human-readable description of the last error that
-    occurred. This is useful to present a error message to the user
-    when receiving a requestFinished() or a done() signal with the \c
-    error argument \c TRUE.
-*/
-TQString TQHttp::errorString() const
-{
-    return d->errorString;
-}
-
-/*! \reimp
-*/
-void TQHttp::timerEvent( TQTimerEvent *e )
-{
-    if ( e->timerId() == d->idleTimer ) {
-	killTimer( d->idleTimer );
-	d->idleTimer = 0;
-
-	if ( d->state == Connected ) {
-	    finishedWithSuccess();
-	} else if ( d->state != Unconnected ) {
-	    setState( Unconnected );
-	    finishedWithSuccess();
-	}
-    } else {
-	TQObject::timerEvent( e );
-    }
-}
-
-void TQHttp::killIdleTimer()
-{
-    killTimer( d->idleTimer );
-    d->idleTimer = 0;
-}
-
-void TQHttp::setState( int s )
-{
-#if defined(TQHTTP_DEBUG)
-    qDebug( "TQHttp state changed %d -> %d", d->state, s );
-#endif
-    d->state = (State)s;
-    emit stateChanged( s );
-}
-
-void TQHttp::close()
-{
-    // If no connection is open -> ignore
-    if ( d->state == Closing || d->state == Unconnected )
-	return;
-
-    d->postDevice = 0;
-    setState( Closing );
-
-    // Already closed ?
-    if ( !d->socket.isOpen() ) {
-	d->idleTimer = startTimer( 0 );
-    } else {
-	// Close now.
-	d->socket.close();
-
-	// Did close succeed immediately ?
-	if ( d->socket.state() == TQSocket::Idle ) {
-	    // Prepare to emit the requestFinished() signal.
-	    d->idleTimer = startTimer( 0 );
-	}
-    }
-}
-
-/**********************************************************************
- *
- * TQHttp implementation of the TQNetworkProtocol interface
- *
- *********************************************************************/
-/*! \reimp
-*/
-int TQHttp::supportedOperations() const
-{
-    return OpGet | OpPut;
-}
-
-/*! \reimp
-*/
-void TQHttp::operationGet( TQNetworkOperation *op )
-{
-    connect( this, TQT_SIGNAL(readyRead(const TQHttpResponseHeader&)),
-	    this, TQT_SLOT(clientReply(const TQHttpResponseHeader&)) );
-    connect( this, TQT_SIGNAL(done(bool)),
-	    this, TQT_SLOT(clientDone(bool)) );
-    connect( this, TQT_SIGNAL(stateChanged(int)),
-	    this, TQT_SLOT(clientStateChanged(int)) );
-
-    bytesRead = 0;
-    op->setState( StInProgress );
-    TQUrl u( operationInProgress()->arg( 0 ) );
-    TQHttpRequestHeader header( "GET", u.encodedPathAndQuery(), 1, 0 );
-    header.setValue( "Host", u.host() );
-    setHost( u.host(), u.port() != -1 ? u.port() : 80 );
-    request( header );
-}
-
-/*! \reimp
-*/
-void TQHttp::operationPut( TQNetworkOperation *op )
-{
-    connect( this, TQT_SIGNAL(readyRead(const TQHttpResponseHeader&)),
-	    this, TQT_SLOT(clientReply(const TQHttpResponseHeader&)) );
-    connect( this, TQT_SIGNAL(done(bool)),
-	    this, TQT_SLOT(clientDone(bool)) );
-    connect( this, TQT_SIGNAL(stateChanged(int)),
-	    this, TQT_SLOT(clientStateChanged(int)) );
-
-    bytesRead = 0;
-    op->setState( StInProgress );
-    TQUrl u( operationInProgress()->arg( 0 ) );
-    TQHttpRequestHeader header( "POST", u.encodedPathAndQuery(), 1, 0 );
-    header.setValue( "Host", u.host() );
-    setHost( u.host(), u.port() != -1 ? u.port() : 80 );
-    request( header, op->rawArg(1) );
-}
-
-void TQHttp::clientReply( const TQHttpResponseHeader &rep )
-{
-    TQNetworkOperation *op = operationInProgress();
-    if ( op ) {
-	if ( rep.statusCode() >= 400 && rep.statusCode() < 600 ) {
-	    op->setState( StFailed );
-	    op->setProtocolDetail(
-		    TQString("%1 %2").arg(rep.statusCode()).arg(rep.reasonPhrase())
-						    );
-	    switch ( rep.statusCode() ) {
-		case 401:
-		case 403:
-		case 405:
-		    op->setErrorCode( ErrPermissionDenied );
-		    break;
-		case 404:
-		    op->setErrorCode(ErrFileNotExisting );
-		    break;
-		default:
-		    if ( op->operation() == OpGet )
-			op->setErrorCode( ErrGet );
-		    else
-			op->setErrorCode( ErrPut );
-		    break;
-	    }
-	}
-	// ### In cases of an error, should we still emit the data() Q_SIGNALS?
-	if ( op->operation() == OpGet && bytesAvailable() > 0 ) {
-	    TQByteArray ba = readAll();
-	    emit data( ba, op );
-	    bytesRead += ba.size();
-	    if ( rep.hasContentLength() ) {
-		emit dataTransferProgress( bytesRead, rep.contentLength(), op );
-	    }
-	}
-    }
-}
-
-void TQHttp::clientDone( bool err )
-{
-    disconnect( this, TQT_SIGNAL(readyRead(const TQHttpResponseHeader&)),
-	    this, TQT_SLOT(clientReply(const TQHttpResponseHeader&)) );
-    disconnect( this, TQT_SIGNAL(done(bool)),
-	    this, TQT_SLOT(clientDone(bool)) );
-    disconnect( this, TQT_SIGNAL(stateChanged(int)),
-	    this, TQT_SLOT(clientStateChanged(int)) );
-
-    if ( err ) {
-	TQNetworkOperation *op = operationInProgress();
-	if ( op ) {
-	    op->setState( TQNetworkProtocol::StFailed );
-	    op->setProtocolDetail( errorString() );
-	    switch ( error() ) {
-		case ConnectionRefused:
-		    op->setErrorCode( ErrHostNotFound );
-		    break;
-		case HostNotFound:
-		    op->setErrorCode( ErrHostNotFound );
-		    break;
-		default:
-		    if ( op->operation() == OpGet )
-			op->setErrorCode( ErrGet );
-		    else
-			op->setErrorCode( ErrPut );
-		    break;
-	    }
-	    emit finished( op );
-	}
-    } else {
-	TQNetworkOperation *op = operationInProgress();
-	if ( op ) {
-	    if ( op->state() != StFailed ) {
-		op->setState( TQNetworkProtocol::StDone );
-		op->setErrorCode( TQNetworkProtocol::NoError );
-	    }
-	    emit finished( op );
-	}
-    }
-
-}
-
-void TQHttp::clientStateChanged( int state )
-{
-    if ( url() ) {
-	switch ( (State)state ) {
-	    case Connecting:
-		emit connectionStateChanged( ConHostFound, tr( "Host %1 found" ).arg( url()->host() ) );
-		break;
-	    case Sending:
-		emit connectionStateChanged( ConConnected, tr( "Connected to host %1" ).arg( url()->host() ) );
-		break;
-	    case Unconnected:
-		emit connectionStateChanged( ConClosed, tr( "Connection to %1 closed" ).arg( url()->host() ) );
-		break;
-	    default:
-		break;
-	}
-    } else {
-	switch ( (State)state ) {
-	    case Connecting:
-		emit connectionStateChanged( ConHostFound, tr( "Host found" ) );
-		break;
-	    case Sending:
-		emit connectionStateChanged( ConConnected, tr( "Connected to host" ) );
-		break;
-	    case Unconnected:
-		emit connectionStateChanged( ConClosed, tr( "Connection closed" ) );
-		break;
-	    default:
-		break;
-	}
-    }
-}
-
-#endif