/// <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);
}
protected void SlotBrowserMimetype(KIO.Job job, string type)
{
interceptor.Invoke("slotBrowserMimetype#$", "slotBrowserMimetype(KIO::Job*, const QString&)", typeof(void), typeof(KIO.Job), job, typeof(string), type);
}
/// <remarks>
/// Stop the execution of a job.
/// <param> name="job" the job to cancel
/// </param></remarks> <short> Stop the execution of a job.</short>
public static void CancelJob(KIO.SimpleJob job)
{
staticInterceptor.Invoke("cancelJob#", "cancelJob(KIO::SimpleJob*)", typeof(void), typeof(KIO.SimpleJob), job);
}
/// <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);
}
protected virtual void StartingJob(KIO.Job arg1)
{
interceptor.Invoke("startingJob#", "startingJob(KIO::Job*)", typeof(void), typeof(KIO.Job), arg1);
}
// KIO::SlaveInterface* SlaveInterface(KIO::SlaveInterfacePrivate& arg1,QObject* arg2); >>>> NOT CONVERTED
// KIO::SlaveInterface* SlaveInterface(KIO::SlaveInterfacePrivate& arg1); >>>> NOT CONVERTED
public void SetConnection(KIO.Connection connection)
{
interceptor.Invoke("setConnection#", "setConnection(KIO::Connection*)", typeof(void), typeof(KIO.Connection), connection);
}
protected virtual void PrepareUDSEntry(KIO.UDSEntry entry)
{
interceptor.Invoke("prepareUDSEntry#", "prepareUDSEntry(KIO::UDSEntry&) const", typeof(void), typeof(KIO.UDSEntry), entry);
}
/// <remarks>
/// Set meta data to be sent to the slave, replacing existing
/// meta data.
/// <param> name="metaData" the meta data to set
/// </param></remarks> <short> Set meta data to be sent to the slave, replacing existing meta data.</short>
/// <see> addMetaData</see>
/// <see> mergeMetaData</see>
public void SetMetaData(KIO.MetaData metaData)
{
interceptor.Invoke("setMetaData#", "setMetaData(const KIO::MetaData&)", typeof(void), typeof(KIO.MetaData), metaData);
}
// KIO::MultiGetJob* MultiGetJob(KIO::MultiGetJobPrivate& arg1); >>>> NOT CONVERTED
/// <remarks>
/// Get an additional file.
/// <param> name="id" the id of the file
/// </param><param> name="url" the url of the file to get
/// </param><param> name="metaData" the meta data for this request
/// </param></remarks> <short> Get an additional file.</short>
public void Get(long id, KUrl url, KIO.MetaData metaData)
{
interceptor.Invoke("get$##", "get(long, const KUrl&, const KIO::MetaData&)", typeof(void), typeof(long), id, typeof(KUrl), url, typeof(KIO.MetaData), metaData);
}
protected virtual void PrepareUDSEntry(KIO.UDSEntry entry, bool listing)
{
interceptor.Invoke("prepareUDSEntry#$", "prepareUDSEntry(KIO::UDSEntry&, bool) const", typeof(void), typeof(KIO.UDSEntry), entry, typeof(bool), listing);
}
protected virtual void HandleError(KIO.Job arg1)
{
interceptor.Invoke("handleError#", "handleError(KIO::Job*)", typeof(void), typeof(KIO.Job), arg1);
}
/// <remarks>
/// Copy constructor.
/// </remarks> <short> Copy constructor.</short>
public AuthInfo(KIO.AuthInfo info)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("AuthInfo#", "AuthInfo(const KIO::AuthInfo&)", typeof(void), typeof(KIO.AuthInfo), info);
}
/// <remarks>
/// Set Extra Field Flags
/// </remarks> <short> Set Extra Field Flags </short>
public void SetExtraFieldFlags(string fieldName, KIO.AuthInfo.FieldFlags flags)
{
interceptor.Invoke("setExtraFieldFlags$$", "setExtraFieldFlags(const QString&, const KIO::AuthInfo::FieldFlags)", typeof(void), typeof(string), fieldName, typeof(KIO.AuthInfo.FieldFlags), flags);
}
public virtual void ConfigDataFor(KIO.MetaData configData, string proto, string host)
{
interceptor.Invoke("configDataFor#$$", "configDataFor(KIO::MetaData&, const QString&, const QString&)", typeof(void), typeof(KIO.MetaData), configData, typeof(string), proto, typeof(string), host);
}
/// <remarks>
/// Sets the job.
/// </remarks> <short> Sets the job.</short>
protected void SetJob(KIO.Job job)
{
interceptor.Invoke("setJob#", "setJob(KIO::Job*)", typeof(void), typeof(KIO.Job), job);
}
public bool OpenPasswordDialog(KIO.AuthInfo info)
{
return (bool) interceptor.Invoke("openPasswordDialog#", "openPasswordDialog(KIO::AuthInfo&)", typeof(bool), typeof(KIO.AuthInfo), info);
}
protected void SlotScanMimeType(KIO.Job arg1, string type)
{
interceptor.Invoke("slotScanMimeType#$", "slotScanMimeType(KIO::Job*, const QString&)", typeof(void), typeof(KIO.Job), arg1, typeof(string), type);
}
/// <remarks>
/// Set the parent Job.
/// One example use of this is when FileCopyJob calls RenameDialog.Open,
/// it must pass the correct progress ID of the parent CopyJob
/// (to hide the progress dialog).
/// You can set the parent job only once. By default a job does not
/// have a parent job.
/// <param> name="parentJob" the new parent job
/// </param></remarks> <short> Set the parent Job.</short>
public void SetParentJob(KIO.Job parentJob)
{
interceptor.Invoke("setParentJob#", "setParentJob(KIO::Job*)", typeof(void), typeof(KIO.Job), parentJob);
}
/// <remarks>
/// Call this from stat() to express details about an object, the
/// UDSEntry customarily contains the atoms describing file name, size,
/// mimetype, etc.
/// <param> name="_entry" The UDSEntry containing all of the object attributes.
/// </param></remarks> <short> Call this from stat() to express details about an object, the UDSEntry customarily contains the atoms describing file name, size, mimetype, etc.</short>
public void StatEntry(KIO.UDSEntry _entry)
{
interceptor.Invoke("statEntry#", "statEntry(const KIO::UDSEntry&)", typeof(void), typeof(KIO.UDSEntry), _entry);
}
/// <remarks>
/// Configure slaves of type <code>protocol</code> with <code>config.</code>
/// If <code>host</code> is specified the configuration only applies when dealing
/// with <code>host.</code>
/// Changes made to the slave configuration only apply to slaves
/// used by the current process.
/// </remarks> <short> Configure slaves of type <code>protocol</code> with <code>config.</code></short>
public void SetConfigData(string protocol, string host, KIO.MetaData config)
{
interceptor.Invoke("setConfigData$$#", "setConfigData(const QString&, const QString&, const KIO::MetaData&)", typeof(void), typeof(string), protocol, typeof(string), host, typeof(KIO.MetaData), config);
}
/// <remarks>
/// Checks for cached authentication based on parameters
/// given by <code>info.</code>
/// Use this function to check if any cached password exists
/// for the URL given by <code>info.</code> If <code>AuthInfo</code>.RealmValue
/// and/or <code>AuthInfo</code>.VerifyPath flag is specified, then
/// they will also be factored in determining the presence
/// of a cached password. Note that <code>Auth</code>.Url is a required
/// parameter when attempting to check for cached authorization
/// info. Here is a simple example:
/// <pre>
/// AuthInfo info;
/// info.url = KUrl("http://www.foobar.org/foo/bar");
/// info.username = "******";
/// info.verifyPath = true;
/// if ( !checkCachedAuthentication( info ) )
/// {
/// if ( !openPasswordDialog(info) )
/// ....
/// }
/// </pre>
/// <param> name="info" See AuthInfo.
/// </param></remarks> <return> <code>true</code> if cached Authorization is found, false otherwise.
/// </return>
/// <short> Checks for cached authentication based on parameters given by <code>info.</code></short>
public bool CheckCachedAuthentication(KIO.AuthInfo info)
{
return (bool) interceptor.Invoke("checkCachedAuthentication#", "checkCachedAuthentication(KIO::AuthInfo&)", typeof(bool), typeof(KIO.AuthInfo), info);
}
/// <remarks>
/// Uses <code>slave</code> to do <code>job.</code>
/// This function should be called immediately after creating a Job.
/// <param> name="slave" The slave to use. The slave must have been obtained
/// with a call to getConnectedSlave and must not
/// be currently assigned to any other job.
/// </param><param> name="job" The job to do.
/// </param></remarks> <return> true is successful, false otherwise.
/// </return>
/// <short> Uses <code>slave</code> to do <code>job.</code></short>
/// <see> getConnectedSlave</see>
/// <see> disconnectSlave</see>
/// <see> slaveConnected</see>
/// <see> slaveError</see>
public static bool AssignJobToSlave(KIO.Slave slave, KIO.SimpleJob job)
{
return (bool) staticInterceptor.Invoke("assignJobToSlave##", "assignJobToSlave(KIO::Slave*, KIO::SimpleJob*)", typeof(bool), typeof(KIO.Slave), slave, typeof(KIO.SimpleJob), job);
}
/// <remarks>
/// internal function to be called by the slave.
/// It collects entries and emits them via listEntries
/// when enough of them are there or a certain time
/// frame exceeded (to make sure the app gets some
/// items in time but not too many items one by one
/// as this will cause a drastic performance penalty)
/// <param> name="_entry" The UDSEntry containing all of the object attributes.
/// </param><param> name="ready" set to true after emitting all items. <code>_entry</code> is not
/// used in this case
/// </param></remarks> <short> internal function to be called by the slave.</short>
public void ListEntry(KIO.UDSEntry _entry, bool ready)
{
interceptor.Invoke("listEntry#$", "listEntry(const KIO::UDSEntry&, bool)", typeof(void), typeof(KIO.UDSEntry), _entry, typeof(bool), ready);
}
/// <remarks>
/// Disconnects <code>slave.</code>
/// <param> name="slave" The slave to disconnect. The slave must have been
/// obtained with a call to getConnectedSlave
/// and must not be assigned to any job.
/// </param></remarks> <return> true is successful, false otherwise.
/// </return>
/// <short> Disconnects <code>slave.</code></short>
/// <see> getConnectedSlave</see>
/// <see> assignJobToSlave</see>
public static bool DisconnectSlave(KIO.Slave slave)
{
return (bool) staticInterceptor.Invoke("disconnectSlave#", "disconnectSlave(KIO::Slave*)", typeof(bool), typeof(KIO.Slave), slave);
}
public int MessageBox(string text, KIO.SlaveBase.MessageBoxType type, string caption, string buttonYes)
{
return (int) interceptor.Invoke("messageBox$$$$", "messageBox(const QString&, KIO::SlaveBase::MessageBoxType, const QString&, const QString&)", typeof(int), typeof(string), text, typeof(KIO.SlaveBase.MessageBoxType), type, typeof(string), caption, typeof(string), buttonYes);
}
/// <remarks>
/// Called when a job is done.
/// <param> name="job" the finished job
/// </param><param> name="slave" the slave that executed the <code>job</code>
/// </param></remarks> <short> Called when a job is done.</short>
public static void JobFinished(KIO.SimpleJob job, KIO.Slave slave)
{
staticInterceptor.Invoke("jobFinished##", "jobFinished(KIO::SimpleJob*, KIO::Slave*)", typeof(void), typeof(KIO.SimpleJob), job, typeof(KIO.Slave), slave);
}
public int MessageBox(string text, KIO.SlaveBase.MessageBoxType type)
{
return (int) interceptor.Invoke("messageBox$$", "messageBox(const QString&, KIO::SlaveBase::MessageBoxType)", typeof(int), typeof(string), text, typeof(KIO.SlaveBase.MessageBoxType), type);
}
/// <remarks>
/// Calling ths function makes that <code>job</code> gets scheduled for later
/// execution, if multiple jobs are registered it might wait for
/// other jobs to finish.
/// <param> name="job" the job to schedule
/// </param></remarks> <short> Calling ths function makes that <code>job</code> gets scheduled for later execution, if multiple jobs are registered it might wait for other jobs to finish.</short>
public static void ScheduleJob(KIO.SimpleJob job)
{
staticInterceptor.Invoke("scheduleJob#", "scheduleJob(KIO::SimpleJob*)", typeof(void), typeof(KIO.SimpleJob), job);
}
/// <remarks>
/// Prompt the user for Authorization info (login & password).
/// Use this function to request authorization information from
/// the end user. You can also pass an error message which explains
/// why a previous authorization attempt failed. Here is a very
/// simple example:
/// <pre>
/// KIO.AuthInfo authInfo;
/// if ( openPasswordDialog( authInfo ) )
/// {
/// kDebug() << QLatin1String("User: "******"Password: "******"Not displayed here!") << endl;
/// }
/// </pre>
/// You can also preset some values like the username, caption or
/// comment as follows:
/// <pre>
/// KIO.AuthInfo authInfo;
/// authInfo.caption= "Acme Password Dialog";
/// authInfo.username= "******";
/// string errorMsg = "You entered an incorrect password.";
/// if ( openPasswordDialog( authInfo, errorMsg ) )
/// {
/// kDebug() << QLatin1String("User: "******"Password: "******"Not displayed here!") << endl;
/// }
/// </pre>
/// <b>Note:<> You should consider using checkCachedAuthentication() to
/// see if the password is available in kpasswdserver before calling
/// this function.
/// <b>Note:<> A call to this function can fail and return <code>false</code>,
/// if the UIServer could not be started for whatever reason.
/// <param> name="info" See AuthInfo.
/// </param><param> name="errorMsg" Error message to show
/// </param></remarks> <return> <code>true</code> if user clicks on "OK", <code>false</code> otherwsie.
/// </return>
/// <short> Prompt the user for Authorization info (login & password).</short>
/// <see> checkCachedAuthentication</see>
public bool OpenPasswordDialog(KIO.AuthInfo info, string errorMsg)
{
return (bool) interceptor.Invoke("openPasswordDialog#$", "openPasswordDialog(KIO::AuthInfo&, const QString&)", typeof(bool), typeof(KIO.AuthInfo), info, typeof(string), errorMsg);
}
protected virtual void SlotMetaData(KIO.MetaData _metaData)
{
interceptor.Invoke("slotMetaData#", "slotMetaData(const KIO::MetaData&)", typeof(void), typeof(KIO.MetaData), _metaData);
}
private void Write(RegisterIndex index, ushort value)
{
KIO.outpw(0x01CE, (ushort)index);
KIO.outpw(0x01CF, value);
}
