public static void Init(string[] argv, QByteArray appname, QByteArray catalog, KLocalizedString programName, QByteArray version)
{
string[] args = new string[argv.Length + 1];
args[0] = System.Reflection.Assembly.GetExecutingAssembly().Location;
argv.CopyTo(args, 1);
staticInterceptor.Invoke("init$?####", "init(int, char**, const QByteArray&, const QByteArray&, const KLocalizedString&, const QByteArray&)", typeof(void), false, typeof(int), args.Length, typeof(string[]), args, typeof(QByteArray), appname, typeof(QByteArray), catalog, typeof(KLocalizedString), programName, typeof(QByteArray), version);
}
public static QByteArray FromArray(byte[] array)
{
var qba = new QByteArray(array.Length, '\0');
Pointer<sbyte> p = qba.Data();
for (int i = 0; i < array.Length; i++) {
p[i] = (sbyte) array[i];
}
return qba;
}
public static byte[] ToArray(QByteArray qba)
{
Pointer<sbyte> p = qba.Data();
byte[] array = new byte[qba.Size()];
for (int i = 0; i < qba.Size(); i++) {
array[i] = (byte) p[i];
}
return array;
}
public static byte[] ToArray(QByteArray qba)
{
Pointer <sbyte> p = qba.Data();
byte[] array = new byte[qba.Size()];
for (int i = 0; i < qba.Size(); i++)
{
array[i] = (byte)p[i];
}
return(array);
}
public static QByteArray FromArray(byte[] array)
{
var qba = new QByteArray(array.Length, '\0');
Pointer <sbyte> p = qba.Data();
for (int i = 0; i < array.Length; i++)
{
p[i] = (sbyte)array[i];
}
return(qba);
}
protected override bool IsGroupImmutableImpl(QByteArray aGroup)
{
return (bool) interceptor.Invoke("isGroupImmutableImpl#", "isGroupImmutableImpl(const QByteArray&) const", typeof(bool), typeof(QByteArray), aGroup);
}
protected override KConfigGroup GroupImpl(QByteArray b)
{
return (KConfigGroup) interceptor.Invoke("groupImpl#", "groupImpl(const QByteArray&)", typeof(KConfigGroup), typeof(QByteArray), b);
}
public static QDataStream Read(QDataStream arg1, QByteArray arg2)
{
return (QDataStream) staticInterceptor.Invoke("operator>>##", "operator>>(QDataStream&, QByteArray&)", typeof(QDataStream), typeof(QDataStream), arg1, typeof(QByteArray), arg2);
}
/// <remarks>
/// Creates a new session.
/// <param> name="sessionId" The identifier for this session, will be a
/// random value if empty.
/// </param><param> name="parent" The parent object.
/// </param></remarks> <short> Creates a new session.</short>
/// <see> defaultSession</see>
public Session(QByteArray sessionId, QObject parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Session##", "Session(const QByteArray&, QObject*)", typeof(void), typeof(QByteArray), sessionId, typeof(QObject), parent);
}
public static QTextCodec CodecForHtml(QByteArray ba)
{
return((QTextCodec)staticInterceptor.Invoke("codecForHtml#", "codecForHtml(const QByteArray&)", typeof(QTextCodec), typeof(QByteArray), ba));
}
public static string DecodeName(QByteArray localFileName)
{
return((string)staticInterceptor.Invoke("decodeName#", "decodeName(const QByteArray&)", typeof(string), typeof(QByteArray), localFileName));
}
public bool HasEncodedQueryItem(QByteArray key)
{
return((bool)interceptor.Invoke("hasEncodedQueryItem#", "hasEncodedQueryItem(const QByteArray&) const", typeof(bool), typeof(QByteArray), key));
}
public QByteArray EncodedQueryItemValue(QByteArray key)
{
return((QByteArray)interceptor.Invoke("encodedQueryItemValue#", "encodedQueryItemValue(const QByteArray&) const", typeof(QByteArray), typeof(QByteArray), key));
}
public void SetEncodedQuery(QByteArray query)
{
interceptor.Invoke("setEncodedQuery#", "setEncodedQuery(const QByteArray&)", typeof(void), typeof(QByteArray), query);
}
public void AddEncodedQueryItem(QByteArray key, QByteArray value)
{
interceptor.Invoke("addEncodedQueryItem##", "addEncodedQueryItem(const QByteArray&, const QByteArray&)", typeof(void), typeof(QByteArray), key, typeof(QByteArray), value);
}
public void SetEncodedPath(QByteArray path)
{
interceptor.Invoke("setEncodedPath#", "setEncodedPath(const QByteArray&)", typeof(void), typeof(QByteArray), path);
}
public void SetEncodedHost(QByteArray host)
{
interceptor.Invoke("setEncodedHost#", "setEncodedHost(const QByteArray&)", typeof(void), typeof(QByteArray), host);
}
public void SetEncodedPassword(QByteArray password)
{
interceptor.Invoke("setEncodedPassword#", "setEncodedPassword(const QByteArray&)", typeof(void), typeof(QByteArray), password);
}
public QByteArray ToPem(QByteArray passPhrase)
{
return (QByteArray) interceptor.Invoke("toPem#", "toPem(const QByteArray&) const", typeof(QByteArray), typeof(QByteArray), passPhrase);
}
public List <QByteArray> AllEncodedQueryItemValues(QByteArray key)
{
return((List <QByteArray>)interceptor.Invoke("allEncodedQueryItemValues#", "allEncodedQueryItemValues(const QByteArray&) const", typeof(List <QByteArray>), typeof(QByteArray), key));
}
public QSslKey(QByteArray encoded, QSsl.KeyAlgorithm algorithm)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QSslKey#$", "QSslKey(const QByteArray&, QSsl::KeyAlgorithm)", typeof(void), typeof(QByteArray), encoded, typeof(QSsl.KeyAlgorithm), algorithm);
}
public void RemoveAllEncodedQueryItems(QByteArray key)
{
interceptor.Invoke("removeAllEncodedQueryItems#", "removeAllEncodedQueryItems(const QByteArray&)", typeof(void), typeof(QByteArray), key);
}
public string ToUnicode(QByteArray arg1)
{
return((string)interceptor.Invoke("toUnicode#", "toUnicode(const QByteArray&) const", typeof(string), typeof(QByteArray), arg1));
}
public void SetEncodedFragment(QByteArray fragment)
{
interceptor.Invoke("setEncodedFragment#", "setEncodedFragment(const QByteArray&)", typeof(void), typeof(QByteArray), fragment);
}
public void SetEncodedUserName(QByteArray userName)
{
interceptor.Invoke("setEncodedUserName#", "setEncodedUserName(const QByteArray&)", typeof(void), typeof(QByteArray), userName);
}
public static QUrl FromEncoded(QByteArray url)
{
return((QUrl)staticInterceptor.Invoke("fromEncoded#", "fromEncoded(const QByteArray&)", typeof(QUrl), typeof(QByteArray), url));
}
public QXmlStreamReader(QByteArray data) : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QXmlStreamReader#", "QXmlStreamReader(const QByteArray&)", typeof(void), typeof(QByteArray), data);
}
public static QUrl FromEncoded(QByteArray url, QUrl.ParsingMode mode)
{
return((QUrl)staticInterceptor.Invoke("fromEncoded#$", "fromEncoded(const QByteArray&, QUrl::ParsingMode)", typeof(QUrl), typeof(QByteArray), url, typeof(QUrl.ParsingMode), mode));
}
/// <remarks>
/// For writing gzip compressed files only:
/// set the name of the original file, to be used in the gzip header.
/// <param> name="fileName" the name of the original file
/// </param></remarks> <short> For writing gzip compressed files only: set the name of the original file, to be used in the gzip header.</short>
public void SetOrigFileName(QByteArray fileName)
{
interceptor.Invoke("setOrigFileName#", "setOrigFileName(const QByteArray&)", typeof(void), typeof(QByteArray), fileName);
}
public static QByteArray ToPercentEncoding(string arg1, QByteArray exclude)
{
return((QByteArray)staticInterceptor.Invoke("toPercentEncoding$#", "toPercentEncoding(const QString&, const QByteArray&)", typeof(QByteArray), typeof(string), arg1, typeof(QByteArray), exclude));
}
protected override void DeleteGroupImpl(QByteArray group, uint flags)
{
interceptor.Invoke("deleteGroupImpl#$", "deleteGroupImpl(const QByteArray&, KConfigBase::WriteConfigFlags)", typeof(void), typeof(QByteArray), group, typeof(uint), flags);
}
public static string FromAce(QByteArray arg1)
{
return((string)staticInterceptor.Invoke("fromAce#", "fromAce(const QByteArray&)", typeof(string), typeof(QByteArray), arg1));
}
protected override bool HasGroupImpl(QByteArray group)
{
return (bool) interceptor.Invoke("hasGroupImpl#", "hasGroupImpl(const QByteArray&) const", typeof(bool), typeof(QByteArray), group);
}
public void SetEncodedUrl(QByteArray url)
{
interceptor.Invoke("setEncodedUrl#", "setEncodedUrl(const QByteArray&)", typeof(void), typeof(QByteArray), url);
}
public QNetworkReply Post(QNetworkRequest request, QByteArray data)
{
return((QNetworkReply)interceptor.Invoke("post##", "post(const QNetworkRequest&, const QByteArray&)", typeof(QNetworkReply), typeof(QNetworkRequest), request, typeof(QByteArray), data));
}
public void SetEncodedUrl(QByteArray url, QUrl.ParsingMode mode)
{
interceptor.Invoke("setEncodedUrl#$", "setEncodedUrl(const QByteArray&, QUrl::ParsingMode)", typeof(void), typeof(QByteArray), url, typeof(QUrl.ParsingMode), mode);
}
public QSslKey(QByteArray encoded, QSsl.KeyAlgorithm algorithm, QSsl.EncodingFormat format, QSsl.KeyType type)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QSslKey#$$$", "QSslKey(const QByteArray&, QSsl::KeyAlgorithm, QSsl::EncodingFormat, QSsl::KeyType)", typeof(void), typeof(QByteArray), encoded, typeof(QSsl.KeyAlgorithm), algorithm, typeof(QSsl.EncodingFormat), format, typeof(QSsl.KeyType), type);
}
public bool HasRawHeader(QByteArray headerName)
{
return((bool)interceptor.Invoke("hasRawHeader#", "hasRawHeader(const QByteArray&) const", typeof(bool), typeof(QByteArray), headerName));
}
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>
/// Write block
/// <param> name="data" the data to write
/// </param></remarks> <short> Write block </short>
public void Write(QByteArray data)
{
interceptor.Invoke("write#", "write(const QByteArray&)", typeof(void), typeof(QByteArray), data);
}
public static QTextCodec CodecForHtml(QByteArray ba, QTextCodec defaultCodec)
{
return((QTextCodec)staticInterceptor.Invoke("codecForHtml##", "codecForHtml(const QByteArray&, QTextCodec*)", typeof(QTextCodec), typeof(QByteArray), ba, typeof(QTextCodec), defaultCodec));
}
public static QByteArray QCompress(QByteArray data, int compressionLevel)
{
return (QByteArray) staticInterceptor.Invoke("qCompress#$", "qCompress(const QByteArray&, int)", typeof(QByteArray), typeof(QByteArray), data, typeof(int), compressionLevel);
}
public static QTextCodec CodecForName(QByteArray name)
{
return((QTextCodec)staticInterceptor.Invoke("codecForName#", "codecForName(const QByteArray&)", typeof(QTextCodec), typeof(QByteArray), name));
}
public static int Qstrcmp(string str1, QByteArray str2)
{
return (int) staticInterceptor.Invoke("qstrcmp$#", "qstrcmp(const char*, const QByteArray&)", typeof(int), typeof(string), str1, typeof(QByteArray), str2);
}
public QByteArray RawHeader(QByteArray headerName)
{
return((QByteArray)interceptor.Invoke("rawHeader#", "rawHeader(const QByteArray&) const", typeof(QByteArray), typeof(QByteArray), headerName));
}
public void SetContent(QByteArray data)
{
interceptor.Invoke("setContent#", "setContent(const QByteArray&)", typeof(void), typeof(QByteArray), data);
}
public static QTextCodec CodecForHtml(QByteArray ba)
{
return (QTextCodec) staticInterceptor.Invoke("codecForHtml#", "codecForHtml(const QByteArray&)", typeof(QTextCodec), typeof(QByteArray), ba);
}
protected void SetRawHeader(QByteArray headerName, QByteArray value)
{
interceptor.Invoke("setRawHeader##", "setRawHeader(const QByteArray&, const QByteArray&)", typeof(void), typeof(QByteArray), headerName, typeof(QByteArray), value);
}
public static bool Qputenv(string varName, QByteArray value)
{
return (bool) staticInterceptor.Invoke("qputenv$#", "qputenv(const char*, const QByteArray&)", typeof(bool), typeof(string), varName, typeof(QByteArray), value);
}
public bool RestoreState(QByteArray state)
{
return (bool) interceptor.Invoke("restoreState#", "restoreState(const QByteArray&)", typeof(bool), typeof(QByteArray), state);
}
public static QByteArray QUncompress(QByteArray data)
{
return (QByteArray) staticInterceptor.Invoke("qUncompress#", "qUncompress(const QByteArray&)", typeof(QByteArray), typeof(QByteArray), data);
}
public void SetFormat(QByteArray format)
{
interceptor.Invoke("setFormat#", "setFormat(const QByteArray&)", typeof(void), typeof(QByteArray), format);
}
public static QDataStream Write(QDataStream arg1, QByteArray arg2)
{
return (QDataStream) staticInterceptor.Invoke("operator<<##", "operator<<(QDataStream&, const QByteArray&)", typeof(QDataStream), typeof(QDataStream), arg1, typeof(QByteArray), arg2);
}
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);
}
public void AddData(QByteArray data)
{
interceptor.Invoke("addData#", "addData(const QByteArray&)", typeof(void), typeof(QByteArray), data);
}
public QImageWriter(string fileName, QByteArray format)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QImageWriter$#", "QImageWriter(const QString&, const QByteArray&)", typeof(void), typeof(string), fileName, typeof(QByteArray), format);
}
public Session(QByteArray sessionId)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Session#", "Session(const QByteArray&)", typeof(void), typeof(QByteArray), sessionId);
}
/// <remarks>
/// Writes a value to the config object.
/// <param> name="key" The key to write
/// </param><param> name="value" The value to write
/// </param><param> name="pFlags" The flags to use when writing this entry.
/// </param></remarks> <short> Writes a value to the config object.</short>
public void WriteEntry(string key, QByteArray value, uint pFlags)
{
interceptor.Invoke("writeEntry$#$", "writeEntry(const QString&, const QByteArray&, KConfigBase::WriteConfigFlags)", typeof(void), typeof(string), key, typeof(QByteArray), value, typeof(uint), pFlags);
}
public QDynamicPropertyChangeEvent(QByteArray name)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("QDynamicPropertyChangeEvent#", "QDynamicPropertyChangeEvent(const QByteArray&)", typeof(void), typeof(QByteArray), name);
}
public void WriteEntry(string key, QByteArray value)
{
interceptor.Invoke("writeEntry$#", "writeEntry(const QString&, const QByteArray&)", typeof(void), typeof(string), key, typeof(QByteArray), value);
}
