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

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

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