Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 306 insertions, 0 deletions

diff --git a/src/extension/prefdialog/parameter.cpp b/src/extension/prefdialog/parameter.cpp
new file mode 100644
index 0000000..b8d8386
--- /dev/null
+++ b/src/extension/prefdialog/parameter.cpp
@@ -0,0 +1,306 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * Parameters for extensions.
+ */
+/* Author:
+ *   Ted Gould <ted@gould.cx>
+ *   Johan Engelen <johan@shouraizou.nl>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2005-2007 Authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cstring>
+#include <list>
+
+#include <glibmm/i18n.h>
+#include <sigc++/sigc++.h>
+
+#include "parameter.h"
+#include "parameter-bool.h"
+#include "parameter-color.h"
+#include "parameter-float.h"
+#include "parameter-int.h"
+#include "parameter-notebook.h"
+#include "parameter-optiongroup.h"
+#include "parameter-path.h"
+#include "parameter-string.h"
+#include "widget.h"
+#include "widget-label.h"
+
+#include "extension/extension.h"
+
+#include "object/sp-defs.h"
+
+#include "ui/widget/color-notebook.h"
+
+#include "xml/node.h"
+
+
+namespace Inkscape {
+namespace Extension {
+
+
+// Re-implement ParamDescription for backwards-compatibility, deriving from both, WidgetLabel and InxParameter.
+// TODO: Should go away eventually...
+class ParamDescription : public virtual WidgetLabel, public virtual InxParameter {
+public:
+    ParamDescription(Inkscape::XML::Node *xml, Inkscape::Extension::Extension *ext)
+        : WidgetLabel(xml, ext)
+        , InxParameter(xml, ext)
+    {}
+
+    Gtk::Widget *get_widget(sigc::signal<void> *changeSignal) override
+    {
+        return this->WidgetLabel::get_widget(changeSignal);
+    }
+
+    // Well, no, I don't have a value! That's why I should not be an InxParameter!
+    std::string value_to_string() const override { return ""; }
+};
+
+
+
+InxParameter *InxParameter::make(Inkscape::XML::Node *in_repr, Inkscape::Extension::Extension *in_ext)
+{
+    InxParameter *param = nullptr;
+
+    try {
+        const char *type = in_repr->attribute("type");
+        if (!type) {
+            // we can't create a parameter without type
+            g_warning("Parameter without type in extension '%s'.", in_ext->get_id());
+        } else if(!strcmp(type, "bool") || !strcmp(type, "boolean")) { // support "boolean" for backwards-compatibility
+            param = new ParamBool(in_repr, in_ext);
+        } else if (!strcmp(type, "int")) {
+            param = new ParamInt(in_repr, in_ext);
+        } else if (!strcmp(type, "float")) {
+            param = new ParamFloat(in_repr, in_ext);
+        } else if (!strcmp(type, "string")) {
+            param = new ParamString(in_repr, in_ext);
+        } else if (!strcmp(type, "path")) {
+            param = new ParamPath(in_repr, in_ext);
+        } else if (!strcmp(type, "description")) {
+            // support deprecated "description" for backwards-compatibility
+            in_repr->setAttribute("gui-text", "description"); // TODO: hack to allow descriptions to be parameters
+            param = new ParamDescription(in_repr, in_ext);
+        } else if (!strcmp(type, "notebook")) {
+            in_repr->setAttribute("gui-text", "notebook"); // notebooks have no 'gui-text' (but Parameters need one)
+            param = new ParamNotebook(in_repr, in_ext);
+        } else if (!strcmp(type, "optiongroup")) {
+            param = new ParamOptionGroup(in_repr, in_ext);
+        } else if (!strcmp(type, "enum")) { // support deprecated "enum" for backwards-compatibility
+            in_repr->setAttribute("appearance", "combo");
+            param = new ParamOptionGroup(in_repr, in_ext);
+        } else if (!strcmp(type, "color")) {
+            param = new ParamColor(in_repr, in_ext);
+        } else {
+            g_warning("Unknown parameter type ('%s') in extension '%s'", type, in_ext->get_id());
+        }
+    } catch (const param_no_name&) {
+    } catch (const param_no_text&) {
+    }
+
+    // Note: param could equal nullptr
+    return param;
+}
+
+bool InxParameter::get_bool() const
+{
+    ParamBool const *boolpntr = dynamic_cast<ParamBool const *>(this);
+    if (!boolpntr) {
+        throw param_not_bool_param();
+    }
+    return boolpntr->get();
+}
+
+int InxParameter::get_int() const
+{
+    ParamInt const *intpntr = dynamic_cast<ParamInt const *>(this);
+    if (!intpntr) {
+        // This allows option groups to contain integers. Consider just using this.
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        return prefs->getInt(this->pref_name());
+    }
+    return intpntr->get();
+}
+
+double InxParameter::get_float() const
+{
+    ParamFloat const *floatpntr = dynamic_cast<ParamFloat const *>(this);
+    if (!floatpntr) {
+        throw param_not_float_param();
+    }
+    return floatpntr->get();
+}
+
+const char *InxParameter::get_string() const
+{
+    ParamString const *stringpntr = dynamic_cast<ParamString const *>(this);
+    if (!stringpntr) {
+        throw param_not_string_param();
+    }
+    return stringpntr->get().c_str();
+}
+
+const char *InxParameter::get_optiongroup() const
+{
+    ParamOptionGroup const *param = dynamic_cast<ParamOptionGroup const *>(this);
+    if (!param) {
+        throw param_not_optiongroup_param();
+    }
+    return param->get().c_str();
+}
+
+bool InxParameter::get_optiongroup_contains(const char *value) const
+{
+    ParamOptionGroup const *param = dynamic_cast<ParamOptionGroup const *>(this);
+    if (!param) {
+        throw param_not_optiongroup_param();
+    }
+    return param->contains(value);
+}
+
+unsigned int InxParameter::get_color() const
+{
+    ParamColor const *param = dynamic_cast<ParamColor const *>(this);
+    if (!param) {
+        throw param_not_color_param();
+    }
+    return param->get();
+}
+
+bool InxParameter::set_bool(bool in)
+{
+    ParamBool * boolpntr = dynamic_cast<ParamBool *>(this);
+    if (boolpntr == nullptr)
+        throw param_not_bool_param();
+    return boolpntr->set(in);
+}
+
+int InxParameter::set_int(int in)
+{
+    ParamInt *intpntr = dynamic_cast<ParamInt *>(this);
+    if (intpntr == nullptr)
+        throw param_not_int_param();
+    return intpntr->set(in);
+}
+
+double InxParameter::set_float(double in)
+{
+    ParamFloat * floatpntr;
+    floatpntr = dynamic_cast<ParamFloat *>(this);
+    if (floatpntr == nullptr)
+        throw param_not_float_param();
+    return floatpntr->set(in);
+}
+
+const char *InxParameter::set_string(const char *in)
+{
+    ParamString * stringpntr = dynamic_cast<ParamString *>(this);
+    if (stringpntr == nullptr)
+        throw param_not_string_param();
+    return stringpntr->set(in).c_str();
+}
+
+const char *InxParameter::set_optiongroup(const char *in)
+{
+    ParamOptionGroup *param = dynamic_cast<ParamOptionGroup *>(this);
+    if (!param) {
+        throw param_not_optiongroup_param();
+    }
+    return param->set(in).c_str();
+}
+
+unsigned int InxParameter::set_color(unsigned int in)
+{
+    ParamColor*param = dynamic_cast<ParamColor *>(this);
+    if (param == nullptr)
+        throw param_not_color_param();
+    return param->set(in);
+}
+
+
+InxParameter::InxParameter(Inkscape::XML::Node *in_repr, Inkscape::Extension::Extension *ext)
+    : InxWidget(in_repr, ext)
+{
+    // name (mandatory for all parameters)
+    const char *name = in_repr->attribute("name");
+    if (name) {
+        _name = g_strstrip(g_strdup(name));
+    }
+    if (!_name || !strcmp(_name, "")) {
+        g_warning("Parameter without name in extension '%s'.", _extension->get_id());
+        throw param_no_name();
+    }
+
+    // gui-text
+    const char *gui_text = in_repr->attribute("gui-text");
+    if (!gui_text) {
+        gui_text = in_repr->attribute("_gui-text"); // backwards-compatibility with underscored variants
+    }
+    if (gui_text) {
+        if (_translatable != NO) { // translate unless explicitly marked untranslatable
+            gui_text = get_translation(gui_text);
+        }
+        _text = g_strdup(gui_text);
+    }
+    if (!_text && !_hidden) {
+        g_warning("Parameter '%s' in extension '%s' is visible but does not have a 'gui-text'.",
+                  _name, _extension->get_id());
+        throw param_no_text();
+    }
+
+    // gui-description (optional)
+    const char *gui_description = in_repr->attribute("gui-description");
+    if (!gui_description) {
+        gui_description = in_repr->attribute("_gui-description"); // backwards-compatibility with underscored variants
+    }
+    if (gui_description) {
+        if (_translatable != NO) { // translate unless explicitly marked untranslatable
+            gui_description = get_translation(gui_description);
+        }
+        _description = g_strdup(gui_description);
+    }
+}
+
+InxParameter::~InxParameter()
+{
+    g_free(_name);
+    _name = nullptr;
+
+    g_free(_text);
+    _text = nullptr;
+
+    g_free(_description);
+    _description = nullptr;
+}
+
+Glib::ustring InxParameter::pref_name() const
+{
+    return Glib::ustring::compose("/extensions/%1.%2", _extension->get_id(), _name);
+}
+
+std::string InxParameter::value_to_string() const
+{
+    // if we end up here we're missing a definition of ::string() in one of the subclasses
+    g_critical("InxParameter::value_to_string called from parameter '%s' in extension '%s'", _name, _extension->get_id());
+    g_assert_not_reached();
+    return "";
+}
+
+}  // namespace Extension
+}  // namespace Inkscape
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :