public bool SetContent(QIODevice dev, StringBuilder errorMsg, ref int errorLine)
{
StackItem[] stack = new StackItem[4];
#if DEBUG
stack[1].s_class = (IntPtr)DebugGCHandle.Alloc(dev);
#else
stack[1].s_class = (IntPtr)GCHandle.Alloc(dev);
#endif
#if DEBUG
stack[2].s_class = (IntPtr)DebugGCHandle.Alloc(errorMsg);
#else
stack[2].s_class = (IntPtr)GCHandle.Alloc(errorMsg);
#endif
stack[3].s_int = errorLine;
interceptor.Invoke("setContent#$$", "setContent(QIODevice*, QString*, int*)", stack);
#if DEBUG
DebugGCHandle.Free((GCHandle)stack[1].s_class);
#else
((GCHandle)stack[1].s_class).SynchronizedFree();
#endif
#if DEBUG
DebugGCHandle.Free((GCHandle)stack[2].s_class);
#else
((GCHandle)stack[2].s_class).SynchronizedFree();
#endif
errorLine = stack[3].s_int;
return(stack[0].s_bool);
}
public bool SetContent(QIODevice dev)
{
return((bool)interceptor.Invoke("setContent#", "setContent(QIODevice*)", typeof(bool), typeof(QIODevice), dev));
}
/// <remarks>
/// Sets the XML used to define the operation schema for
/// this Service.
/// </remarks> <short> Sets the XML used to define the operation schema for this Service.</short>
protected void SetOperationsScheme(QIODevice xml)
{
interceptor.Invoke("setOperationsScheme#", "setOperationsScheme(QIODevice*)", typeof(void), typeof(QIODevice), xml);
}
public QXmlStreamReader(QIODevice device) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QXmlStreamReader#", "QXmlStreamReader(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public QNetworkReply Put(QNetworkRequest request, QIODevice data)
{
return((QNetworkReply)interceptor.Invoke("put##", "put(const QNetworkRequest&, QIODevice*)", typeof(QNetworkReply), typeof(QNetworkRequest), request, typeof(QIODevice), data));
}
public void SetDevice(QIODevice device)
{
interceptor.Invoke("setDevice#", "setDevice(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public int Put(QIODevice dev, string file, QFtp.TransferType type) {
return (int) interceptor.Invoke("put#$$", "put(QIODevice*, const QString&, QFtp::TransferType)", typeof(int), typeof(QIODevice), dev, typeof(string), file, typeof(QFtp.TransferType), type);
}
public static QByteArray ImageFormat(QIODevice device)
{
return (QByteArray) staticInterceptor.Invoke("imageFormat#", "imageFormat(QIODevice*)", typeof(QByteArray), typeof(QIODevice), device);
}
public QDataStream(QIODevice arg1) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QDataStream#", "QDataStream(QIODevice*)", typeof(void), typeof(QIODevice), arg1);
}
public int Request(QHttpRequestHeader header, QByteArray data, QIODevice to)
{
return((int)interceptor.Invoke("request###", "request(const QHttpRequestHeader&, const QByteArray&, QIODevice*)", typeof(int), typeof(QHttpRequestHeader), header, typeof(QByteArray), data, typeof(QIODevice), to));
}
public int Request(QHttpRequestHeader header, QIODevice device)
{
return((int)interceptor.Invoke("request##", "request(const QHttpRequestHeader&, QIODevice*)", typeof(int), typeof(QHttpRequestHeader), header, typeof(QIODevice), device));
}
public int Post(string path, QByteArray data, QIODevice to)
{
return((int)interceptor.Invoke("post$##", "post(const QString&, const QByteArray&, QIODevice*)", typeof(int), typeof(string), path, typeof(QByteArray), data, typeof(QIODevice), to));
}
public int Post(string path, QIODevice data)
{
return((int)interceptor.Invoke("post$#", "post(const QString&, QIODevice*)", typeof(int), typeof(string), path, typeof(QIODevice), data));
}
public int Get(string path, QIODevice to)
{
return((int)interceptor.Invoke("get$#", "get(const QString&, QIODevice*)", typeof(int), typeof(string), path, typeof(QIODevice), to));
}
public QXmlInputSource(QIODevice dev) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QXmlInputSource#", "QXmlInputSource(QIODevice*)", typeof(void), typeof(QIODevice), dev);
}
public bool Load(QIODevice dev)
{
return((bool)interceptor.Invoke("load#", "load(QIODevice*)", typeof(bool), typeof(QIODevice), dev));
}
public bool Save(QIODevice dev)
{
return((bool)interceptor.Invoke("save#", "save(QIODevice*)", typeof(bool), typeof(QIODevice), dev));
}
public bool Load(QIODevice device, string format)
{
return((bool)interceptor.Invoke("load#$", "load(QIODevice*, const char*)", typeof(bool), typeof(QIODevice), device, typeof(string), format));
}
public abstract void Serialize(Akonadi.Item item, QByteArray label, QIODevice data, ref int version);
public bool Save(QIODevice device, string format, int quality)
{
return((bool)interceptor.Invoke("save#$$", "save(QIODevice*, const char*, int) const", typeof(bool), typeof(QIODevice), device, typeof(string), format, typeof(int), quality));
}
public int Get(string file, QIODevice dev, QFtp.TransferType type) {
return (int) interceptor.Invoke("get$#$", "get(const QString&, QIODevice*, QFtp::TransferType)", typeof(int), typeof(string), file, typeof(QIODevice), dev, typeof(QFtp.TransferType), type);
}
public QIODeviceWrapper(QIODevice device)
{
m_device = device;
}
public abstract void Insert(QIODevice device);
public static QByteArray ImageFormat(QIODevice device)
{
return((QByteArray)staticInterceptor.Invoke("imageFormat#", "imageFormat(QIODevice*)", typeof(QByteArray), typeof(QIODevice), device));
}
public QSslKey(QIODevice device, QSsl.KeyAlgorithm algorithm, QSsl.EncodingFormat format)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QSslKey#$$", "QSslKey(QIODevice*, QSsl::KeyAlgorithm, QSsl::EncodingFormat)", typeof(void), typeof(QIODevice), device, typeof(QSsl.KeyAlgorithm), algorithm, typeof(QSsl.EncodingFormat), format);
}
public QImageReader(QIODevice device, QByteArray format) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QImageReader##", "QImageReader(QIODevice*, const QByteArray&)", typeof(void), typeof(QIODevice), device, typeof(QByteArray), format);
}
/// <remarks>
/// Creates an i/o device that is able to read from the QIODevice <code>inDevice</code>,
/// whether the data is compressed or not. Available compression filters
/// (gzip/bzip2 etc.) will automatically be used.
/// The compression filter to be used is determined <code>mimetype</code> .
/// Pass "application/x-gzip" or "application/x-bzip"
/// to use the corresponding decompression filter.
/// Warning: application/x-bzip may not be available.
/// In that case 0 will be returned !
/// The returned QIODevice has to be deleted after using.
/// <param> name="inDevice" input device. Won't be deleted if <code>autoDeleteInDevice</code> = false
/// </param><param> name="mimetype" the mime type for the filter
/// </param><param> name="autoDeleteInDevice" if true, <code>inDevice</code> will be deleted automatically
/// </param></remarks> <return> a QIODevice that filters the original stream. Must be deleted after
/// using
/// </return>
/// <short> Creates an i/o device that is able to read from the QIODevice <code>inDevice</code>, whether the data is compressed or not.</short>
public static QIODevice Device(QIODevice inDevice, string mimetype, bool autoDeleteInDevice)
{
return (QIODevice) staticInterceptor.Invoke("device#$$", "device(QIODevice*, const QString&, bool)", typeof(QIODevice), typeof(QIODevice), inDevice, typeof(string), mimetype, typeof(bool), autoDeleteInDevice);
}
public static List <QSslCertificate> FromDevice(QIODevice device, QSsl.EncodingFormat format)
{
return((List <QSslCertificate>)staticInterceptor.Invoke("fromDevice#$", "fromDevice(QIODevice*, QSsl::EncodingFormat)", typeof(List <QSslCertificate>), typeof(QIODevice), device, typeof(QSsl.EncodingFormat), format));
}
public bool Save(QIODevice dev, string format)
{
return (bool) interceptor.Invoke("save#$", "save(QIODevice*, const char*)", typeof(bool), typeof(QIODevice), dev, typeof(string), format);
}
public static List <QSslCertificate> FromDevice(QIODevice device)
{
return((List <QSslCertificate>)staticInterceptor.Invoke("fromDevice#", "fromDevice(QIODevice*)", typeof(List <QSslCertificate>), typeof(QIODevice), device));
}
public QXmlInputSource(QIODevice dev)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QXmlInputSource#", "QXmlInputSource(QIODevice*)", typeof(void), typeof(QIODevice), dev);
}
// QMultiMap<QSsl::AlternateNameEntryType, QString> alternateSubjectNames(); >>>> NOT CONVERTED
public QSslCertificate(QIODevice device, QSsl.EncodingFormat format) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QSslCertificate#$", "QSslCertificate(QIODevice*, QSsl::EncodingFormat)", typeof(void), typeof(QIODevice), device, typeof(QSsl.EncodingFormat), format);
}
public bool Save(QIODevice dev, string format)
{
return((bool)interceptor.Invoke("save#$", "save(QIODevice*, const char*)", typeof(bool), typeof(QIODevice), dev, typeof(string), format));
}
public QSslCertificate(QIODevice device) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QSslCertificate#", "QSslCertificate(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public QImageReader(QIODevice device)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QImageReader#", "QImageReader(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public override void Insert(QIODevice device)
{
interceptor.Invoke("insert#", "insert(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public abstract bool Deserialize(Akonadi.Item item, QByteArray label, QIODevice data, int version);
public abstract QImageIOHandler Create(QIODevice device, QByteArray format);
/// <remarks>
/// Creates an instance that operates on the given device.
/// The device can be compressed (KFilterDev) or not (QFile, etc.).
/// <param> name="dev" the device to read from
/// </param></remarks> <short> Creates an instance that operates on the given device.</short>
public KAr(QIODevice dev)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KAr#", "KAr(QIODevice*)", typeof(void), typeof(QIODevice), dev);
}
public QTextStream(QIODevice device) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QTextStream#", "QTextStream(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public int Put(QIODevice dev, string file) {
return (int) interceptor.Invoke("put#$", "put(QIODevice*, const QString&)", typeof(int), typeof(QIODevice), dev, typeof(string), file);
}
public QNetworkReply Put(QNetworkRequest request, QIODevice data)
{
return (QNetworkReply) interceptor.Invoke("put##", "put(const QNetworkRequest&, QIODevice*)", typeof(QNetworkReply), typeof(QNetworkRequest), request, typeof(QIODevice), data);
}
public int Get(string file, QIODevice dev) {
return (int) interceptor.Invoke("get$#", "get(const QString&, QIODevice*)", typeof(int), typeof(string), file, typeof(QIODevice), dev);
}
protected virtual QNetworkReply CreateRequest(QNetworkAccessManager.Operation op, QNetworkRequest request, QIODevice outgoingData)
{
return (QNetworkReply) interceptor.Invoke("createRequest$##", "createRequest(QNetworkAccessManager::Operation, const QNetworkRequest&, QIODevice*)", typeof(QNetworkReply), typeof(QNetworkAccessManager.Operation), op, typeof(QNetworkRequest), request, typeof(QIODevice), outgoingData);
}
public QImageWriter(QIODevice device, QByteArray format)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QImageWriter##", "QImageWriter(QIODevice*, const QByteArray&)", typeof(void), typeof(QIODevice), device, typeof(QByteArray), format);
}
/// <remarks>
/// Creates a MediaSource object for a QIODevice.
/// This constructor can be very handy in the combination of QByteArray and QBuffer.
/// \param ioDevice An arbitrary readable QIODevice subclass. If the device is not opened
/// MediaSource will open it as QIODevice.ReadOnly. Sequential I/O devices are possible,
/// too. For those MediaObject.IsSeekable() will have to return false obviously.
/// \see setAutoDelete
/// </remarks> <short> Creates a MediaSource object for a QIODevice.</short>
public MediaSource(QIODevice ioDevice)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("MediaSource#", "MediaSource(QIODevice*)", typeof(void), typeof(QIODevice), ioDevice);
}
protected virtual QNetworkReply CreateRequest(QNetworkAccessManager.Operation op, QNetworkRequest request, QIODevice outgoingData)
{
return((QNetworkReply)interceptor.Invoke("createRequest$##", "createRequest(QNetworkAccessManager::Operation, const QNetworkRequest&, QIODevice*)", typeof(QNetworkReply), typeof(QNetworkAccessManager.Operation), op, typeof(QNetworkRequest), request, typeof(QIODevice), outgoingData));
}
public QTextStream(QIODevice device)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QTextStream#", "QTextStream(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public QSslKey(QIODevice device, QSsl.KeyAlgorithm algorithm, QSsl.EncodingFormat format, QSsl.KeyType type, QByteArray passPhrase)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QSslKey#$$$#", "QSslKey(QIODevice*, QSsl::KeyAlgorithm, QSsl::EncodingFormat, QSsl::KeyType, const QByteArray&)", typeof(void), typeof(QIODevice), device, typeof(QSsl.KeyAlgorithm), algorithm, typeof(QSsl.EncodingFormat), format, typeof(QSsl.KeyType), type, typeof(QByteArray), passPhrase);
}
/// <remarks>
/// Sets the device on which the filter will work
/// <param> name="dev" the device on which the filter will work
/// </param><param> name="autodelete" if true, <code>dev</code> is deleted when the filter is deleted
/// </param></remarks> <short> Sets the device on which the filter will work </short>
public void SetDevice(QIODevice dev, bool autodelete)
{
interceptor.Invoke("setDevice#$", "setDevice(QIODevice*, bool)", typeof(void), typeof(QIODevice), dev, typeof(bool), autodelete);
}
public QSslKey(QIODevice device, QSsl.KeyAlgorithm algorithm)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QSslKey#$", "QSslKey(QIODevice*, QSsl::KeyAlgorithm)", typeof(void), typeof(QIODevice), device, typeof(QSsl.KeyAlgorithm), algorithm);
}
public QXmlStreamWriter(QIODevice device)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QXmlStreamWriter#", "QXmlStreamWriter(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public void SetDevice(QIODevice device)
{
interceptor.Invoke("setDevice#", "setDevice(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
public static List<QSslCertificate> FromDevice(QIODevice device, QSsl.EncodingFormat format)
{
return (List<QSslCertificate>) staticInterceptor.Invoke("fromDevice#$", "fromDevice(QIODevice*, QSsl::EncodingFormat)", typeof(List<QSslCertificate>), typeof(QIODevice), device, typeof(QSsl.EncodingFormat), format);
}
public static QIODevice Device(QIODevice inDevice, string mimetype)
{
return (QIODevice) staticInterceptor.Invoke("device#$", "device(QIODevice*, const QString&)", typeof(QIODevice), typeof(QIODevice), inDevice, typeof(string), mimetype);
}
public static List<QSslCertificate> FromDevice(QIODevice device)
{
return (List<QSslCertificate>) staticInterceptor.Invoke("fromDevice#", "fromDevice(QIODevice*)", typeof(List<QSslCertificate>), typeof(QIODevice), device);
}
public bool Load(QIODevice dev)
{
return (bool) interceptor.Invoke("load#", "load(QIODevice*)", typeof(bool), typeof(QIODevice), dev);
}
// QMultiMap<QSsl::AlternateNameEntryType,QString> alternateSubjectNames(); >>>> NOT CONVERTED
public QSslCertificate(QIODevice device, QSsl.EncodingFormat format)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QSslCertificate#$", "QSslCertificate(QIODevice*, QSsl::EncodingFormat)", typeof(void), typeof(QIODevice), device, typeof(QSsl.EncodingFormat), format);
}
public bool Save(QIODevice dev)
{
return (bool) interceptor.Invoke("save#", "save(QIODevice*)", typeof(bool), typeof(QIODevice), dev);
}
public QSslCertificate(QIODevice device)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QSslCertificate#", "QSslCertificate(QIODevice*)", typeof(void), typeof(QIODevice), device);
}
