From: johanengelen Date: Mon, 18 Sep 2006 23:44:37 +0000 (+0000) Subject: Added support for enumerated types in the UI of Extensions! (all eyes on requester... X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=61e2dc476914e19f2789d32f920086419edc124b;p=inkscape.git Added support for enumerated types in the UI of Extensions! (all eyes on requester Spike to submit an example extension ! :P) --- diff --git a/src/extension/Makefile_insert b/src/extension/Makefile_insert index 644eb82c5..9540d863d 100644 --- a/src/extension/Makefile_insert +++ b/src/extension/Makefile_insert @@ -21,6 +21,8 @@ extension_libextension_a_SOURCES = \ extension/parameter.cpp \ extension/paramnotebook.h \ extension/paramnotebook.cpp \ + extension/paramenum.h \ + extension/paramenum.cpp \ extension/prefdialog.cpp \ extension/prefdialog.h \ extension/system.cpp \ diff --git a/src/extension/paramenum.cpp b/src/extension/paramenum.cpp new file mode 100644 index 000000000..85656343d --- /dev/null +++ b/src/extension/paramenum.cpp @@ -0,0 +1,218 @@ +/** \file + * extension parameter for enumerations. + * + * It uses a Gtk:ComboBoxText widget in the extension UI. + */ + +/* + * Author: + * Johan Engelen + * + * Copyright (C) 2006 Author + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + + +#include +#include +#include +#include + +#include + +#include + +#include "extension.h" +#include "prefs-utils.h" +#include "document-private.h" +#include "sp-object.h" + +#include "paramenum.h" + +/** \brief The root directory in the preferences database for extension + related parameters. */ +#define PREF_DIR "extensions" + +namespace Inkscape { +namespace Extension { + +ParamComboBox::ParamComboBox (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, ext) +{ + choices = NULL; + _value = NULL; + + // Read XML tree to add enumeration items: + // printf("Extension Constructor: "); + if (xml != NULL) { + Inkscape::XML::Node *child_repr = sp_repr_children(xml); + while (child_repr != NULL) { + char const * chname = child_repr->name(); + if (!strcmp(chname, "item")) { + Glib::ustring * newitem = NULL; + const char * contents = sp_repr_children(child_repr)->content(); + if (contents != NULL) + newitem = new Glib::ustring(contents); + if (newitem != NULL) choices = g_slist_append(choices, newitem); + } + child_repr = sp_repr_next(child_repr); + } + } + + // Initialize _value with the default value from xml + // for simplicity : default to the contents of the first xml-child + const char * defaultval = NULL; + if (sp_repr_children(sp_repr_children(xml)) != NULL) + defaultval = sp_repr_children(sp_repr_children(xml))->content(); + + gchar * pref_name = this->pref_name(); + const gchar * paramval = prefs_get_string_attribute(PREF_DIR, pref_name); + g_free(pref_name); + + if (paramval != NULL) + defaultval = paramval; + if (defaultval != NULL) + _value = g_strdup(defaultval); // allocate space for _value + + return; +} + +ParamComboBox::~ParamComboBox (void) +{ + //destroy choice strings + for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { + Glib::ustring * text = reinterpret_cast(list->data); + delete text; + } + g_slist_free(choices); + + g_free(_value); +} + + +/** \brief A function to set the \c _value + \param in The value to set + \param doc A document that should be used to set the value. + \param node The node where the value may be placed + + This function sets ONLY the internal value, but it also sets the value + in the preferences structure. To put it in the right place, \c PREF_DIR + and \c pref_name() are used. + + To copy the data into _value the old memory must be free'd first. + It is important to note that \c g_free handles \c NULL just fine. Then + the passed in value is duplicated using \c g_strdup(). +*/ +const gchar * +ParamComboBox::set (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node) +{ + if (in == NULL) return NULL; /* Can't have NULL string */ + + if (_value != NULL) + g_free(_value); + _value = g_strdup(in); + + gchar * prefname = this->pref_name(); + prefs_set_string_attribute(PREF_DIR, prefname, _value); + g_free(prefname); + + return _value; +} + + +/** + \brief A function to get the currentpage and the parameters in a string form + \return A string with the 'value' and all the parameters on all pages as command line arguments +*/ +Glib::ustring * +ParamComboBox::string (void) +{ + Glib::ustring * param_string = new Glib::ustring(""); + + *param_string += "\""; + *param_string += _value; + *param_string += "\""; + + return param_string; +} + +/** \brief A special category of Gtk::Entry to handle string parameteres */ +class ParamComboBoxEntry : public Gtk::ComboBoxText { +private: + ParamComboBox * _pref; + SPDocument * _doc; + Inkscape::XML::Node * _node; +public: + /** \brief Build a string preference for the given parameter + \param pref Where to get the string from, and where to put it + when it changes. + */ + ParamComboBoxEntry (ParamComboBox * pref, SPDocument * doc, Inkscape::XML::Node * node) : + Gtk::ComboBoxText(), _pref(pref), _doc(doc), _node(node) { + this->signal_changed().connect(sigc::mem_fun(this, &ParamComboBoxEntry::changed)); + }; + void changed (void); +}; + +/** \brief Respond to the text box changing + + This function responds to the box changing by grabbing the value + from the text box and putting it in the parameter. +*/ +void +ParamComboBoxEntry::changed (void) +{ + Glib::ustring data = this->get_active_text(); + _pref->set(data.c_str(), _doc, _node); + return; +} + + + +/** + \brief Creates a combobox widget for an enumeration parameter +*/ +Gtk::Widget * +ParamComboBox::get_widget (SPDocument * doc, Inkscape::XML::Node * node) +{ + Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); + + Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_LEFT)); + label->show(); + hbox->pack_start(*label, false, false); + + ParamComboBoxEntry * combo = Gtk::manage(new ParamComboBoxEntry(this, doc, node)); + // add choice strings: + for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { + Glib::ustring * text = reinterpret_cast(list->data); + combo->append_text(*text); + } + combo->set_active_text(Glib::ustring(_value)); + + combo->show(); + hbox->pack_start(*combo, true, true); + + hbox->show(); + + return dynamic_cast(hbox); +} + + +} /* 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 : diff --git a/src/extension/paramenum.h b/src/extension/paramenum.h new file mode 100644 index 000000000..3c21c4065 --- /dev/null +++ b/src/extension/paramenum.h @@ -0,0 +1,67 @@ +#ifndef __INK_EXTENSION_PARAMENUM_H__ +#define __INK_EXTENSION_PARAMENUM_H__ + +/** \file + * Enumeration parameter for extensions. + */ + +/* + * Author: + * Johan Engelen + * + * Copyright (C) 2006 Author + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include + +#include "xml/document.h" +#include "extension-forward.h" + +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + + + +// \brief A class to represent a notebookparameter of an extension +class ParamComboBox : public Parameter { +private: + /** \brief Internal value. This should point to a string that has + been allocated in memory. And should be free'd. + It is the value of the current selected string */ + gchar * _value; + + GSList * choices; /**< A table to store the choice strings */ + +public: + ParamComboBox(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + ~ParamComboBox(void); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node); + Glib::ustring * string (void); + + const gchar * get (const SPDocument * doc, const Inkscape::XML::Node * node) { return _value; } + const gchar * set (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node); +}; /* class ParamComboBox */ + + + + + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* __INK_EXTENSION_PARAMENUM_H__ */ + +/* + 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 : diff --git a/src/extension/parameter.cpp b/src/extension/parameter.cpp index a821a626d..70f66c416 100644 --- a/src/extension/parameter.cpp +++ b/src/extension/parameter.cpp @@ -32,6 +32,7 @@ #include "parameter.h" #include "paramnotebook.h" +#include "paramenum.h" /** \brief The root directory in the preferences database for extension related parameters. */ @@ -312,7 +313,7 @@ Parameter::make (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * } else if (!strcmp(type, "description")) { param = new ParamDescription(name, guitext, desc, scope, in_ext, in_repr); } else if (!strcmp(type, "enum")) { - param = new ParamEnum(name, guitext, desc, scope, in_ext, in_repr); + param = new ParamComboBox(name, guitext, desc, scope, in_ext, in_repr); } else if (!strcmp(type, "notebook")) { param = new ParamNotebook(name, guitext, desc, scope, in_ext, in_repr); }