/// <remarks>
/// Construct a stateful foreground/decoration brush from a specified
/// QBrush (or QColor, via QBrush's implicit constructor). The various
/// states are determined from the base QBrush (which fills in the Active
/// state) according to the same rules used to build stateful color schemes
/// from the system color scheme. The state effects from the given KConfig
/// are used (if null, the system state effects are used).
/// <param> name="background" The background brush (or color) corresponding to the
/// KColorScheme.NormalBackground role and QPalette.Active state for this
/// foreground/decoration color.
/// </param></remarks> <short> Construct a stateful foreground/decoration brush from a specified QBrush (or QColor, via QBrush's implicit constructor).</short>
public KStatefulBrush(QBrush arg1, QBrush background, KSharedConfig arg3)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KStatefulBrush##?", "KStatefulBrush(const QBrush&, const QBrush&, KSharedPtr<KSharedConfig>)", typeof(void), typeof(QBrush), arg1, typeof(QBrush), background, typeof(KSharedConfig), arg3);
}
/// <remarks>
/// Construct a stateful brush from given color set and decoration role,
/// using the colors from the given KConfig (if null, the system colors are
/// used).
/// </remarks> <short> Construct a stateful brush from given color set and decoration role, using the colors from the given KConfig (if null, the system colors are used).</short>
public KStatefulBrush(KColorScheme.ColorSet arg1, KColorScheme.DecorationRole arg2, KSharedConfig arg3)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KStatefulBrush$$?", "KStatefulBrush(KColorScheme::ColorSet, KColorScheme::DecorationRole, KSharedPtr<KSharedConfig>)", typeof(void), typeof(KColorScheme.ColorSet), arg1, typeof(KColorScheme.DecorationRole), arg2, typeof(KSharedConfig), arg3);
}
/// <remarks>
/// Returns the contrast for borders as a floating point value.
/// <param> name="config" pointer to the config from which to read the contrast
/// setting (the default is to use KGlobal.Config())
/// </param></remarks> <return> the contrast (between 0.0 for minimum and 1.0 for maximum
/// contrast)
/// </return>
/// <short> Returns the contrast for borders as a floating point value.</short>
public static double ContrastF(KSharedConfig config)
{
return (double) staticInterceptor.Invoke("contrastF?", "contrastF(const KSharedPtr<KSharedConfig>&)", typeof(double), typeof(KSharedConfig), config);
}
/// <remarks>
/// Used to obtain the QPalette that will be used to set the application palette.
/// This is only useful for configuration modules such as krdb and should not be
/// used in normal circumstances.
/// <param> name="config" KConfig from which to load the colors (passed as-is to
/// .KColorScheme).
/// </param></remarks> <return> the QPalette
/// </return>
/// <short> Used to obtain the QPalette that will be used to set the application palette.</short>
public static QPalette CreateApplicationPalette(KSharedConfig config)
{
return (QPalette) staticInterceptor.Invoke("createApplicationPalette?", "createApplicationPalette(const KSharedPtr<KSharedConfig>&)", typeof(QPalette), typeof(KSharedConfig), config);
}
/// <remarks>
/// Add a list of KParts plugins. Convenience method for the one above.
/// If not set explicitly, <code>config</code> is set to componentData.config()
/// </remarks> <short> Add a list of KParts plugins.</short>
public void AddPlugins(KComponentData instance, string categoryName, string categoryKey, KSharedConfig config)
{
interceptor.Invoke("addPlugins#$$?", "addPlugins(const KComponentData&, const QString&, const QString&, const KSharedPtr<KSharedConfig>&)", typeof(void), typeof(KComponentData), instance, typeof(string), categoryName, typeof(string), categoryKey, typeof(KSharedConfig), config);
}
/// <remarks>
/// Add a list of non-KParts plugins
/// <param> name="pluginInfoList" A list of KPluginInfo objects containing the
/// necessary information for the plugins you want to
/// add to the list
/// </param><param> name="pluginLoadMethod" If KPluginSelector will try to load the
/// state of the plugin when loading the
/// dialog from the configuration file or not.
/// This is useful if for some reason you
/// called the setPluginEnabled() for each plugin
/// individually before loading the dialog, and
/// don't want KPluginSelector to override them
/// when loading
/// </param><param> name="categoryName" The translated name of the category. This is the
/// name that is shown in the title. If the category
/// did exist before because of another call to
/// addPlugins, then they will be shown in that
/// category. If <code>categoryName</code> is a new one, then
/// a new category will be shown on the plugin window,
/// and the list of plugins added to it
/// </param><param> name="categoryKey" When you have different categories of KParts
/// plugins you distinguish between the plugins using
/// the Category key in the .desktop file. Use this
/// parameter to select only those KParts plugins
/// with the Category key == <code>categoryKey.</code> If
/// <code>categoryKey</code> is not set the Category key is
/// ignored and all plugins are shown. Not match case
/// </param><param> name="config" The KConfig object that holds the state of the
/// plugins being enabled or not. By default it will
/// use KGlobal.Config(). It is recommended to
/// always pass a KConfig object if you use
/// KSettings.PluginPage since you never know from
/// where the page will be called (think global
/// config app). For example KViewCanvas passes
/// KConfig("kviewcanvas")
/// </param> @note All plugins that were set a config group using setConfig() method
/// will load and save their information from there. For those that
/// weren't any config object, <code>config</code> will be used
/// </remarks> <short> Add a list of non-KParts plugins </short>
public void AddPlugins(List<KPluginInfo> pluginInfoList, KPluginSelector.PluginLoadMethod pluginLoadMethod, string categoryName, string categoryKey, KSharedConfig config)
{
interceptor.Invoke("addPlugins?$$$?", "addPlugins(const QList<KPluginInfo>&, KPluginSelector::PluginLoadMethod, const QString&, const QString&, const KSharedPtr<KSharedConfig>&)", typeof(void), typeof(List<KPluginInfo>), pluginInfoList, typeof(KPluginSelector.PluginLoadMethod), pluginLoadMethod, typeof(string), categoryName, typeof(string), categoryKey, typeof(KSharedConfig), config);
}
public KConfigSkeleton(KSharedConfig config)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KConfigSkeleton?", "KConfigSkeleton(KSharedPtr<KSharedConfig>)", typeof(void), typeof(KSharedConfig), config);
}
//common config
public void ReadConfig(KSharedConfig config)
{
KConfigGroup cfg = new KConfigGroup(config, "General Options");
m_showStatusBar.Checked = cfg.ReadEntry("ShowStatusBar", true);
m_showPath.Checked = cfg.ReadEntry("ShowPath", false);
m_recentFiles.LoadEntries(config.Group("Recent Files"));
m_view.Document().Editor().ReadConfig(config);
if (m_showStatusBar.Checked) {
StatusBar().Show();
} else {
StatusBar().Hide();
}
}
/// <remarks>
/// Set the <see cref="KSharedConfig"></see> object used for reading and writing the settings.
/// </remarks> <short> Set the @ref KSharedConfig object used for reading and writing the settings.</short>
public void SetSharedConfig(KSharedConfig pConfig)
{
interceptor.Invoke("setSharedConfig?", "setSharedConfig(KSharedPtr<KSharedConfig>)", typeof(void), typeof(KSharedConfig), pConfig);
}
/// <remarks>
/// Constructor.
/// <param> name="config" configuration object to use.
/// </param></remarks> <short> Constructor.</short>
public KConfigSkeleton(KSharedConfig config, QObject parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KConfigSkeleton?#", "KConfigSkeleton(KSharedPtr<KSharedConfig>, QObject*)", typeof(void), typeof(KSharedConfig), config, typeof(QObject), parent);
}
private void SaveProperties(KSharedConfig config)
{
WriteConfig(config);
KConfigGroup group = new KConfigGroup(config, "");
group.WriteEntry("DocumentNumber", docList.IndexOf(m_view.Document()) + 1);
KTextEditor.SessionConfigInterface iface = qobject_cast<KTextEditor.SessionConfigInterface>(m_view);
if (iface != null) {
KConfigGroup cg = new KConfigGroup( config, "General Options" );
iface.WriteSessionConfig(cg);
}
}
private void ReadProperties(KSharedConfig config)
{
ReadConfig(config);
KTextEditor.SessionConfigInterface iface = qobject_cast<KTextEditor.SessionConfigInterface>(m_view);
if (iface != null)
iface.ReadSessionConfig(new KConfigGroup(config, "General Options"));
}
public void WriteConfig(KSharedConfig config)
{
KConfigGroup generalOptions = new KConfigGroup(config, "General Options");
generalOptions.WriteEntry("ShowStatusBar", m_showStatusBar.Checked);
generalOptions.WriteEntry("ShowPath", m_showPath.Checked);
m_recentFiles.SaveEntries(new KConfigGroup(config, "Recent Files"));
// Writes into its own group
m_view.Document().Editor().WriteConfig(config);
config.Sync();
}
/// <remarks>
/// Constructs a KLocale with the given catalog name.
/// The constructor looks for an entry Locale/Language in the
/// configuration file.
/// If no config file is specified, it will also look for languages
/// using the environment variables (KDE_LANG, LC_MESSAGES, LC_ALL, LANG),
/// as well as the global configuration file. If KLocale is not able to use
/// any of the specified languages, the default language (en_US) will be
/// used.
/// If you specify a configuration file, it has to be valid until
/// the KLocale object is destroyed.
/// <param> name="catalog" The name of the main language file
/// </param><param> name="config" The configuration file to use.
/// </param></remarks> <short> Constructs a KLocale with the given catalog name.</short>
public KLocale(string catalog, KSharedConfig config)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KLocale$?", "KLocale(const QString&, KSharedPtr<KSharedConfig>)", typeof(void), typeof(string), catalog, typeof(KSharedConfig), config);
}
/// <remarks>
/// Add a list of KParts plugins
/// The information about the plugins will be loaded from the
/// share/apps/<instancename>/kpartplugins directory
/// <param> name="componentName" The name of the KComponentData of the plugin's parent.
/// </param><param> name="categoryName" The translated name of the category. This is the
/// name that is shown in the title. If the category
/// did exist before because of another call to
/// addPlugins, then they will be shown in that
/// category. If <code>categoryName</code> is a new one, then
/// a new category will be shown on the plugin window,
/// and the list of plugins added to it
/// </param><param> name="categoryKey" When you have different categories of KParts
/// plugins you distinguish between the plugins using
/// the Category key in the .desktop file. Use this
/// parameter to select only those KParts plugins
/// with the Category key == <code>categoryKey.</code> If
/// <code>categoryKey</code> is not set the Category key is
/// ignored and all plugins are shown. Not match case
/// </param><param> name="config" The KConfig object that holds the state of the
/// plugins being enabled or not. By default it should
/// be componentData.config(). It is recommended to
/// always pass a KConfig object if you use
/// KSettings.PluginPage since you never know from where the
/// page will be called (think global config app).
/// For example KViewCanvas passes KConfig(
/// "kviewcanvas" )
/// </param></remarks> <short> Add a list of KParts plugins </short>
public void AddPlugins(string componentName, string categoryName, string categoryKey, KSharedConfig config)
{
interceptor.Invoke("addPlugins$$$?", "addPlugins(const QString&, const QString&, const QString&, KSharedPtr<KSharedConfig>)", typeof(void), typeof(string), componentName, typeof(string), categoryName, typeof(string), categoryKey, typeof(KSharedConfig), config);
}
public KConfigGroup(KSharedConfig master, string group)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KConfigGroup?$", "KConfigGroup(const KSharedPtr<KSharedConfig>&, const QString&)", typeof(void), typeof(KSharedConfig), master, typeof(string), group);
}
public ConfigLoader(KSharedConfig config, QIODevice xml)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("ConfigLoader?#", "ConfigLoader(KSharedPtr<KSharedConfig>, QIODevice*)", typeof(void), typeof(KSharedConfig), config, typeof(QIODevice), xml);
}