//
//     Copyright 2006 Jim Bublitz <jbublitz@nwinternet.com>
//     Earlier copyrights 1998 - 2005 Jim Bublitz and/or Phil Thompson
//     may also apply


//                 Generated by preSip
//            module kio  version KDE 3.5.3


// This software is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this library; see the file COPYING.
// If not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

namespace KIO
{

class Job : TQObject
{
%TypeHeaderCode
#include <jobclasses.h>
%End


protected:
                         Job (bool);

public:
    virtual void         kill (bool = 1);
    int                  error ();
    int                  progressId ();
    const TQString&       errorText ();
    TQString              errorString ();
    TQStringList          detailedErrorStrings (const KURL* = 0, int = -1) const;
    void                 showErrorDialog (TQWidget* = 0);
    void                 setAutoErrorHandlingEnabled (bool, TQWidget* = 0);
    bool                 isAutoErrorHandlingEnabled () const;

%If ( KDE_3_5_0 -  )
    void                 setAutoWarningHandlingEnabled (bool);
    bool                 isAutoWarningHandlingEnabled () const;
%End


%If ( KDE_3_4_3 -  )
    void                 setInteractive (bool);
    bool                 isInteractive () const;
%End

    void                 setWindow (TQWidget*);
    TQWidget*             window () const;

%If ( KDE_3_1_0 -  )
    void                 setParentJob (KIO::Job*);
    KIO::Job*            parentJob () const;
%End

    void                 setMetaData (const KIO::MetaData&);
    void                 addMetaData (const TQString&, const TQString&);
    void                 addMetaData (const TQMap<TQString,TQString>&);
    void                 mergeMetaData (const TQMap<TQString,TQString>&);
    KIO::MetaData        outgoingMetaData () const;
    KIO::MetaData        metaData () const;
    TQString              queryMetaData (const TQString&);

%If ( KDE_3_2_0 -  )
    KIO::filesize_t      getProcessedSize ();
%End


signals:
    void                 result (KIO::Job*);
    void                 canceled (KIO::Job*);
    void                 infoMessage (KIO::Job*, const TQString&);

%If ( KDE_3_5_0 -  )
    void                 warning (KIO::Job*, const TQString&);
%End

    void                 connected (KIO::Job*);
    void                 percent (KIO::Job*, ulong);
    void                 totalSize (KIO::Job*, KIO::filesize_t);
    void                 processedSize (KIO::Job*, KIO::filesize_t);
    void                 speed (KIO::Job*, ulong);

protected slots:
    virtual void         slotResult (KIO::Job*);
    void                 slotSpeed (KIO::Job*, ulong);
    void                 slotInfoMessage (KIO::Job*, const TQString&);
    void                 slotSpeedTimeout ();

protected:
    virtual void         addSubjob (KIO::Job*, bool = 1);
    virtual void         removeSubjob (KIO::Job*);

%If ( KDE_3_4_0 -  )
    void                 removeSubjob (KIO::Job*, bool, bool);
%End

    void                 emitPercent (KIO::filesize_t, KIO::filesize_t);
    void                 emitSpeed (ulong);
    void                 emitResult ();

%If ( KDE_3_2_0 -  )
    void                 setProcessedSize (KIO::filesize_t);
%End

//ig     int&                 extraFlags ();

protected:
//igx     virtual void         virtual_hook (int, void*);

protected:

%If ( KDE_3_2_0 - KDE_3_2_2 )
    int                  extraFlags ();
%MethodCode
//returns (int)
    Py_BEGIN_ALLOW_THREADS
    sipRes = sipCpp -> sipProtect_extraFlags ();
    Py_END_ALLOW_THREADS
%End

%End


};  // class Job


class SimpleJob : KIO::Job
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         SimpleJob (const KURL&, int, const TQByteArray&, bool);
    const KURL&          url () const;
    virtual void         kill (bool = 1);
    virtual void         putOnHold ();
    static void          removeOnHold ();
    virtual void         start (KIO::Slave*);
    void                 slaveDone ();
    KIO::Slave*          slave ();
    int                  command ();

public slots:

%If ( KDE_3_1_0 -  )
    void                 slotTotalSize (KIO::filesize_t);
%End


protected slots:
    virtual void         slotFinished ();
    void                 slotWarning (const TQString&);
    void                 slotInfoMessage (const TQString&);
    void                 slotConnected ();
    void                 slotProcessedSize (KIO::filesize_t);
    void                 slotSpeed (ulong);
    virtual void         slotMetaData (const KIO::MetaData&);

public slots:
    virtual void         slotError (int, const TQString&);

protected slots:
    void                 slotNeedProgressId ();

protected:

protected:
//igx     virtual void         virtual_hook (int, void*);

%If ( KDE_3_2_0 -  )
    void                 storeSSLSessionFromJob (const KURL&);
%End


protected slots:

%If (  - KDE_3_1_0 )
    void                 slotTotalSize (KIO::filesize_t);
%End


};  // class SimpleJob


class StatJob : KIO::SimpleJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         StatJob (const KURL&, int, const TQByteArray&, bool);
    void                 setSide (bool);
    void                 setDetails (short);
    const KIO::UDSEntry& statResult () const;
    virtual void         start (KIO::Slave*);

signals:
    void                 redirection (KIO::Job*, const KURL&);

%If ( KDE_3_1_0 -  )
    void                 permanentRedirection (KIO::Job*, const KURL&, const KURL&);
%End


protected slots:
    void                 slotStatEntry (const KIO::UDSEntry&);
    void                 slotRedirection (const KURL&);
    virtual void         slotFinished ();

%If ( KDE_3_2_0 -  )
    virtual void         slotMetaData (const KIO::MetaData&);
%End


protected:

protected:
//igx     virtual void         virtual_hook (int, void*);

};  // class StatJob


%If ( KDE_3_3_0 -  )

class MkdirJob : KIO::SimpleJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         MkdirJob (const KURL&, int, const TQByteArray&, bool);
    virtual void         start (KIO::Slave*);

signals:
    void                 redirection (KIO::Job*, const KURL&);
    void                 permanentRedirection (KIO::Job*, const KURL&, const KURL&);

protected slots:
    void                 slotRedirection (const KURL&);
    virtual void         slotFinished ();

protected:

protected:
    virtual void         virtual_hook (int, void*);

};  // class MkdirJob

%End


%If ( KDE_3_3_0 -  )

class DirectCopyJob : KIO::SimpleJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         DirectCopyJob (const KURL&, int, const TQByteArray&, bool);
    virtual void         start (KIO::Slave*);

signals:
    void                 canResume (KIO::Job*, KIO::filesize_t);

};  // class DirectCopyJob

%End


class TransferJob : KIO::SimpleJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         TransferJob (const KURL&, int, const TQByteArray&, const TQByteArray&, bool);
    virtual void         start (KIO::Slave*);
    virtual void         slotResult (KIO::Job*);
    void                 suspend ();
    void                 resume ();
    bool                 isSuspended () const;
    bool                 isErrorPage () const;

%If ( KDE_3_2_0 -  )
    void                 setAsyncDataEnabled (bool);
    void                 sendAsyncData (const TQByteArray&);
    void                 setReportDataSent (bool);
    bool                 reportDataSent ();
%End


signals:
    void                 data (KIO::Job*, const TQByteArray&);
    void                 dataReq (KIO::Job*, TQByteArray&);
    void                 redirection (KIO::Job*, const KURL&);

%If ( KDE_3_1_0 -  )
    void                 permanentRedirection (KIO::Job*, const KURL&, const KURL&);
%End

    void                 mimetype (KIO::Job*, const TQString&);
    void                 canResume (KIO::Job*, KIO::filesize_t);

protected slots:
    virtual void         slotRedirection (const KURL&);
    virtual void         slotFinished ();
    virtual void         slotData (const TQByteArray&);
    virtual void         slotDataReq ();
    virtual void         slotMimetype (const TQString&);
    virtual void         slotNeedSubURLData ();
    virtual void         slotSubURLData (KIO::Job*, const TQByteArray&);

%If ( KDE_3_2_0 -  )
    virtual void         slotMetaData (const KIO::MetaData&);
%End

    void                 slotErrorPage ();
    void                 slotCanResume (KIO::filesize_t);

%If ( KDE_3_2_0 -  )
    void                 slotPostRedirection ();
%End


protected:

protected:
//igx     virtual void         virtual_hook (int, void*);

};  // class TransferJob


%If ( KDE_3_3_0 -  )

class StoredTransferJob : KIO::TransferJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         StoredTransferJob (const KURL&, int, const TQByteArray&, const TQByteArray&, bool);
    void                 setData (const TQByteArray&);
    TQByteArray           data () const;

};  // class StoredTransferJob

%End


class MultiGetJob : KIO::TransferJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         MultiGetJob (const KURL&, bool);
    virtual void         start (KIO::Slave*);
    void                 get (long, const KURL&, const KIO::MetaData&);

signals:
    void                 data (long, const TQByteArray&);
    void                 mimetype (long, const TQString&);
    void                 result (long);

protected slots:
    virtual void         slotRedirection (const KURL&);
    virtual void         slotFinished ();
    virtual void         slotData (const TQByteArray&);
    virtual void         slotMimetype (const TQString&);

protected:
//igx     virtual void         virtual_hook (int, void*);

};  // class MultiGetJob


class MimetypeJob : KIO::TransferJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         MimetypeJob (const KURL&, int, const TQByteArray&, bool);
    TQString              mimetype () const;
    virtual void         start (KIO::Slave*);

protected slots:
    virtual void         slotFinished ();

protected:
//igx     virtual void         virtual_hook (int, void*);

};  // class MimetypeJob


class FileCopyJob : KIO::Job
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         FileCopyJob (const KURL&, const KURL&, int, bool, bool, bool, bool);

%If ( KDE_3_2_0 -  )
    void                 setSourceSize64 (KIO::filesize_t);

%If ( KDE_3_5_2 -  )
    void                 setModificationTime (time_t);
%End

%End

//ig     void                 setSourceSize (off_t);
    KURL                 srcURL () const;
    KURL                 destURL () const;

public slots:
    void                 slotStart ();
    void                 slotData (KIO::Job*, const TQByteArray&);
    void                 slotDataReq (KIO::Job*, TQByteArray&);

protected slots:
    virtual void         slotResult (KIO::Job*);
    void                 slotProcessedSize (KIO::Job*, KIO::filesize_t);
    void                 slotTotalSize (KIO::Job*, KIO::filesize_t);
    void                 slotPercent (KIO::Job*, ulong);
    void                 slotCanResume (KIO::Job*, KIO::filesize_t);

protected:
    void                 startCopyJob ();
    void                 startCopyJob (const KURL&);

%If ( KDE_3_4_0 -  )
    void                 startRenameJob (const KURL&);
%End

    void                 startDataPump ();
    void                 connectSubjob (KIO::SimpleJob*);

protected:

protected:
//igx     virtual void         virtual_hook (int, void*);

};  // class FileCopyJob


class ListJob : KIO::SimpleJob
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         ListJob (const KURL&, bool, bool = 0, TQString = TQString ::null , bool = 1);
    virtual void         start (KIO::Slave*);

%If ( KDE_3_4_3 -  )
    const KURL&          redirectionURL () const;
%End


%If ( KDE_3_2_0 -  )
    void                 setUnrestricted (bool);
%End


signals:
    void                 entries (KIO::Job*, const KIO::UDSEntryList&);
    void                 redirection (KIO::Job*, const KURL&);

%If ( KDE_3_1_0 -  )
    void                 permanentRedirection (KIO::Job*, const KURL&, const KURL&);
%End


protected slots:
    virtual void         slotFinished ();

%If ( KDE_3_2_0 -  )
    virtual void         slotMetaData (const KIO::MetaData&);
%End

    virtual void         slotResult (KIO::Job*);
    void                 slotListEntries (const KIO::UDSEntryList&);
    void                 slotRedirection (const KURL&);
    void                 gotEntries (KIO::Job*, const KIO::UDSEntryList&);

protected:
//igx     virtual void         virtual_hook (int, void*);

};  // class ListJob


class CopyInfo
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
    KURL                 uSource;
    KURL                 uDest;
    TQString              linkDest;
    mode_t               permissions;
    time_t               ctime;
    time_t               mtime;
    off_t                size;

};  // class CopyInfo


class CopyJob : KIO::Job
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:

    enum CopyMode
    {
        Copy, 
        Move, 
        Link
    };

                         CopyJob (const KURL::List&, const KURL&, KIO::CopyJob::CopyMode, bool, bool);
    KURL::List           srcURLs () const;
    KURL                 destURL () const;

%If ( KDE_3_2_3 -  )
    void                 setDefaultPermissions (bool);

%If ( KDE_3_4_0 -  )
    void                 setInteractive (bool);
%End

%End


signals:
    void                 totalFiles (KIO::Job*, ulong);
    void                 totalDirs (KIO::Job*, ulong);

%If ( KDE_3_2_0 -  )
    void                 aboutToCreate (KIO::Job*, const TQValueList<KIO::CopyInfo>&);
%End

    void                 processedFiles (KIO::Job*, ulong);
    void                 processedDirs (KIO::Job*, ulong);
    void                 copying (KIO::Job*, const KURL&, const KURL&);
    void                 linking (KIO::Job*, const TQString&, const KURL&);
    void                 moving (KIO::Job*, const KURL&, const KURL&);
    void                 creatingDir (KIO::Job*, const KURL&);
    void                 renamed (KIO::Job*, const KURL&, const KURL&);
    void                 copyingDone (KIO::Job*, const KURL&, const KURL&, bool, bool);
    void                 copyingLinkDone (KIO::Job*, const KURL&, const TQString&, const KURL&);

protected:

%If ( KDE_3_2_3 -  )
    void                 statCurrentSrc ();
%End

    void                 statNextSrc ();
    void                 slotResultStating (KIO::Job*);
    void                 startListing (const KURL&);
    void                 slotResultCreatingDirs (KIO::Job*);
    void                 slotResultConflictCreatingDirs (KIO::Job*);
    void                 createNextDir ();
    void                 slotResultCopyingFiles (KIO::Job*);
    void                 slotResultConflictCopyingFiles (KIO::Job*);
    void                 copyNextFile ();
    void                 slotResultDeletingDirs (KIO::Job*);
    void                 deleteNextDir ();
    void                 skip (const KURL&);

%If ( KDE_3_3_2 -  )
    void                 slotResultRenaming (KIO::Job*);

%If ( KDE_3_5_2 -  )
    void                 setNextDirAttribute ();
%End

%End


protected slots:
    void                 slotStart ();
    void                 slotEntries (KIO::Job*, const KIO::UDSEntryList&);
    virtual void         slotResult (KIO::Job*);
    void                 slotProcessedSize (KIO::Job*, KIO::filesize_t);
    void                 slotTotalSize (KIO::Job*, KIO::filesize_t);
    void                 slotReport ();

protected:
//igx     virtual void         virtual_hook (int, void*);

};  // class CopyJob


class DeleteJob : KIO::Job
{
%TypeHeaderCode
#include <jobclasses.h>
%End


public:
                         DeleteJob (const KURL::List&, bool, bool);
    KURL::List           urls () const;

signals:
    void                 totalFiles (KIO::Job*, ulong);
    void                 totalDirs (KIO::Job*, ulong);
    void                 processedFiles (KIO::Job*, ulong);
    void                 processedDirs (KIO::Job*, ulong);
    void                 deleting (KIO::Job*, const KURL&);

protected slots:
    void                 slotStart ();
    void                 slotEntries (KIO::Job*, const KIO::UDSEntryList&);
    virtual void         slotResult (KIO::Job*);
    void                 slotProcessedSize (KIO::Job*, KIO::filesize_t);
    void                 slotReport ();

protected:
//igx     virtual void         virtual_hook (int, void*);

protected:

%If (  - KDE_3_1_0 )
    void                 startNextJob ();
    void                 deleteNextFile ();
    void                 deleteNextDir ();
%End


};  // class DeleteJob

};  // namespace KIO



%MappedType TQValueList<KIO::CopyInfo>
//converts a Python list of KIO::CopyInfo
{
%TypeHeaderCode
#include <qvaluelist.h>
%End

%ConvertFromTypeCode
    if (!sipCpp)
        return PyList_New(0);

    // Create the list
    PyObject *pylist;
    if ((pylist = PyList_New(0)) == NULL)
        return NULL;

    TQValueList<KIO::CopyInfo> *cpplist = (TQValueList<KIO::CopyInfo> *)sipCpp;
    PyObject *inst;

    // Get it.
    TQValueList<KIO::CopyInfo>::Iterator it;
    for( it = cpplist->begin(); it != cpplist->end(); ++it )
    {
        if (((inst = sipConvertFromNewType(new KIO::CopyInfo(*it), sipType_KIO_CopyInfo, NULL)) == NULL)
            || PyList_Append (pylist, inst) < 0)
        {
            Py_DECREF (pylist);
            return NULL;
        }
    }

    return pylist;
%End


%ConvertToTypeCode
    if (sipIsErr == NULL)
        return PyList_Check(sipPy);

    TQValueList<KIO::CopyInfo> *cpplist = new TQValueList<KIO::CopyInfo>;

    PyObject *elem;
    KIO::CopyInfo *cpp;
    int iserr = 0;

    for (int i = 0; i < PyList_Size (sipPy); i++)
    {
        elem = PyList_GET_ITEM (sipPy, i);
        cpp = (KIO::CopyInfo *)sipForceConvertToType(elem, sipType_KIO_CopyInfo, sipTransferObj, SIP_NOT_NONE|SIP_NO_CONVERTORS, NULL, &iserr);

        if (iserr)
        {
            *sipIsErr = 1;
            delete cpplist;
            return 0;
        }

        cpplist->append (*cpp);
    }

    *sipCppPtr = cpplist;

    return 1;
%End
};