/// <remarks>
/// Creates a new slave.
/// <param> name="protocol" the protocol
/// </param><param> name="url" is the url
/// </param><param> name="error" is the error code on failure and undefined else.
/// </param><param> name="error_text" is the error text on failure and undefined else.
/// </param></remarks> <return> 0 on failure, or a pointer to a slave otherwise.
/// </return>
/// <short> Creates a new slave.</short>
public static KIO.Slave CreateSlave(string protocol, KUrl url, ref int error, StringBuilder error_text)
{
StackItem[] stack = new StackItem[5];
#if DEBUG
stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(protocol);
#else
stack[1].s_class = (IntPtr) GCHandle.Alloc(protocol);
#endif
#if DEBUG
stack[2].s_class = (IntPtr) DebugGCHandle.Alloc(url);
#else
stack[2].s_class = (IntPtr) GCHandle.Alloc(url);
#endif
stack[3].s_int = error;
#if DEBUG
stack[4].s_class = (IntPtr) DebugGCHandle.Alloc(error_text);
#else
stack[4].s_class = (IntPtr) GCHandle.Alloc(error_text);
#endif
staticInterceptor.Invoke("createSlave$#$$", "createSlave(const QString&, const KUrl&, int&, QString&)", 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
error = stack[3].s_int;
#if DEBUG
DebugGCHandle.Free((GCHandle) stack[4].s_class);
#else
((GCHandle) stack[4].s_class).SynchronizedFree();
#endif
return (KIO.Slave) Enum.ToObject(typeof(KIO.Slave), stack[0].s_int);
}
public override void Get(KUrl url)
{
string docurl = url.ToString().Substring(9);
if (docurl == string.Empty) {
Redirection(new KUrl("monodoc:/root:/classlib"));
Finished();
return;
}
MimeType("text/html");
Node n;
try {
string data = GetHtml(docurl, null, out n);
if (data != null) {
data = data.Replace("href=\"", "href=\"monodoc:/");
Data(data);
} else {
Data("The requested url is not availible");
}
} catch {
Data("The requested url is not availible");
}
Finished();
}
/// <remarks>
/// Used to access a service from an url. Always check for the signal serviceReady() that fires
/// when this service is actually ready for use.
/// </remarks> <short> Used to access a service from an url.</short>
public static Plasma.Service Access(KUrl url, QObject parent)
{
return (Plasma.Service) staticInterceptor.Invoke("access##", "access(const KUrl&, QObject*)", typeof(Plasma.Service), typeof(KUrl), url, typeof(QObject), parent);
}
public abstract void ShowPreview(KUrl url);
public virtual void Save(KUrl url, string suggestedFileName)
{
interceptor.Invoke("save#$", "save(const KUrl&, const QString&)", typeof(void), typeof(KUrl), url, typeof(string), suggestedFileName);
}
public static void SimpleSave(KUrl url, string suggestedFileName, QWidget window)
{
staticInterceptor.Invoke("simpleSave#$#", "simpleSave(const KUrl&, const QString&, QWidget*)", typeof(void), typeof(KUrl), url, typeof(string), suggestedFileName, typeof(QWidget), window);
}
public static KParts.BrowserRun.AskSaveResult AskEmbedOrSave(KUrl url, string mimeType)
{
return (KParts.BrowserRun.AskSaveResult) staticInterceptor.Invoke("askEmbedOrSave#$", "askEmbedOrSave(const KUrl&, const QString&)", typeof(KParts.BrowserRun.AskSaveResult), typeof(KUrl), url, typeof(string), mimeType);
}
public static bool AllowExecution(string mimeType, KUrl url)
{
return (bool) staticInterceptor.Invoke("allowExecution$#", "allowExecution(const QString&, const KUrl&)", typeof(bool), typeof(string), mimeType, typeof(KUrl), url);
}
/// <remarks>
/// Converts the given URL into 8-bit form and separate the
/// dirname from the filename. This is useful for slave functions
/// like stat or get.
/// The dirname is returned with the final slash always stripped
/// </remarks> <short> Converts the given URL into 8-bit form and separate the dirname from the filename.</short>
public QByteArray Directory(KUrl url, bool ignore_trailing_slash)
{
return (QByteArray) interceptor.Invoke("directory#$", "directory(const KUrl&, bool) const", typeof(QByteArray), typeof(KUrl), url, typeof(bool), ignore_trailing_slash);
}
/// <remarks>
/// Converts the given URL into 8-bit form and retrieve the filename.
/// </remarks> <short> Converts the given URL into 8-bit form and retrieve the filename.</short>
public QByteArray FileName(KUrl url)
{
return (QByteArray) interceptor.Invoke("fileName#", "fileName(const KUrl&) const", typeof(QByteArray), typeof(KUrl), url);
}
/// <remarks>
/// Converts the given URL into its 8-bit components
/// </remarks> <short> Converts the given URL into its 8-bit components </short>
public QByteArray Encode(KUrl url)
{
return (QByteArray) interceptor.Invoke("encode#", "encode(const KUrl&) const", typeof(QByteArray), typeof(KUrl), url);
}
public override bool OpenUrl(KUrl url)
{
return (bool) interceptor.Invoke("openUrl#", "openUrl(const KUrl&)", typeof(bool), typeof(KUrl), url);
}
public virtual void Begin(KUrl url)
{
interceptor.Invoke("begin#", "begin(const KUrl&)", typeof(void), typeof(KUrl), url);
}
public virtual void Begin(KUrl url, int xOffset)
{
interceptor.Invoke("begin#$", "begin(const KUrl&, int)", typeof(void), typeof(KUrl), url, typeof(int), xOffset);
}
/// <remarks>
/// presents a detailed error message to the user.
/// <code>errorCode</code> kio error code, eg KIO.ERR_SERVER_TIMEOUT.
/// <code>text</code> kio additional information text.
/// <code>url</code> the url that triggered the error.
/// </remarks> <short> presents a detailed error message to the user.</short>
protected void HtmlError(int errorCode, string text, KUrl reqUrl)
{
interceptor.Invoke("htmlError$$#", "htmlError(int, const QString&, const KUrl&)", typeof(void), typeof(int), errorCode, typeof(string), text, typeof(KUrl), reqUrl);
}
/// <remarks>
/// Set the URL of the bookmark
/// <param> name="url" the new bookmark URL
/// </param></remarks> <short> Set the URL of the bookmark </short>
public void SetUrl(KUrl url)
{
interceptor.Invoke("setUrl#", "setUrl(const KUrl&)", typeof(void), typeof(KUrl), url);
}
/// <remarks>
/// Find a KFileItem by URL and return it.
/// </remarks> <return> the item with the given URL, or a null-item if none was found
/// (see KFileItem.IsNull())
/// </return>
/// <short> Find a KFileItem by URL and return it.</short>
public KFileItem FindByUrl(KUrl url)
{
return (KFileItem) interceptor.Invoke("findByUrl#", "findByUrl(const KUrl&) const", typeof(KFileItem), typeof(KUrl), url);
}
public QByteArray Directory(KUrl url)
{
return (QByteArray) interceptor.Invoke("directory#", "directory(const KUrl&) const", typeof(QByteArray), typeof(KUrl), url);
}
/// <remarks>
/// Similar to askSave but for the case where the current application is
/// able to embed the url itself (instead of passing it to another app).
/// <param> name="url" the URL in question
/// </param><param> name="mimeType" the mimetype of the URL
/// </param><param> name="suggestedFileName" optional filename suggested by the server
/// </param><param> name="flags" set to AttachmentDisposition if suggested by the server
/// </param></remarks> <return> Save, Open or Cancel.
/// </return>
/// <short> Similar to askSave but for the case where the current application is able to embed the url itself (instead of passing it to another app).</short>
public static KParts.BrowserRun.AskSaveResult AskEmbedOrSave(KUrl url, string mimeType, string suggestedFileName, int flags)
{
return (KParts.BrowserRun.AskSaveResult) staticInterceptor.Invoke("askEmbedOrSave#$$$", "askEmbedOrSave(const KUrl&, const QString&, const QString&, int)", typeof(KParts.BrowserRun.AskSaveResult), typeof(KUrl), url, typeof(string), mimeType, typeof(string), suggestedFileName, typeof(int), flags);
}
public void OpenUrlRequest(KUrl url, KParts.OpenUrlArguments part)
{
SetUrl(url.Url());
}
public static KParts.BrowserRun.AskSaveResult AskSave(KUrl url, KService offer, string mimeType)
{
return (KParts.BrowserRun.AskSaveResult) staticInterceptor.Invoke("askSave#?$", "askSave(const KUrl&, KSharedPtr<KService>, const QString&)", typeof(KParts.BrowserRun.AskSaveResult), typeof(KUrl), url, typeof(KService), offer, typeof(string), mimeType);
}
public void OpenUrlRequest(KUrl url, KParts.OpenUrlArguments part)
{
location.Text = url.Url();
ChangeLocation();
}
public static void SimpleSave(KUrl url, string suggestedFileName)
{
staticInterceptor.Invoke("simpleSave#$", "simpleSave(const KUrl&, const QString&)", typeof(void), typeof(KUrl), url, typeof(string), suggestedFileName);
}
/// <remarks>
/// Requests a slave for use in connection-oriented mode.
/// <param> name="url" This defines the username,password,host & port to
/// connect with.
/// </param><param> name="config" Configuration data for the slave.
/// </param></remarks> <return> A pointer to a connected slave or 0 if an error occurred.
/// </return>
/// <short> Requests a slave for use in connection-oriented mode.</short>
/// <see> assignJobToSlave</see>
/// <see> disconnectSlave</see>
public static KIO.Slave GetConnectedSlave(KUrl url, KIO.MetaData config)
{
return (KIO.Slave) staticInterceptor.Invoke("getConnectedSlave##", "getConnectedSlave(const KUrl&, const KIO::MetaData&)", typeof(KIO.Slave), typeof(KUrl), url, typeof(KIO.MetaData), config);
}
public BrowserRun(KUrl url, KParts.OpenUrlArguments args, KParts.BrowserArguments browserArgs, KParts.ReadOnlyPart part, QWidget window, bool removeReferrer, bool trustedSource)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("BrowserRun#####$$", "BrowserRun(const KUrl&, const KParts::OpenUrlArguments&, const KParts::BrowserArguments&, KParts::ReadOnlyPart*, QWidget*, bool, bool)", typeof(void), typeof(KUrl), url, typeof(KParts.OpenUrlArguments), args, typeof(KParts.BrowserArguments), browserArgs, typeof(KParts.ReadOnlyPart), part, typeof(QWidget), window, typeof(bool), removeReferrer, typeof(bool), trustedSource);
}
public static KIO.Slave GetConnectedSlave(KUrl url)
{
return (KIO.Slave) staticInterceptor.Invoke("getConnectedSlave#", "getConnectedSlave(const KUrl&)", typeof(KIO.Slave), typeof(KUrl), url);
}
protected void StoreSSLSessionFromJob(KUrl m_redirectionURL)
{
interceptor.Invoke("storeSSLSessionFromJob#", "storeSSLSessionFromJob(const KUrl&)", typeof(void), typeof(KUrl), m_redirectionURL);
}
/// <remarks>
/// Puts a slave on notice. A next job may reuse this slave if it
/// requests the same URL.
/// A job can be put on hold after it has emit'ed its mimetype.
/// Based on the mimetype, the program can give control to another
/// component in the same process which can then resume the job
/// by simply asking for the same URL again.
/// <param> name="job" the job that should be stopped
/// </param><param> name="url" the URL that is handled by the <code>url</code>
/// </param></remarks> <short> Puts a slave on notice.</short>
public static void PutSlaveOnHold(KIO.SimpleJob job, KUrl url)
{
staticInterceptor.Invoke("putSlaveOnHold##", "putSlaveOnHold(KIO::SimpleJob*, const KUrl&)", typeof(void), typeof(KIO.SimpleJob), job, typeof(KUrl), url);
}
public static Plasma.Service Access(KUrl url)
{
return (Plasma.Service) staticInterceptor.Invoke("access#", "access(const KUrl&)", typeof(Plasma.Service), typeof(KUrl), url);
}
public static KBookmark StandaloneBookmark(string text, KUrl url)
{
return (KBookmark) staticInterceptor.Invoke("standaloneBookmark$#", "standaloneBookmark(const QString&, const KUrl&)", typeof(KBookmark), typeof(string), text, typeof(KUrl), url);
}
