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 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); }