public virtual void Restore(KConfigGroup group)
{
interceptor.Invoke("restore#", "restore(KConfigGroup&)", typeof(void), typeof(KConfigGroup), group);
}
public KConfigGroup(KConfigGroup arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KConfigGroup#", "KConfigGroup(const KConfigGroup&)", typeof(void), typeof(KConfigGroup), arg1);
}
/// <remarks>
/// Called to create a ServiceJob which is associated with a given
/// operation and parameter set.
/// </remarks> <return> a started ServiceJob; the consumer may connect to relevant
/// signals before returning to the event loop
/// </return>
/// <short> Called to create a ServiceJob which is associated with a given operation and parameter set.</short>
public Plasma.ServiceJob StartOperationCall(KConfigGroup description, QObject parent)
{
return (Plasma.ServiceJob) interceptor.Invoke("startOperationCall##", "startOperationCall(const KConfigGroup&, QObject*)", typeof(Plasma.ServiceJob), typeof(KConfigGroup), description, typeof(QObject), parent);
}
public RunnerManager(KConfigGroup config)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("RunnerManager#", "RunnerManager(KConfigGroup&)", typeof(void), typeof(KConfigGroup), config);
}
/// <remarks>
/// Saves state information about this applet that will
/// be accessed when next instantiated in the restore(KConfigGroup&) method.
/// This method does not need to be reimplmented by Applet
/// subclasses, but can be useful for Applet specializations
/// (such as Containment) to do so.
/// Applet subclasses may instead want to reimplement saveState().
/// </remarks> <short> Saves state information about this applet that will be accessed when next instantiated in the restore(KConfigGroup&) method.</short>
public virtual void Save(KConfigGroup group)
{
applet.Save(group);
}
/// <remarks>
/// Read the toolbar settings from group <code>configGroup</code> in <code>config</code>
/// and apply them. Even default settings are re-applied if <code>force</code> is set.
/// </remarks> <short> Read the toolbar settings from group <code>configGroup</code> in <code>config</code> and apply them.</short>
public void ApplySettings(KConfigGroup cg, bool force)
{
interceptor.Invoke("applySettings#$", "applySettings(const KConfigGroup&, bool)", typeof(void), typeof(KConfigGroup), cg, typeof(bool), force);
}
/// <remarks>
/// Save the toolbar settings to group <code>configGroup</code> in <code>config.</code>
/// </remarks> <short> Save the toolbar settings to group <code>configGroup</code> in <code>config.</code></short>
public void SaveSettings(KConfigGroup cg)
{
interceptor.Invoke("saveSettings#", "saveSettings(KConfigGroup&)", typeof(void), typeof(KConfigGroup), cg);
}
public void WriteSettings(KConfigGroup config, bool writeDefaults)
{
interceptor.Invoke("writeSettings#$", "writeSettings(KConfigGroup*, bool) const", typeof(void), typeof(KConfigGroup), config, typeof(bool), writeDefaults);
}
public void WriteSettings(KConfigGroup config)
{
interceptor.Invoke("writeSettings#", "writeSettings(KConfigGroup*) const", typeof(void), typeof(KConfigGroup), config);
}
/// <remarks>
/// Read all key associations from <code>config.</code>
/// If <code>config</code> is zero, read all key associations from the
/// application's configuration file KGlobal.Config(),
/// in the group set by setConfigGroup().
/// </remarks> <short> Read all key associations from <code>config.</code></short>
public void ReadSettings(KConfigGroup config)
{
interceptor.Invoke("readSettings#", "readSettings(KConfigGroup*)", typeof(void), typeof(KConfigGroup), config);
}
/// <remarks>
/// Write the current configurable key associations to <b>config</b>. What the
/// function does if <b>config</b> is zero depends. If this action collection
/// belongs to a KXMLGuiClient the setting are saved to the kxmlgui
/// definition file. If not the settings are written to the applications
/// config file.
/// <b>Note:<> oneAction() and writeDefaults() have no meaning for the kxmlgui
/// configuration file.
/// \param config Config object to save to, or null (see above)
/// \param writeDefaults set to true to write settings which are already at defaults.
/// \param oneAction pass an action here if you just want to save the values for one action, eg.
/// if you know that action is the only one which has changed.
/// </remarks> <short> Write the current configurable key associations to <b>config</b>.</short>
public void WriteSettings(KConfigGroup config, bool writeDefaults, QAction oneAction)
{
interceptor.Invoke("writeSettings#$#", "writeSettings(KConfigGroup*, bool, QAction*) const", typeof(void), typeof(KConfigGroup), config, typeof(bool), writeDefaults, typeof(QAction), oneAction);
}
/// <remarks>
/// Import from <code>config</code> all configurable global key associations.
/// \since 4.1
/// \param config Config object to read from
/// </remarks> <short> Import from <code>config</code> all configurable global key associations.</short>
public void ImportGlobalShortcuts(KConfigGroup config)
{
interceptor.Invoke("importGlobalShortcuts#", "importGlobalShortcuts(KConfigGroup*)", typeof(void), typeof(KConfigGroup), config);
}
public void ExportGlobalShortcuts(KConfigGroup config)
{
interceptor.Invoke("exportGlobalShortcuts#", "exportGlobalShortcuts(KConfigGroup*) const", typeof(void), typeof(KConfigGroup), config);
}
/// <remarks>
/// Export the current configurable global key associations to <code>config.</code>
/// \since 4.1
/// \param config Config object to save to
/// \param writeDefaults set to true to write settings which are already at defaults.
/// </remarks> <short> Export the current configurable global key associations to <code>config.</code></short>
public void ExportGlobalShortcuts(KConfigGroup config, bool writeDefaults)
{
interceptor.Invoke("exportGlobalShortcuts#$", "exportGlobalShortcuts(KConfigGroup*, bool) const", typeof(void), typeof(KConfigGroup), config, typeof(bool), writeDefaults);
}
public virtual void Save(KConfigGroup config)
{
interceptor.Invoke("save#", "save(KConfigGroup&)", typeof(void), typeof(KConfigGroup), config);
}
public override void ApplyMainWindowSettings(KConfigGroup config, bool force)
{
interceptor.Invoke("applyMainWindowSettings#$", "applyMainWindowSettings(const KConfigGroup&, bool)", typeof(void), typeof(KConfigGroup), config, typeof(bool), force);
}
protected virtual void Init(KConfigGroup config)
{
interceptor.Invoke("init#", "init(const KConfigGroup&)", typeof(void), typeof(KConfigGroup), config);
}
public override void ApplyMainWindowSettings(KConfigGroup config)
{
interceptor.Invoke("applyMainWindowSettings#", "applyMainWindowSettings(const KConfigGroup&)", typeof(void), typeof(KConfigGroup), config);
}
public void ApplySettings(KConfigGroup cg)
{
interceptor.Invoke("applySettings#", "applySettings(const KConfigGroup&)", typeof(void), typeof(KConfigGroup), cg);
}
/// <remarks>
/// Write the current settings to the <pre>config</pre> object.
/// This does not initialize the <pre>config</pre> object. It adds the
/// configuration.
/// @note this will not save the global configuration! globalaccel holds
/// that part of the configuration.
/// <param> name="config" Config object to save to or, or null to use the
/// applications config object
/// </param> </remarks> <short> Write the current settings to the \p config object.</short>
/// <see> writeGlobalConfig</see>
public void WriteConfiguration(KConfigGroup config)
{
interceptor.Invoke("writeConfiguration#", "writeConfiguration(KConfigGroup*) const", typeof(void), typeof(KConfigGroup), config);
}
public RunnerManager(KConfigGroup config, QObject parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("RunnerManager##", "RunnerManager(KConfigGroup&, QObject*)", typeof(void), typeof(KConfigGroup), config, typeof(QObject), parent);
}
/// <remarks>
/// Saves the current recent files entries to a given KConfigGroup object.
/// You can provide the name of the group used to load the entries.
/// If the groupname is empty, entries are saved to a group called 'RecentFiles'
/// </remarks> <short> Saves the current recent files entries to a given KConfigGroup object.</short>
public void SaveEntries(KConfigGroup config)
{
interceptor.Invoke("saveEntries#", "saveEntries(const KConfigGroup&)", typeof(void), typeof(KConfigGroup), config);
}
/// <remarks>
/// Restores state information about this applet saved previously
/// in save(KConfigGroup&).
/// This method does not need to be reimplmented by Applet
/// subclasses, but can be useful for Applet specializations
/// (such as Containment) to do so.
/// </remarks> <short> Restores state information about this applet saved previously in save(KConfigGroup&).</short>
public virtual void Restore(KConfigGroup group)
{
applet.Restore(group);
}
public virtual void InitWallpaper(KConfigGroup config)
{
interceptor.Invoke("initWallpaper#", "initWallpaper(const KConfigGroup&)", typeof(void), typeof(KConfigGroup), config);
}
/// <remarks>
/// When called, the Applet should write any information needed as part
/// of the Applet's running state to the configuration object in config()
/// and/or globalConfig().
/// Applets that always sync their settings/state with the config
/// objects when these settings/states change do not need to reimplement
/// this method.
/// </remarks> <short> When called, the Applet should write any information needed as part of the Applet's running state to the configuration object in config() and/or globalConfig().</short>
protected virtual void SaveState(KConfigGroup config)
{
}
public Browser(string name)
: base((QWidget) null)
{
ObjectName = name;
SetCaption("KDE Tutorial - p9");
QMenu filemenu = new QMenu(KDE.I18n("&File"), this);
KAction setDefaultPageAction = new KAction(this);
setDefaultPageAction.Text = KDE.I18n("&Set default page");
ActionCollection().AddAction("set_default_page", setDefaultPageAction);
Connect( setDefaultPageAction, SIGNAL("triggered(bool)"),
this, SLOT("FileSetDefaultPage()") );
addBookmarkAction = KStandardAction.AddBookmark(this, SLOT("BookLocation()"), ActionCollection());
backAction = KStandardAction.Back(this, SLOT("GotoPreviousPage()"), ActionCollection());
backAction.Enabled = false;
quitAction = KStandardAction.Quit(KApplication.kApplication(), SLOT("quit()"), ActionCollection());
string about = KDE.I18n("p9 1.0\n\n" +
"(C) 1999-2002 Antonio Larrosa Jimenez\n" +
"[email protected]\t\[email protected]\n" +
"Malaga (Spain)\n\n" +
"Simple KDE Tutorial\n" +
"This tutorial comes with ABSOLUTELY NO WARRANTY\n" +
"This is free software, and you are welcome to redistribute it\n" +
"under certain conditions\n");
QMenu helpmenu = HelpMenu(about);
KMenuBar menu = MenuBar();
menu.AddMenu(filemenu);
menu.AddSeparator();
menu.AddMenu(helpmenu);
ToolBar().AddAction(quitAction);
ToolBar().AddAction(addBookmarkAction);
ToolBar().AddAction(backAction);
StandardToolBarMenuEnabled = true;
location = new QLineEdit();
config = new KConfigGroup(KGlobal.Config(), "Settings");
location.Text = config.ReadEntry("defaultPage", "http://localhost");
Connect(location, SIGNAL("returnPressed()"), this, SLOT("ChangeLocation()"));
QSplitter split = new QSplitter();
split.OpaqueResize = true;
QWidget widget = new QWidget(this);
QVBoxLayout vbox = new QVBoxLayout(widget);
vbox.AddWidget(location);
vbox.AddWidget(split);
browser = new KHTMLPart(split);
browser.OpenUrl(new KUrl(location.Text));
Connect( browser.BrowserExtension(),
SIGNAL("openUrlRequest(KUrl, KParts::OpenUrlArguments)"),
this, SLOT("OpenUrlRequest(KUrl, KParts::OpenUrlArguments)") );
SetCentralWidget(widget);
SetupGUI();
}
/// <remarks>
/// </remarks> <return> a parameter map for the given description
/// @arg description the configuration values to turn into the parameter map
/// </return>
/// <short> </short>
public Dictionary<string, QVariant> ParametersFromDescription(KConfigGroup description)
{
return (Dictionary<string, QVariant>) interceptor.Invoke("parametersFromDescription#", "parametersFromDescription(const KConfigGroup&)", typeof(Dictionary<string, QVariant>), typeof(KConfigGroup), description);
}
/// <remarks>
/// This method should be called once the plugin is loaded or settings are changed.
/// <param> name="config" Config group to load settings
/// </param></remarks> <short> This method should be called once the plugin is loaded or settings are changed.</short>
/// <see> init</see>
public void Restore(KConfigGroup config)
{
interceptor.Invoke("restore#", "restore(const KConfigGroup&)", typeof(void), typeof(KConfigGroup), config);
}
public Plasma.ServiceJob StartOperationCall(KConfigGroup description)
{
return (Plasma.ServiceJob) interceptor.Invoke("startOperationCall#", "startOperationCall(const KConfigGroup&)", typeof(Plasma.ServiceJob), typeof(KConfigGroup), description);
}
protected virtual void SaveState(KConfigGroup config)
{
interceptor.Invoke("saveState#", "saveState(KConfigGroup&) const", typeof(void), typeof(KConfigGroup), config);
}
