Пример #1
0
 /// <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);
 }
Пример #2
0
 /// <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);
 }
Пример #3
0
 /// <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);
 }
Пример #4
0
 /// <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);
 }
Пример #5
0
 /// <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);
 }
Пример #6
0
 /// <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);
 }
Пример #7
0
 public KConfigSkeleton(KSharedConfig config)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("KConfigSkeleton?", "KConfigSkeleton(KSharedPtr<KSharedConfig>)", typeof(void), typeof(KSharedConfig), config);
 }
Пример #8
0
    //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();
        }
    }
Пример #9
0
 /// <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);
 }
Пример #10
0
 /// <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);
 }
Пример #11
0
    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);
        }
    }
Пример #12
0
    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"));
    }
Пример #13
0
    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();
    }
Пример #14
0
 /// <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);
 }
Пример #15
0
 /// <remarks>
 ///  Add a list of KParts plugins
 ///  The information about the plugins will be loaded from the
 ///  share/apps/&lt;instancename&gt;/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);
 }
Пример #16
0
 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);
 }
Пример #17
0
 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);
 }