From: gouldtj Date: Fri, 4 Apr 2008 04:55:24 +0000 (+0000) Subject: r18381@shi: ted | 2008-03-07 20:11:34 -0800 X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=f1ec1be29a388dbf184f6190302a357fe67070ac;p=inkscape.git r18381@shi: ted | 2008-03-07 20:11:34 -0800 New work branch r18391@shi: ted | 2008-03-08 21:36:03 -0800 Moving the parameters around to clean up the directories. r18392@shi: ted | 2008-03-08 21:57:14 -0800 Moving the 'get' function to cpp r18870@shi: ted | 2008-04-03 21:10:20 -0700 Adding in to the parameter prototype the ability to have a gui-tip and a gui-hidden parameter r18871@shi: ted | 2008-04-03 21:17:39 -0700 Using the _gui-hidden parameter to block the creation of the widget if set. r18890@shi: ted | 2008-04-03 21:53:55 -0700 Merge from r18024 which got lost in the shuffle. --- diff --git a/src/extension/Makefile_insert b/src/extension/Makefile_insert index 9c6cdd61f..bb0dc9cef 100644 --- a/src/extension/Makefile_insert +++ b/src/extension/Makefile_insert @@ -19,26 +19,26 @@ extension_libextension_a_SOURCES = \ extension/execution-env.h \ extension/init.cpp \ extension/init.h \ - extension/parameter.h \ - extension/parameter.cpp \ - extension/paramnotebook.h \ - extension/paramnotebook.cpp \ - extension/parambool.h \ - extension/parambool.cpp \ - extension/paramcolor.h \ - extension/paramcolor.cpp \ - extension/paramdescription.h \ - extension/paramdescription.cpp \ - extension/paramenum.h \ - extension/paramenum.cpp \ - extension/paramfloat.h \ - extension/paramfloat.cpp \ - extension/paramint.h \ - extension/paramint.cpp \ - extension/paramradiobutton.h \ - extension/paramradiobutton.cpp \ - extension/paramstring.h \ - extension/paramstring.cpp \ + extension/param/parameter.h \ + extension/param/parameter.cpp \ + extension/param/notebook.h \ + extension/param/notebook.cpp \ + extension/param/bool.h \ + extension/param/bool.cpp \ + extension/param/color.h \ + extension/param/color.cpp \ + extension/param/description.h \ + extension/param/description.cpp \ + extension/param/enum.h \ + extension/param/enum.cpp \ + extension/param/float.h \ + extension/param/float.cpp \ + extension/param/int.h \ + extension/param/int.cpp \ + extension/param/radiobutton.h \ + extension/param/radiobutton.cpp \ + extension/param/string.h \ + extension/param/string.cpp \ extension/prefdialog.cpp \ extension/prefdialog.h \ extension/system.cpp \ diff --git a/src/extension/extension.cpp b/src/extension/extension.cpp index 07803c187..a4ae7de9b 100644 --- a/src/extension/extension.cpp +++ b/src/extension/extension.cpp @@ -34,7 +34,7 @@ #include "db.h" #include "dependency.h" #include "timer.h" -#include "parameter.h" +#include "param/parameter.h" namespace Inkscape { namespace Extension { diff --git a/src/extension/param/bool.cpp b/src/extension/param/bool.cpp new file mode 100644 index 000000000..509ded032 --- /dev/null +++ b/src/extension/param/bool.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include +#include + +#include + +#include "../extension.h" +#include "bool.h" + +namespace Inkscape { +namespace Extension { + +/** \brief Use the superclass' allocator and set the \c _value */ +ParamBool::ParamBool (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext), _value(false) +{ + const char * defaultval = NULL; + if (sp_repr_children(xml) != NULL) + defaultval = sp_repr_children(xml)->content(); + + if (defaultval != NULL && (!strcmp(defaultval, "TRUE") || !strcmp(defaultval, "true") || !strcmp(defaultval, "1"))) { + _value = true; + } else { + _value = false; + } + + gchar * pref_name = this->pref_name(); + _value = (bool)prefs_get_int_attribute(PREF_DIR, pref_name, _value); + g_free(pref_name); + + return; +} + +/** \brief A function to set the \c _value + \param in The value to set to + \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 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. +*/ +bool +ParamBool::set( bool in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/ ) +{ + _value = in; + + gchar * prefname = this->pref_name(); + prefs_set_int_attribute(PREF_DIR, prefname, _value == true ? 1 : 0); + g_free(prefname); + + return _value; +} + +/** \brief Returns \c _value */ +bool +ParamBool::get (const SPDocument * doc, const Inkscape::XML::Node * node) +{ + return _value; +} + +/** \brief A check button which is Param aware. It works with the + parameter to change it's value as the check button changes + value. */ +class ParamBoolCheckButton : public Gtk::CheckButton { +private: + /** \brief Param to change */ + ParamBool * _pref; + SPDocument * _doc; + Inkscape::XML::Node * _node; + sigc::signal * _changeSignal; +public: + /** \brief Initialize the check button + \param param Which parameter to adjust on changing the check button + + This function sets the value of the checkbox to be that of the + parameter, and then sets up a callback to \c on_toggle. + */ + ParamBoolCheckButton (ParamBool * param, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : + Gtk::CheckButton(), _pref(param), _doc(doc), _node(node), _changeSignal(changeSignal) { + this->set_active(_pref->get(NULL, NULL) /**\todo fix */); + this->signal_toggled().connect(sigc::mem_fun(this, &ParamBoolCheckButton::on_toggle)); + return; + } + void on_toggle (void); +}; + +/** + \brief A function to respond to the check box changing + + Adjusts the value of the preference to match that in the check box. +*/ +void +ParamBoolCheckButton::on_toggle (void) +{ + _pref->set(this->get_active(), NULL /**\todo fix this */, NULL); + if (_changeSignal != NULL) { + _changeSignal->emit(); + } + return; +} + +/** \brief Return 'true' or 'false' */ +void +ParamBool::string (std::string &string) +{ + if (_value) { + string += "true"; + } else { + string += "false"; + } + + return; +} + +/** + \brief Creates a bool check button for a bool parameter + + Builds a hbox with a label and a check button in it. +*/ +Gtk::Widget * +ParamBool::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + 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, true, true); + + ParamBoolCheckButton * checkbox = new ParamBoolCheckButton(this, doc, node, changeSignal); + checkbox->show(); + hbox->pack_start(*checkbox, false, false); + + hbox->show(); + + return dynamic_cast(hbox); +} + +} /* namespace Extension */ +} /* namespace Inkscape */ diff --git a/src/extension/param/bool.h b/src/extension/param/bool.h new file mode 100644 index 000000000..a1cd4ce4a --- /dev/null +++ b/src/extension/param/bool.h @@ -0,0 +1,45 @@ +#ifndef __INK_EXTENSION_PARAMBOOL_H__ +#define __INK_EXTENSION_PARAMBOOL_H__ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include +#include +#include +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + +/** \brief A boolean parameter */ +class ParamBool : public Parameter { +private: + /** \brief Internal value. */ + bool _value; +public: + ParamBool(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + bool get (const SPDocument * doc, const Inkscape::XML::Node * node); + bool set (bool in, SPDocument * doc, Inkscape::XML::Node * node); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::string &string); +}; + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* __INK_EXTENSION_PARAMBOOL_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/param/color.cpp b/src/extension/param/color.cpp new file mode 100644 index 000000000..845a04824 --- /dev/null +++ b/src/extension/param/color.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen + * Christopher Brown + * 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 "color.h" + +#include +#include "widgets/sp-color-selector.h" +#include "widgets/sp-color-notebook.h" + + +namespace Inkscape { +namespace Extension { + +void sp_color_param_changed(SPColorSelector *csel, GObject *cp); + + +/** \brief Free the allocated data. */ +ParamColor::~ParamColor(void) +{ + +} + +guint32 +ParamColor::set( guint32 in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/ ) +{ + _value = in; + + gchar * prefname = this->pref_name(); + std::string value; + string(value); + prefs_set_string_attribute(PREF_DIR, prefname, value.c_str()); + g_free(prefname); + + return _value; +} + +/** \brief Initialize the object, to do that, copy the data. */ +ParamColor::ParamColor (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext) +{ + const char * defaulthex = NULL; + if (sp_repr_children(xml) != NULL) + defaulthex = 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) + defaulthex = paramval; + + _value = atoi(defaulthex); + + return; +} + +void +ParamColor::string (std::string &string) +{ + char str[16]; + sprintf(str, "%i", _value); + string += str; + return; +} + +Gtk::Widget * +ParamColor::get_widget( SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal * changeSignal ) +{ + if (_gui_hidden) return NULL; + + _changeSignal = new sigc::signal(*changeSignal); + Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); + SPColorSelector* spColorSelector = (SPColorSelector*)sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK); + + ColorSelector* colorSelector = spColorSelector->base; + if (_value < 1) { + _value = 0xFF000000; + } + SPColor *color = new SPColor( _value ); + float alpha = (_value & 0xff) / 255.0F; + colorSelector->setColorAlpha(*color, alpha); + + hbox->pack_start (*Glib::wrap(&spColorSelector->vbox), true, true, 0); + g_signal_connect(G_OBJECT(spColorSelector), "changed", G_CALLBACK(sp_color_param_changed), (void*)this); + + gtk_widget_show(GTK_WIDGET(spColorSelector)); + hbox->show(); + + return dynamic_cast(hbox); +} + +void +sp_color_param_changed(SPColorSelector *csel, GObject *obj) +{ + const SPColor color = csel->base->getColor(); + float alpha = csel->base->getAlpha(); + + ParamColor* ptr = (ParamColor*)obj; + ptr->set(color.toRGBA32( alpha ), NULL, NULL); + + ptr->_changeSignal->emit(); +} + +}; /* namespace Extension */ +}; /* namespace Inkscape */ diff --git a/src/extension/param/color.h b/src/extension/param/color.h new file mode 100644 index 000000000..6836442a1 --- /dev/null +++ b/src/extension/param/color.h @@ -0,0 +1,36 @@ +#ifndef __INK_EXTENSION_PARAMCOLOR_H__ +#define __INK_EXTENSION_PARAMCOLOR_H__ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include +#include +#include +#include +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + +class ParamColor : public Parameter { +private: + guint32 _value; +public: + ParamColor(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + virtual ~ParamColor(void); + /** \brief Returns \c _value, with a \i const to protect it. */ + guint32 get( const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/ ) { return _value; } + guint32 set (guint32 in, SPDocument * doc, Inkscape::XML::Node * node); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::string &string); + sigc::signal * _changeSignal; +}; /* class ParamColor */ + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* __INK_EXTENSION_PARAMCOLOR_H__ */ diff --git a/src/extension/param/description.cpp b/src/extension/param/description.cpp new file mode 100644 index 000000000..61bfa9f5a --- /dev/null +++ b/src/extension/param/description.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef linux // does the dollar sign need escaping when passed as string parameter? +# define ESCAPE_DOLLAR_COMMANDLINE +#endif + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + + +#include "description.h" + +#include +#include +#include +#include + + +#include + +#include + +#include +#include + +namespace Inkscape { +namespace Extension { + + +/** \brief Initialize the object, to do that, copy the data. */ +ParamDescription::ParamDescription (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext), _value(NULL) +{ + // printf("Building Description\n"); + const char * defaultval = NULL; + if (sp_repr_children(xml) != NULL) + defaultval = sp_repr_children(xml)->content(); + + if (defaultval != NULL) + _value = g_strdup(defaultval); + + return; +} + +/** \brief Create a label for the description */ +Gtk::Widget * +ParamDescription::get_widget (SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal * /*changeSignal*/) +{ + if (_gui_hidden) return NULL; + + Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_value))); + label->set_line_wrap(); + label->show(); + + Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); + hbox->pack_start(*label, true, true, 5); + hbox->show(); + + return hbox; +} + +} /* namespace Extension */ +} /* namespace Inkscape */ diff --git a/src/extension/param/description.h b/src/extension/param/description.h new file mode 100644 index 000000000..c305ea6df --- /dev/null +++ b/src/extension/param/description.h @@ -0,0 +1,43 @@ +#ifndef __INK_EXTENSION_PARAMDESCRIPTION_H__ +#define __INK_EXTENSION_PARAMDESCRIPTION_H__ + +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include +#include +#include +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + +/** \brief A description parameter */ +class ParamDescription : public Parameter { +private: + /** \brief Internal value. */ + gchar * _value; +public: + ParamDescription(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); +}; + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* __INK_EXTENSION_PARAMDESCRIPTION_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/param/enum.cpp b/src/extension/param/enum.cpp new file mode 100644 index 000000000..274220699 --- /dev/null +++ b/src/extension/param/enum.cpp @@ -0,0 +1,258 @@ +/** \file + * extension parameter for enumerations. + * + * It uses a Gtk:ComboBoxText widget in the extension UI. + */ + +/* + * Author: + * Johan Engelen + * + * Copyright (C) 2006-2007 Johan Engelen + * + * 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 +#include +#include +#include + +#include "enum.h" + +/** \brief The root directory in the preferences database for extension + related parameters. */ +#define PREF_DIR "extensions" + +namespace Inkscape { +namespace Extension { + +/* For internal use only. + Note that value and guitext MUST be non-NULL. This is ensured by newing only at one location in the code where non-NULL checks are made. */ +class enumentry { +public: + enumentry (Glib::ustring * val, Glib::ustring * text) { + value = val; + guitext = text; + } + ~enumentry() { + delete value; + delete guitext; + } + + Glib::ustring * value; + Glib::ustring * guitext; +}; + + +ParamComboBox::ParamComboBox (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, 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") || !strcmp(chname, "_item")) { + Glib::ustring * newguitext = NULL; + Glib::ustring * newvalue = NULL; + const char * contents = sp_repr_children(child_repr)->content(); + if (contents != NULL) + // don't translate when 'item' but do translate when '_item' + // NOTE: internal extensions use build_from_mem and don't need _item but + // still need to include if are to be localized + newguitext = new Glib::ustring( !strcmp(chname, "_item") ? _(contents) : contents ); + else + continue; + + const char * val = child_repr->attribute("value"); + if (val != NULL) + newvalue = new Glib::ustring(val); + else + newvalue = new Glib::ustring(contents); + + if ( (newguitext) && (newvalue) ) { // logical error if this is not true here + choices = g_slist_append( choices, new enumentry(newvalue, newguitext) ); + } + } + 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(xml)->attribute("value"); + + 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)) { + delete (reinterpret_cast(list->data)); + } + 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 */ + + Glib::ustring * settext = NULL; + for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { + enumentry * entr = reinterpret_cast(list->data); + if ( !entr->guitext->compare(in) ) { + settext = entr->value; + break; // break out of for loop + } + } + if (settext) { + if (_value != NULL) g_free(_value); + _value = g_strdup(settext->c_str()); + gchar * prefname = this->pref_name(); + prefs_set_string_attribute(PREF_DIR, prefname, _value); + g_free(prefname); + } + + return _value; +} + +void +ParamComboBox::changed (void) { + +} + + +/** + \brief A function to get the value of the parameter in string form + \return A string with the 'value' as command line argument +*/ +void +ParamComboBox::string (std::string &string) +{ + string += _value; + return; +} + + + + +/** \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; + sigc::signal * _changeSignal; +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, sigc::signal * changeSignal) : + Gtk::ComboBoxText(), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { + 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); + if (_changeSignal != NULL) { + _changeSignal->emit(); + } +} + +/** + \brief Creates a combobox widget for an enumeration parameter +*/ +Gtk::Widget * +ParamComboBox::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + + 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, changeSignal)); + // add choice strings: + Glib::ustring * settext = 0; + for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { + enumentry * entr = reinterpret_cast(list->data); + Glib::ustring * text = entr->guitext; + combo->append_text(*text); + if ( !entr->value->compare(_value) ) { + settext = entr->guitext; + } + } + if (settext) combo->set_active_text(*settext); + + combo->show(); + hbox->pack_start(*combo, true, true); + + hbox->show(); + + return dynamic_cast(hbox); +} + + +} /* namespace Extension */ +} /* namespace Inkscape */ diff --git a/src/extension/param/enum.h b/src/extension/param/enum.h new file mode 100644 index 000000000..3f9707c34 --- /dev/null +++ b/src/extension/param/enum.h @@ -0,0 +1,69 @@ +#ifndef INK_EXTENSION_PARAMENUM_H_SEEN +#define INK_EXTENSION_PARAMENUM_H_SEEN + +/** \file + * Enumeration parameter for extensions. + */ + +/* + * Author: + * Johan Engelen + * + * Copyright (C) 2006-2007 Johan Engelen + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include + +#include "xml/document.h" +#include + +#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, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + virtual ~ParamComboBox(void); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::string &string); + + 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); + + void changed (void); +}; /* class ParamComboBox */ + + + + + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* INK_EXTENSION_PARAMENUM_H_SEEN */ + +/* + 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/param/float.cpp b/src/extension/param/float.cpp new file mode 100644 index 000000000..1225648d6 --- /dev/null +++ b/src/extension/param/float.cpp @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * 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 "float.h" + +namespace Inkscape { +namespace Extension { + + +/** \brief Use the superclass' allocator and set the \c _value */ +ParamFloat::ParamFloat (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext), _value(0.0), _min(0.0), _max(10.0) +{ + const char * defaultval = NULL; + if (sp_repr_children(xml) != NULL) + defaultval = sp_repr_children(xml)->content(); + if (defaultval != NULL) { + _value = atof(defaultval); + } + + const char * maxval = xml->attribute("max"); + if (maxval != NULL) + _max = atof(maxval); + + const char * minval = xml->attribute("min"); + if (minval != NULL) + _min = atof(minval); + + _precision = 1; + const char * precision = xml->attribute("precision"); + if (precision != NULL) + _precision = atoi(precision); + + /* We're handling this by just killing both values */ + if (_max < _min) { + _max = 10.0; + _min = 0.0; + } + + gchar * pref_name = this->pref_name(); + _value = prefs_get_double_attribute(PREF_DIR, pref_name, _value); + g_free(pref_name); + + // std::cout << "New Float:: value: " << _value << " max: " << _max << " min: " << _min << std::endl; + + if (_value > _max) _value = _max; + if (_value < _min) _value = _min; + + return; +} + +/** \brief A function to set the \c _value + \param in The value to set to + \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 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. +*/ +float +ParamFloat::set (float in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) +{ + _value = in; + if (_value > _max) _value = _max; + if (_value < _min) _value = _min; + + gchar * prefname = this->pref_name(); + prefs_set_double_attribute(PREF_DIR, prefname, _value); + g_free(prefname); + + return _value; +} + +/** \brief Return the value as a string */ +void +ParamFloat::string (std::string &string) +{ + char startstring[G_ASCII_DTOSTR_BUF_SIZE]; + g_ascii_dtostr(startstring, G_ASCII_DTOSTR_BUF_SIZE, _value); + string += startstring; + return; +} + +/** \brief A class to make an adjustment that uses Extension params */ +class ParamFloatAdjustment : public Gtk::Adjustment { + /** The parameter to adjust */ + ParamFloat * _pref; + SPDocument * _doc; + Inkscape::XML::Node * _node; + sigc::signal * _changeSignal; +public: + /** \brief Make the adjustment using an extension and the string + describing the parameter. */ + ParamFloatAdjustment (ParamFloat * param, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : + Gtk::Adjustment(0.0, param->min(), param->max(), 0.1), _pref(param), _doc(doc), _node(node), _changeSignal(changeSignal) { + this->set_value(_pref->get(NULL, NULL) /* \todo fix */); + this->signal_value_changed().connect(sigc::mem_fun(this, &ParamFloatAdjustment::val_changed)); + return; + }; + + void val_changed (void); +}; /* class ParamFloatAdjustment */ + +/** \brief A function to respond to the value_changed signal from the + adjustment. + + This function just grabs the value from the adjustment and writes + it to the parameter. Very simple, but yet beautiful. +*/ +void +ParamFloatAdjustment::val_changed (void) +{ + //std::cout << "Value Changed to: " << this->get_value() << std::endl; + _pref->set(this->get_value(), _doc, _node); + if (_changeSignal != NULL) { + _changeSignal->emit(); + } + return; +} + +/** + \brief Creates a Float Adjustment for a float parameter + + Builds a hbox with a label and a float adjustment in it. +*/ +Gtk::Widget * +ParamFloat::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + + 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, true, true); + + ParamFloatAdjustment * fadjust = Gtk::manage(new ParamFloatAdjustment(this, doc, node, changeSignal)); + Gtk::SpinButton * spin = Gtk::manage(new Gtk::SpinButton(*fadjust, 0.1, _precision)); + spin->show(); + hbox->pack_start(*spin, false, false); + + hbox->show(); + + return dynamic_cast(hbox); +} + + +} /* namespace Extension */ +} /* namespace Inkscape */ diff --git a/src/extension/param/float.h b/src/extension/param/float.h new file mode 100644 index 000000000..f105d8f0e --- /dev/null +++ b/src/extension/param/float.h @@ -0,0 +1,52 @@ +#ifndef INK_EXTENSION_PARAMFLOAT_H_SEEN +#define INK_EXTENSION_PARAMFLOAT_H_SEEN + +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include +#include +#include +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + +class ParamFloat : public Parameter { +private: + /** \brief Internal value. */ + float _value; + float _min; + float _max; + int _precision; +public: + ParamFloat (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + /** \brief Returns \c _value */ + float get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _value; } + float set (float in, SPDocument * doc, Inkscape::XML::Node * node); + float max (void) { return _max; } + float min (void) { return _min; } + float precision (void) { return _precision; } + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::string &string); +}; + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* INK_EXTENSION_PARAMFLOAT_H_SEEN */ + +/* + 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/param/int.cpp b/src/extension/param/int.cpp new file mode 100644 index 000000000..dc523435e --- /dev/null +++ b/src/extension/param/int.cpp @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * 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 "int.h" + +namespace Inkscape { +namespace Extension { + + +/** \brief Use the superclass' allocator and set the \c _value */ +ParamInt::ParamInt (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext), _value(0), _min(0), _max(10) +{ + const char * defaultval = NULL; + if (sp_repr_children(xml) != NULL) + defaultval = sp_repr_children(xml)->content(); + if (defaultval != NULL) { + _value = atoi(defaultval); + } + + const char * maxval = xml->attribute("max"); + if (maxval != NULL) + _max = atoi(maxval); + + const char * minval = xml->attribute("min"); + if (minval != NULL) + _min = atoi(minval); + + /* We're handling this by just killing both values */ + if (_max < _min) { + _max = 10; + _min = 0; + } + + gchar * pref_name = this->pref_name(); + _value = prefs_get_int_attribute(PREF_DIR, pref_name, _value); + g_free(pref_name); + + // std::cout << "New Int:: value: " << _value << " max: " << _max << " min: " << _min << std::endl; + + if (_value > _max) _value = _max; + if (_value < _min) _value = _min; + + return; +} + +/** \brief A function to set the \c _value + \param in The value to set to + \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 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. +*/ +int +ParamInt::set (int in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) +{ + _value = in; + if (_value > _max) _value = _max; + if (_value < _min) _value = _min; + + gchar * prefname = this->pref_name(); + prefs_set_int_attribute(PREF_DIR, prefname, _value); + g_free(prefname); + + return _value; +} + +/** \brief A class to make an adjustment that uses Extension params */ +class ParamIntAdjustment : public Gtk::Adjustment { + /** The parameter to adjust */ + ParamInt * _pref; + SPDocument * _doc; + Inkscape::XML::Node * _node; + sigc::signal * _changeSignal; +public: + /** \brief Make the adjustment using an extension and the string + describing the parameter. */ + ParamIntAdjustment (ParamInt * param, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : + Gtk::Adjustment(0.0, param->min(), param->max(), 1.0), _pref(param), _doc(doc), _node(node), _changeSignal(changeSignal) { + this->set_value(_pref->get(NULL, NULL) /* \todo fix */); + this->signal_value_changed().connect(sigc::mem_fun(this, &ParamIntAdjustment::val_changed)); + return; + }; + + void val_changed (void); +}; /* class ParamIntAdjustment */ + +/** \brief A function to respond to the value_changed signal from the + adjustment. + + This function just grabs the value from the adjustment and writes + it to the parameter. Very simple, but yet beautiful. +*/ +void +ParamIntAdjustment::val_changed (void) +{ + //std::cout << "Value Changed to: " << this->get_value() << std::endl; + _pref->set((int)this->get_value(), _doc, _node); + if (_changeSignal != NULL) { + _changeSignal->emit(); + } + return; +} + +/** + \brief Creates a Int Adjustment for a int parameter + + Builds a hbox with a label and a int adjustment in it. +*/ +Gtk::Widget * +ParamInt::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + + 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, true, true); + + ParamIntAdjustment * fadjust = Gtk::manage(new ParamIntAdjustment(this, doc, node, changeSignal)); + Gtk::SpinButton * spin = Gtk::manage(new Gtk::SpinButton(*fadjust, 1.0, 0)); + spin->show(); + hbox->pack_start(*spin, false, false); + + hbox->show(); + + return dynamic_cast(hbox); +} + +/** \brief Return the value as a string */ +void +ParamInt::string (std::string &string) +{ + char startstring[32]; + sprintf(startstring, "%d", _value); + string += startstring; + return; +} + +} /* namespace Extension */ +} /* namespace Inkscape */ diff --git a/src/extension/param/int.h b/src/extension/param/int.h new file mode 100644 index 000000000..a4eb54c81 --- /dev/null +++ b/src/extension/param/int.h @@ -0,0 +1,50 @@ +#ifndef INK_EXTENSION_PARAMINT_H_SEEN +#define INK_EXTENSION_PARAMINT_H_SEEN + +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include +#include +#include +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + +class ParamInt : public Parameter { +private: + /** \brief Internal value. */ + int _value; + int _min; + int _max; +public: + ParamInt (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + /** \brief Returns \c _value */ + int get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _value; } + int set (int in, SPDocument * doc, Inkscape::XML::Node * node); + int max (void) { return _max; } + int min (void) { return _min; } + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::string &string); +}; + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* INK_EXTENSION_PARAMINT_H_SEEN */ + +/* + 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/param/notebook.cpp b/src/extension/param/notebook.cpp new file mode 100644 index 000000000..5c4f96759 --- /dev/null +++ b/src/extension/param/notebook.cpp @@ -0,0 +1,430 @@ +/** \file + * Notebook and NotebookPage parameters for extensions. + */ + +/* + * 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 + +#include +#include "prefs-utils.h" +#include "document-private.h" +#include "sp-object.h" + +#include "notebook.h" + +/** \brief The root directory in the preferences database for extension + related parameters. */ +#define PREF_DIR "extensions" + +namespace Inkscape { +namespace Extension { + + +// \brief A class to represent the pages of a notebookparameter of an extension +class ParamNotebookPage : public Parameter { +private: + GSList * parameters; /**< A table to store the parameters for this page. + This only gets created if there are parameters on this + page */ + Gtk::Tooltips * _tooltips; + +public: + static ParamNotebookPage * makepage (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext); + + ParamNotebookPage(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + ~ParamNotebookPage(void); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void paramString (std::list &list); + gchar * get_guitext (void) {return _text;}; + +}; /* class ParamNotebookPage */ + + +ParamNotebookPage::ParamNotebookPage (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext) +{ + parameters = NULL; + + // Read XML to build page + if (xml != NULL) { + Inkscape::XML::Node *child_repr = sp_repr_children(xml); + while (child_repr != NULL) { + char const * chname = child_repr->name(); + if (chname[0] == '_') // Allow _ for translation of tags + chname++; + if (!strcmp(chname, "param") || !strcmp(chname, "_param")) { + Parameter * param; + param = Parameter::make(child_repr, ext); + if (param != NULL) parameters = g_slist_append(parameters, param); + } + child_repr = sp_repr_next(child_repr); + } + } + + return; +} + +ParamNotebookPage::~ParamNotebookPage (void) +{ + if (_tooltips) delete _tooltips; + //destroy parameters + for (GSList * list = parameters; list != NULL; list = g_slist_next(list)) { + Parameter * param = reinterpret_cast(list->data); + delete param; + } + g_slist_free(parameters); +} + +/** \brief Return the value as a string */ +void +ParamNotebookPage::paramString (std::list &list) +{ + for (GSList * plist = parameters; plist != NULL; plist = g_slist_next(plist)) { + Parameter * param = reinterpret_cast(plist->data); + param->string(list); + } + + return; +} + + +/** + \return None + \brief This function creates a page that can be used later. This + is typically done in the creation of the notebook and defined + in the XML file describing the extension (it's private so people + have to use the system) :) + \param in_repr The XML describing the page + + This function first grabs all of the data out of the Repr and puts + it into local variables. Actually, these are just pointers, and the + data is not duplicated so we need to be careful with it. If there + isn't a name in the XML, then no page is created as + the function just returns. + + From this point on, we're pretty committed as we've allocated an + object and we're starting to fill it. The name is set first, and + is created with a strdup to actually allocate memory for it. Then + there is a case statement (roughly because strcmp requires 'ifs') + based on what type of parameter this is. Depending which type it + is, the value is interpreted differently, but they are relatively + straight forward. In all cases the value is set to the default + value from the XML and the type is set to the interpreted type. +*/ +ParamNotebookPage * +ParamNotebookPage::makepage (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext) +{ + const char * name; + const char * guitext; + const char * desc; + const char * scope_str; + Parameter::_scope_t scope = Parameter::SCOPE_USER; + bool gui_hidden = false; + const char * gui_hide; + const char * gui_tip; + + name = in_repr->attribute("name"); + guitext = in_repr->attribute("gui-text"); + if (guitext == NULL) + guitext = in_repr->attribute("_gui-text"); + gui_tip = in_repr->attribute("gui-tip"); + if (gui_tip == NULL) + gui_tip = in_repr->attribute("_gui-tip"); + desc = in_repr->attribute("gui-description"); + if (desc == NULL) + desc = in_repr->attribute("_gui-description"); + scope_str = in_repr->attribute("scope"); + gui_hide = in_repr->attribute("gui-hidden"); + if (gui_hide != NULL) { + if (strcmp(gui_hide, "1") == 0 || + strcmp(gui_hide, "true") == 0) { + gui_hidden = true; + } + /* else stays false */ + } + + /* In this case we just don't have enough information */ + if (name == NULL) { + return NULL; + } + + if (scope_str != NULL) { + if (!strcmp(scope_str, "user")) { + scope = Parameter::SCOPE_USER; + } else if (!strcmp(scope_str, "document")) { + scope = Parameter::SCOPE_DOCUMENT; + } else if (!strcmp(scope_str, "node")) { + scope = Parameter::SCOPE_NODE; + } + } + + ParamNotebookPage * page = new ParamNotebookPage(name, guitext, desc, scope, gui_hide, gui_tip, in_ext, in_repr); + + /* Note: page could equal NULL */ + return page; +} + + + +/** + \brief Creates a notebookpage widget for a notebook + + Builds a notebook page (a vbox) and puts parameters on it. +*/ +Gtk::Widget * +ParamNotebookPage::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + + if (!_tooltips) _tooltips = new Gtk::Tooltips(); + + Gtk::VBox * vbox = Gtk::manage(new Gtk::VBox); + vbox->set_border_width(5); + + // add parameters onto page (if any) + for (GSList * list = parameters; list != NULL; list = g_slist_next(list)) { + Parameter * param = reinterpret_cast(list->data); + Gtk::Widget * widg = param->get_widget(doc, node, changeSignal); + gchar const * tip = param->get_tooltip(); + + vbox->pack_start(*widg, true, true, 2); + if (tip != NULL) { + _tooltips->set_tip(*widg, Glib::ustring(tip)); + } + } + + vbox->show(); + + return dynamic_cast(vbox); +} + + + + + + + + + +ParamNotebook::ParamNotebook (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext) +{ + pages = NULL; + + // Read XML tree to add pages: + if (xml != NULL) { + Inkscape::XML::Node *child_repr = sp_repr_children(xml); + while (child_repr != NULL) { + char const * chname = child_repr->name(); + if (chname[0] == '_') // Allow _ for translation of tags + chname++; + if (!strcmp(chname, "page")) { + ParamNotebookPage * page; + page = ParamNotebookPage::makepage(child_repr, ext); + if (page != NULL) pages = g_slist_append(pages, page); + } + child_repr = sp_repr_next(child_repr); + } + } + + // Initialize _value with the current page + const char * defaultval = NULL; + // set first page as default + if (pages != NULL) { + ParamNotebookPage * defpage = reinterpret_cast(pages->data); + defaultval = defpage->name(); + } + + 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; +} + +ParamNotebook::~ParamNotebook (void) +{ + //destroy pages + for (GSList * list = pages; list != NULL; list = g_slist_next(list)) { + ParamNotebookPage * page = reinterpret_cast(list->data); + delete page; + } + g_slist_free(pages); + + g_free(_value); +} + + +/** \brief A function to set the \c _value + \param in The number of the page which value must be 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 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 * +ParamNotebook::set (const int in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) +{ + ParamNotebookPage * page = NULL; + int i = 0; + for (GSList * list = pages; (list != NULL) && (i <= in); list = g_slist_next(list)) { + page = reinterpret_cast(list->data); + i++; + } + + if (page == NULL) return _value; + + if (_value != NULL) g_free(_value); + _value = g_strdup(page->name()); + + 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 +*/ +void +ParamNotebook::string (std::list &list) +{ + std::string param_string; + param_string += "--"; + param_string += name(); + param_string += "="; + + param_string += "\""; + param_string += _value; // the name of the current page + param_string += "\""; + list.insert(list.end(), param_string); + + for (GSList * pglist = pages; pglist != NULL; pglist = g_slist_next(pglist)) { + ParamNotebookPage * page = reinterpret_cast(pglist->data); + page->paramString(list); + } + + return; +} + +/** \brief A special category of Gtk::Notebook to handle notebook parameters */ +class ParamNotebookWdg : public Gtk::Notebook { +private: + ParamNotebook * _pref; + SPDocument * _doc; + Inkscape::XML::Node * _node; +public: + /** \brief Build a notebookpage preference for the given parameter + \param pref Where to get the string (pagename) from, and where to put it + when it changes. + */ + ParamNotebookWdg (ParamNotebook * pref, SPDocument * doc, Inkscape::XML::Node * node) : + Gtk::Notebook(), _pref(pref), _doc(doc), _node(node), activated(false) { + // don't have to set the correct page: this is done in ParamNotebook::get_widget. + // hook function + this->signal_switch_page().connect(sigc::mem_fun(this, &ParamNotebookWdg::changed_page)); + return; + }; + void changed_page(GtkNotebookPage *page, guint pagenum); + bool activated; +}; + +/** \brief Respond to the selected page of notebook changing + This function responds to the changing by reporting it to + ParamNotebook. The change is only reported when the notebook + is actually visible. This to exclude 'fake' changes when the + notebookpages are added or removed. +*/ +void +ParamNotebookWdg::changed_page(GtkNotebookPage */*page*/, + guint pagenum) +{ + if (is_visible()) { + _pref->set((int)pagenum, _doc, _node); + } + return; +} + + + +/** + \brief Creates a Notebook widget for a notebook parameter + + Builds a notebook and puts pages in it. +*/ +Gtk::Widget * +ParamNotebook::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + + ParamNotebookWdg * nb = Gtk::manage(new ParamNotebookWdg(this, doc, node)); + + // add pages (if any) + int i = -1; + int pagenr = i; + for (GSList * list = pages; list != NULL; list = g_slist_next(list)) { + i++; + ParamNotebookPage * page = reinterpret_cast(list->data); + Gtk::Widget * widg = page->get_widget(doc, node, changeSignal); + nb->append_page(*widg, _(page->get_guitext())); + if (!strcmp(_value, page->name())) { + pagenr = i; // this is the page to be displayed? + } + } + + nb->show(); + + if (pagenr >= 0) nb->set_current_page(pagenr); + + return dynamic_cast(nb); +} + + +} /* 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/param/notebook.h b/src/extension/param/notebook.h new file mode 100644 index 000000000..24d4ebfc1 --- /dev/null +++ b/src/extension/param/notebook.h @@ -0,0 +1,68 @@ +#ifndef INK_EXTENSION_PARAMNOTEBOOK_H_SEEN +#define INK_EXTENSION_PARAMNOTEBOOK_H_SEEN + +/** \file + * Notebook 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 + +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + + + +// \brief A class to represent a notebookparameter of an extension +class ParamNotebook : 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 name of the current page. */ + gchar * _value; + + GSList * pages; /**< A table to store the pages with parameters for this notebook. + This only gets created if there are pages in this + notebook */ +public: + ParamNotebook(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + virtual ~ParamNotebook(void); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::list &list); + + const gchar * get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _value; } + const gchar * set (const int in, SPDocument * doc, Inkscape::XML::Node * node); +}; /* class ParamNotebook */ + + + + + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* INK_EXTENSION_PARAMNOTEBOOK_H_SEEN */ + +/* + 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/param/parameter.cpp b/src/extension/param/parameter.cpp new file mode 100644 index 000000000..7e071e7e3 --- /dev/null +++ b/src/extension/param/parameter.cpp @@ -0,0 +1,389 @@ +/** \file + * Parameters for extensions. + */ + +/* + * Author: + * Ted Gould + * Johan Engelen + * + * Copyright (C) 2005-2007 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifdef linux // does the dollar sign need escaping when passed as string parameter? +# define ESCAPE_DOLLAR_COMMANDLINE +#endif + +#include +#include +#include + +#include + +#include +#include "document-private.h" +#include "sp-object.h" +#include +#include "widgets/sp-color-selector.h" +#include "widgets/sp-color-notebook.h" + +#include "parameter.h" +#include "bool.h" +#include "color.h" +#include "description.h" +#include "enum.h" +#include "float.h" +#include "int.h" +#include "notebook.h" +#include "radiobutton.h" +#include "string.h" + +namespace Inkscape { +namespace Extension { + +/** + \return None + \brief This function creates a parameter that can be used later. This + is typically done in the creation of the extension and defined + in the XML file describing the extension (it's private so people + have to use the system) :) + \param in_repr The XML describing the parameter + + This function first grabs all of the data out of the Repr and puts + it into local variables. Actually, these are just pointers, and the + data is not duplicated so we need to be careful with it. If there + isn't a name or a type in the XML, then no parameter is created as + the function just returns. + + From this point on, we're pretty committed as we've allocated an + object and we're starting to fill it. The name is set first, and + is created with a strdup to actually allocate memory for it. Then + there is a case statement (roughly because strcmp requires 'ifs') + based on what type of parameter this is. Depending which type it + is, the value is interpreted differently, but they are relatively + straight forward. In all cases the value is set to the default + value from the XML and the type is set to the interpreted type. +*/ +Parameter * +Parameter::make (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext) +{ + const char * name; + const char * type; + const char * guitext; + const char * desc; + const char * scope_str; + Parameter::_scope_t scope = Parameter::SCOPE_USER; + bool gui_hidden = false; + const char * gui_hide; + const char * gui_tip; + + name = in_repr->attribute("name"); + type = in_repr->attribute("type"); + guitext = in_repr->attribute("gui-text"); + if (guitext == NULL) + guitext = in_repr->attribute("_gui-text"); + gui_tip = in_repr->attribute("gui-tip"); + if (gui_tip == NULL) + gui_tip = in_repr->attribute("_gui-tip"); + desc = in_repr->attribute("gui-description"); + if (desc == NULL) + desc = in_repr->attribute("_gui-description"); + scope_str = in_repr->attribute("scope"); + gui_hide = in_repr->attribute("gui-hidden"); + if (gui_hide != NULL) { + if (strcmp(gui_hide, "1") == 0 || + strcmp(gui_hide, "true") == 0) { + gui_hidden = true; + } + /* else stays false */ + } + + /* In this case we just don't have enough information */ + if (name == NULL || type == NULL) { + return NULL; + } + + if (scope_str != NULL) { + if (!strcmp(scope_str, "user")) { + scope = Parameter::SCOPE_USER; + } else if (!strcmp(scope_str, "document")) { + scope = Parameter::SCOPE_DOCUMENT; + } else if (!strcmp(scope_str, "node")) { + scope = Parameter::SCOPE_NODE; + } + } + + Parameter * param = NULL; + if (!strcmp(type, "boolean")) { + param = new ParamBool(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "int")) { + param = new ParamInt(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "float")) { + param = new ParamFloat(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "string")) { + param = new ParamString(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "description")) { + param = new ParamDescription(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "enum")) { + param = new ParamComboBox(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "notebook")) { + param = new ParamNotebook(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "optiongroup")) { + param = new ParamRadioButton(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } else if (!strcmp(type, "color")) { + param = new ParamColor(name, guitext, desc, scope, gui_hidden, gui_tip, in_ext, in_repr); + } + + /* Note: param could equal NULL */ + return param; +} + + + +/** \brief Wrapper to cast to the object and use it's function. */ +bool +Parameter::get_bool (const SPDocument * doc, const Inkscape::XML::Node * node) +{ + ParamBool * boolpntr = dynamic_cast(this); + if (boolpntr == NULL) + throw Extension::param_not_bool_param(); + return boolpntr->get(doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +int +Parameter::get_int (const SPDocument * doc, const Inkscape::XML::Node * node) +{ + ParamInt * intpntr = dynamic_cast(this); + if (intpntr == NULL) + throw Extension::param_not_int_param(); + return intpntr->get(doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +float +Parameter::get_float (const SPDocument * doc, const Inkscape::XML::Node * node) +{ + ParamFloat * floatpntr = dynamic_cast(this); + if (floatpntr == NULL) + throw Extension::param_not_float_param(); + return floatpntr->get(doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +const gchar * +Parameter::get_string (const SPDocument * doc, const Inkscape::XML::Node * node) +{ + ParamString * stringpntr = dynamic_cast(this); + if (stringpntr == NULL) + throw Extension::param_not_string_param(); + return stringpntr->get(doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +const gchar * +Parameter::get_enum (const SPDocument * doc, const Inkscape::XML::Node * node) +{ + ParamComboBox * param = dynamic_cast(this); + if (param == NULL) + throw Extension::param_not_enum_param(); + return param->get(doc, node); +} + +guint32 +Parameter::get_color(const SPDocument* doc, const Inkscape::XML::Node* node) +{ + ParamColor* param = dynamic_cast(this); + if (param == NULL) + throw Extension::param_not_color_param(); + return param->get(doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +bool +Parameter::set_bool (bool in, SPDocument * doc, Inkscape::XML::Node * node) +{ + ParamBool * boolpntr = dynamic_cast(this); + if (boolpntr == NULL) + throw Extension::param_not_bool_param(); + return boolpntr->set(in, doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +int +Parameter::set_int (int in, SPDocument * doc, Inkscape::XML::Node * node) +{ + ParamInt * intpntr = dynamic_cast(this); + if (intpntr == NULL) + throw Extension::param_not_int_param(); + return intpntr->set(in, doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +float +Parameter::set_float (float in, SPDocument * doc, Inkscape::XML::Node * node) +{ + ParamFloat * floatpntr; + floatpntr = dynamic_cast(this); + if (floatpntr == NULL) + throw Extension::param_not_float_param(); + return floatpntr->set(in, doc, node); +} + +/** \brief Wrapper to cast to the object and use it's function. */ +const gchar * +Parameter::set_string (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node) +{ + ParamString * stringpntr = dynamic_cast(this); + if (stringpntr == NULL) + throw Extension::param_not_string_param(); + return stringpntr->set(in, doc, node); +} +/** \brief Wrapper to cast to the object and use it's function. */ +guint32 +Parameter::set_color (guint32 in, SPDocument * doc, Inkscape::XML::Node * node) +{ + ParamColor* param = dynamic_cast(this); + if (param == NULL) + throw Extension::param_not_color_param(); + return param->set(in, doc, node); +} + + +/** \brief Oop, now that we need a parameter, we need it's name. */ +Parameter::Parameter (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext) : + extension(ext), _name(NULL), _desc(NULL), _scope(scope), _text(NULL), _gui_hidden(gui_hidden), _gui_tip(NULL) +{ + if (name != NULL) { + _name = g_strdup(name); + } + if (desc != NULL) { + _desc = g_strdup(desc); + // printf("Adding description: '%s' on '%s'\n", _desc, _name); + } + if (gui_tip != NULL) { + _gui_tip = g_strdup(gui_tip); + } + + + if (guitext != NULL) + _text = g_strdup(guitext); + else + _text = g_strdup(name); + + return; +} + +/** \brief Just free the allocated name. */ +Parameter::~Parameter (void) +{ + g_free(_name); + g_free(_text); + g_free(_gui_tip); +} + +/** \brief Build the name to write the parameter from the extension's + ID and the name of this parameter. */ +gchar * +Parameter::pref_name (void) +{ + return g_strdup_printf("%s.%s", extension->get_id(), _name); +} + +Inkscape::XML::Node * +Parameter::find_child (Inkscape::XML::Node * adult) +{ + return sp_repr_lookup_child(adult, "name", _name); +} + +Inkscape::XML::Node * +Parameter::new_child (Inkscape::XML::Node * parent) +{ + Inkscape::XML::Node * retval; + retval = parent->document()->createElement("inkscape:extension-param"); + retval->setAttribute("name", _name); + + parent->appendChild(retval); + return retval; +} + +Inkscape::XML::Node * +Parameter::document_param_node (SPDocument * doc) +{ + Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc); + Inkscape::XML::Node * defs = SP_OBJECT_REPR(SP_DOCUMENT_DEFS(doc)); + Inkscape::XML::Node * params = NULL; + + GQuark const name_quark = g_quark_from_string("inkscape:extension-params"); + + for (Inkscape::XML::Node * child = defs->firstChild(); + child != NULL; + child = child->next()) { + if ((GQuark)child->code() == name_quark && + !strcmp(child->attribute("extension"), extension->get_id())) { + params = child; + break; + } + } + + if (params == NULL) { + params = xml_doc->createElement("inkscape:extension-param"); + params->setAttribute("extension", extension->get_id()); + defs->appendChild(params); + } + + return params; +} + +/** \brief Basically, if there is no widget pass a NULL. */ +Gtk::Widget * +Parameter::get_widget (SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal * /*changeSignal*/) +{ + return NULL; +} + +/** \brief If I'm not sure which it is, just don't return a value. */ +void +Parameter::string (std::string &/*string*/) +{ + return; +} + +void +Parameter::string (std::list &list) +{ + std::string value; + string(value); + if (value == "") { + return; + } + + std::string final; + final += "--"; + final += name(); + final += "="; + final += value; + + list.insert(list.end(), final); + 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 : diff --git a/src/extension/param/parameter.h b/src/extension/param/parameter.h new file mode 100644 index 000000000..ca3a2a0d4 --- /dev/null +++ b/src/extension/param/parameter.h @@ -0,0 +1,131 @@ +#ifndef __INK_EXTENSION_PARAM_H__ +#define __INK_EXTENSION_PARAM_H__ + +/** \file + * Parameters for extensions. + */ + +/* + * Authors: + * Ted Gould + * + * Copyright (C) 2005-2006 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +/** \brief The root directory in the preferences database for extension-related parameters. */ +#define PREF_DIR "extensions" + +#include + +#include "xml/document.h" +#include "xml/node.h" +#include "document.h" +#include +#include "prefs-utils.h" + +#include + +#include + +namespace Inkscape { +namespace Extension { + +/** \brief A class to represent the parameter of an extension + + This is really a super class that allows them to abstract all + the different types of parameters into some that can be passed + around. There is also a few functions that are used by all the + different parameters. +*/ +class Parameter { +private: + /** \brief Which extension is this parameter attached to? */ + Inkscape::Extension::Extension * extension; + /** \brief The name of this parameter. */ + gchar * _name; + +protected: + /** \brief Description of the parameter. */ + gchar * _desc; + /** \brief List of possible scopes. */ + typedef enum { + SCOPE_USER, /**< Parameter value is saved in the user's configuration file. (default) */ + SCOPE_DOCUMENT, /**< Parameter value is saved in the document. */ + SCOPE_NODE /**< Parameter value is attached to the node. */ + } _scope_t; + /** \brief Scope of the parameter. */ + _scope_t _scope; + /** \brief Text for the GUI selection of this. */ + gchar * _text; + /** \brief Whether the GUI is visible */ + bool _gui_hidden; + /** \brief A tip for the GUI if there is one */ + gchar * _gui_tip; + + + /* **** funcs **** */ + gchar * pref_name (void); + Inkscape::XML::Node * find_child (Inkscape::XML::Node * adult); + Inkscape::XML::Node * document_param_node (SPDocument * doc); + Inkscape::XML::Node * new_child (Inkscape::XML::Node * parent); + +public: + Parameter (const gchar * name, + const gchar * guitext, + const gchar * desc, + const Parameter::_scope_t scope, + bool gui_hidden, + const gchar * gui_tip, + Inkscape::Extension::Extension * ext); + Parameter (const gchar * name, + const gchar * guitext, + Inkscape::Extension::Extension * ext) { + Parameter(name, guitext, NULL, Parameter::SCOPE_USER, false, NULL, ext); + }; + virtual ~Parameter (void); + bool get_bool (const SPDocument * doc, + const Inkscape::XML::Node * node); + int get_int (const SPDocument * doc, + const Inkscape::XML::Node * node); + float get_float (const SPDocument * doc, + const Inkscape::XML::Node * node); + const gchar * get_string (const SPDocument * doc, + const Inkscape::XML::Node * node); + guint32 get_color (const SPDocument * doc, + const Inkscape::XML::Node * node); + const gchar * get_enum (const SPDocument * doc, + const Inkscape::XML::Node * node); + + bool set_bool (bool in, SPDocument * doc, Inkscape::XML::Node * node); + int set_int (int in, SPDocument * doc, Inkscape::XML::Node * node); + float set_float (float in, SPDocument * doc, Inkscape::XML::Node * node); + const gchar * set_string (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node); + guint32 set_color (guint32 in, SPDocument * doc, Inkscape::XML::Node * node); + + const gchar * name (void) {return _name;} + + static Parameter * make (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext); + virtual Gtk::Widget * get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + gchar const * get_tooltip (void) { return _desc; } + + virtual void string (std::list &list); + virtual void string (std::string &string); +}; + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* __INK_EXTENSION_PARAM_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/param/radiobutton.cpp b/src/extension/param/radiobutton.cpp new file mode 100644 index 000000000..1ab526d19 --- /dev/null +++ b/src/extension/param/radiobutton.cpp @@ -0,0 +1,271 @@ +/** \file + * extension parameter for radiobuttons. + * + * It uses a Gtk:ComboBoxText widget in the extension UI. + */ + +/* + * Author: + * Johan Engelen + * + * Copyright (C) 2006-2007 Johan Engelen + * + * 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 + +#include +#include "prefs-utils.h" +#include "document-private.h" +#include "sp-object.h" + +#include "radiobutton.h" + +/** \brief The root directory in the preferences database for extension + related parameters. */ +#define PREF_DIR "extensions" + +namespace Inkscape { +namespace Extension { + +/* For internal use only. + Note that value and guitext MUST be non-NULL. This is ensured by newing only at one location in the code where non-NULL checks are made. */ +class optionentry { +public: + optionentry (Glib::ustring * val, Glib::ustring * text) { + value = val; + guitext = text; + } + ~optionentry() { + delete value; + delete guitext; + } + + Glib::ustring * value; + Glib::ustring * guitext; +}; + +ParamRadioButton::ParamRadioButton (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, 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, "option") || !strcmp(chname, "_option")) { + Glib::ustring * newguitext = NULL; + Glib::ustring * newvalue = NULL; + const char * contents = sp_repr_children(child_repr)->content(); + if (contents != NULL) + // don't translate when 'option' but do translate when '_option' + newguitext = new Glib::ustring( !strcmp(chname, "_option") ? _(contents) : contents ); + else + continue; + + const char * val = child_repr->attribute("value"); + if (val != NULL) + newvalue = new Glib::ustring(val); + else + newvalue = new Glib::ustring(contents); + + if ( (newguitext) && (newvalue) ) { // logical error if this is not true here + choices = g_slist_append( choices, new optionentry(newvalue, newguitext) ); + } + } + 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 (choices) + defaultval = ((optionentry*) choices->data)->value->c_str(); + + 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; +} + +ParamRadioButton::~ParamRadioButton (void) +{ + //destroy choice strings + for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { + delete (reinterpret_cast(list->data)); + } + 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 * +ParamRadioButton::set (const gchar * in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) +{ + if (in == NULL) return NULL; /* Can't have NULL string */ + + Glib::ustring * settext = NULL; + for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { + optionentry * entr = reinterpret_cast(list->data); + if ( !entr->guitext->compare(in) ) { + settext = entr->value; + break; // break out of for loop + } + } + if (settext) { + if (_value != NULL) g_free(_value); + _value = g_strdup(settext->c_str()); + gchar * prefname = this->pref_name(); + prefs_set_string_attribute(PREF_DIR, prefname, _value); + g_free(prefname); + } + + return _value; +} + + +/** + \brief A function to get the current value of the parameter in a string form + \return A string with the 'value' as command line argument +*/ +void +ParamRadioButton::string (std::string &string) +{ + string += _value; + return; +} + +/** \brief A special radiobutton class to use in ParamRadioButton */ +class ParamRadioButtonWdg : public Gtk::RadioButton { +private: + ParamRadioButton * _pref; + SPDocument * _doc; + Inkscape::XML::Node * _node; + sigc::signal * _changeSignal; +public: + /** \brief Build a string preference for the given parameter + \param pref Where to put the radiobutton's string when it is selected. + */ + ParamRadioButtonWdg ( Gtk::RadioButtonGroup& group, const Glib::ustring& label, + ParamRadioButton * pref, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal ) : + Gtk::RadioButton(group, label), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { + add_changesignal(); + }; + ParamRadioButtonWdg ( const Glib::ustring& label, + ParamRadioButton * pref, SPDocument * doc, Inkscape::XML::Node * node , sigc::signal * changeSignal) : + Gtk::RadioButton(label), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { + add_changesignal(); + }; + void add_changesignal() { + this->signal_toggled().connect(sigc::mem_fun(this, &ParamRadioButtonWdg::changed)); + }; + void changed (void); +}; + +/** \brief Respond to the selected radiobutton changing + + This function responds to the radiobutton selection changing by grabbing the value + from the text box and putting it in the parameter. +*/ +void +ParamRadioButtonWdg::changed (void) +{ + if (this->get_active()) { + Glib::ustring data = this->get_label(); + _pref->set(data.c_str(), _doc, _node); + } + if (_changeSignal != NULL) { + _changeSignal->emit(); + } +} + + + +/** + \brief Creates a combobox widget for an enumeration parameter +*/ +Gtk::Widget * +ParamRadioButton::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + + Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); + Gtk::VBox * vbox = Gtk::manage(new Gtk::VBox(false, 0)); + + Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP)); + label->show(); + hbox->pack_start(*label, false, false); + + // add choice strings as radiobuttons + // and select last selected option (_value) + bool first = true; + ParamRadioButtonWdg * radio; + Gtk::RadioButtonGroup group; + for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { + optionentry * entr = reinterpret_cast(list->data); + Glib::ustring * text = entr->guitext; + if (first) { + radio = Gtk::manage(new ParamRadioButtonWdg(*text, this, doc, node, changeSignal)); + group = radio->get_group(); + first = false; + } else { + radio = Gtk::manage(new ParamRadioButtonWdg(group, *text, this, doc, node, changeSignal)); + } + radio->show(); + vbox->pack_start(*radio, true, true); + if (!entr->value->compare(_value)) { + radio->set_active(); + } + } + + vbox->show(); + hbox->pack_end(*vbox, false, false); + hbox->show(); + + + return dynamic_cast(hbox); +} + + +} /* namespace Extension */ +} /* namespace Inkscape */ + diff --git a/src/extension/param/radiobutton.h b/src/extension/param/radiobutton.h new file mode 100644 index 000000000..4bf596e4f --- /dev/null +++ b/src/extension/param/radiobutton.h @@ -0,0 +1,57 @@ +#ifndef INK_EXTENSION_PARAMRADIOBUTTON_H_SEEN +#define INK_EXTENSION_PARAMRADIOBUTTON_H_SEEN + +/** \file + * Radiobutton parameter for extensions. + */ + +/* + * Author: + * Johan Engelen + * + * Copyright (C) 2006-2007 Johan Engelen + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include + +#include "xml/document.h" +#include + +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + + + +// \brief A class to represent a radiobutton parameter of an extension +class ParamRadioButton : 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: + ParamRadioButton(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + virtual ~ParamRadioButton(void); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::string &string); + + 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 ParamRadioButton */ + + + + + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* INK_EXTENSION_PARAMRADIOBUTTON_H_SEEN */ + diff --git a/src/extension/param/string.cpp b/src/extension/param/string.cpp new file mode 100644 index 000000000..36c3ce115 --- /dev/null +++ b/src/extension/param/string.cpp @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * 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 "string.h" + +namespace Inkscape { +namespace Extension { + + +/** \brief Free the allocated data. */ +ParamString::~ParamString(void) +{ + g_free(_value); +} + +/** \brief A function to set the \c _value + \param in The value to set to + \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 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 * +ParamString::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 Return the value as a string */ +void +ParamString::string (std::string &string) +{ + if (_value == NULL) + return; + + string += _value; + return; +} + +/** \brief Initialize the object, to do that, copy the data. */ +ParamString::ParamString (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) : + Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext), _value(NULL) +{ + const char * defaultval = NULL; + if (sp_repr_children(xml) != NULL) + defaultval = 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); + + return; +} + +/** \brief A special category of Gtk::Entry to handle string parameteres */ +class ParamStringEntry : public Gtk::Entry { +private: + ParamString * _pref; + SPDocument * _doc; + Inkscape::XML::Node * _node; + sigc::signal * _changeSignal; +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. + */ + ParamStringEntry (ParamString * pref, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : + Gtk::Entry(), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { + if (_pref->get(NULL, NULL) != NULL) + this->set_text(Glib::ustring(_pref->get(NULL, NULL))); + this->signal_changed().connect(sigc::mem_fun(this, &ParamStringEntry::changed_text)); + }; + void changed_text (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 +ParamStringEntry::changed_text (void) +{ + Glib::ustring data = this->get_text(); + _pref->set(data.c_str(), _doc, _node); + if (_changeSignal != NULL) { + _changeSignal->emit(); + } + return; +} + +/** + \brief Creates a text box for the string parameter + + Builds a hbox with a label and a text box in it. +*/ +Gtk::Widget * +ParamString::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) +{ + if (_gui_hidden) return NULL; + + 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); + + ParamStringEntry * textbox = new ParamStringEntry(this, doc, node, changeSignal); + textbox->show(); + hbox->pack_start(*textbox, true, true); + + hbox->show(); + + return dynamic_cast(hbox); +} + +} /* namespace Extension */ +} /* namespace Inkscape */ diff --git a/src/extension/param/string.h b/src/extension/param/string.h new file mode 100644 index 000000000..0a1a0f2a3 --- /dev/null +++ b/src/extension/param/string.h @@ -0,0 +1,49 @@ +#ifndef INK_EXTENSION_PARAMSTRING_H_SEEN +#define INK_EXTENSION_PARAMSTRING_H_SEEN + +/* + * Copyright (C) 2005-2007 Authors: + * Ted Gould + * Johan Engelen * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include +#include +#include +#include "parameter.h" + +namespace Inkscape { +namespace Extension { + +class ParamString : public Parameter { +private: + /** \brief Internal value. This should point to a string that has + been allocated in memory. And should be free'd. */ + gchar * _value; +public: + ParamString(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, bool gui_hidden, const gchar * gui_tip, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); + virtual ~ParamString(void); + /** \brief Returns \c _value, with a \i const to protect it. */ + 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); + Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); + void string (std::string &string); +}; + + +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* INK_EXTENSION_PARAMSTRING_H_SEEN */ + +/* + 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/parambool.cpp b/src/extension/parambool.cpp deleted file mode 100644 index b324e6281..000000000 --- a/src/extension/parambool.cpp +++ /dev/null @@ -1,144 +0,0 @@ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include -#include - -#include - -#include "extension.h" -#include "parambool.h" - -namespace Inkscape { -namespace Extension { - -/** \brief Use the superclass' allocator and set the \c _value */ -ParamBool::ParamBool (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), _value(false) -{ - const char * defaultval = NULL; - if (sp_repr_children(xml) != NULL) - defaultval = sp_repr_children(xml)->content(); - - if (defaultval != NULL && (!strcmp(defaultval, "TRUE") || !strcmp(defaultval, "true") || !strcmp(defaultval, "1"))) { - _value = true; - } else { - _value = false; - } - - gchar * pref_name = this->pref_name(); - _value = (bool)prefs_get_int_attribute(PREF_DIR, pref_name, _value); - g_free(pref_name); - - return; -} - -/** \brief A function to set the \c _value - \param in The value to set to - \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 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. -*/ -bool -ParamBool::set( bool in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/ ) -{ - _value = in; - - gchar * prefname = this->pref_name(); - prefs_set_int_attribute(PREF_DIR, prefname, _value == true ? 1 : 0); - g_free(prefname); - - return _value; -} - -/** \brief A check button which is Param aware. It works with the - parameter to change it's value as the check button changes - value. */ -class ParamBoolCheckButton : public Gtk::CheckButton { -private: - /** \brief Param to change */ - ParamBool * _pref; - SPDocument * _doc; - Inkscape::XML::Node * _node; - sigc::signal * _changeSignal; -public: - /** \brief Initialize the check button - \param param Which parameter to adjust on changing the check button - - This function sets the value of the checkbox to be that of the - parameter, and then sets up a callback to \c on_toggle. - */ - ParamBoolCheckButton (ParamBool * param, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : - Gtk::CheckButton(), _pref(param), _doc(doc), _node(node), _changeSignal(changeSignal) { - this->set_active(_pref->get(NULL, NULL) /**\todo fix */); - this->signal_toggled().connect(sigc::mem_fun(this, &ParamBoolCheckButton::on_toggle)); - return; - } - void on_toggle (void); -}; - -/** - \brief A function to respond to the check box changing - - Adjusts the value of the preference to match that in the check box. -*/ -void -ParamBoolCheckButton::on_toggle (void) -{ - _pref->set(this->get_active(), NULL /**\todo fix this */, NULL); - if (_changeSignal != NULL) { - _changeSignal->emit(); - } - return; -} - -/** \brief Return 'true' or 'false' */ -void -ParamBool::string (std::string &string) -{ - if (_value) { - string += "true"; - } else { - string += "false"; - } - - return; -} - -/** - \brief Creates a bool check button for a bool parameter - - Builds a hbox with a label and a check button in it. -*/ -Gtk::Widget * -ParamBool::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - 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, true, true); - - ParamBoolCheckButton * checkbox = new ParamBoolCheckButton(this, doc, node, changeSignal); - checkbox->show(); - hbox->pack_start(*checkbox, false, false); - - hbox->show(); - - return dynamic_cast(hbox); -} - -} /* namespace Extension */ -} /* namespace Inkscape */ diff --git a/src/extension/parambool.h b/src/extension/parambool.h deleted file mode 100644 index 7f1be0fcc..000000000 --- a/src/extension/parambool.h +++ /dev/null @@ -1,46 +0,0 @@ -#ifndef __INK_EXTENSION_PARAMBOOL_H__ -#define __INK_EXTENSION_PARAMBOOL_H__ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include -#include -#include -#include "parameter.h" - -namespace Inkscape { -namespace Extension { - -/** \brief A boolean parameter */ -class ParamBool : public Parameter { -private: - /** \brief Internal value. */ - bool _value; -public: - ParamBool(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - /** \brief Returns \c _value */ - bool get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _value; } - bool set (bool in, SPDocument * doc, Inkscape::XML::Node * node); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::string &string); -}; - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* __INK_EXTENSION_PARAMBOOL_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/paramcolor.cpp b/src/extension/paramcolor.cpp deleted file mode 100644 index cb7437be0..000000000 --- a/src/extension/paramcolor.cpp +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen - * Christopher Brown - * 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 "paramcolor.h" - -#include "color.h" -#include "widgets/sp-color-selector.h" -#include "widgets/sp-color-notebook.h" - - -namespace Inkscape { -namespace Extension { - -void sp_color_param_changed(SPColorSelector *csel, GObject *cp); - - -/** \brief Free the allocated data. */ -ParamColor::~ParamColor(void) -{ - -} - -guint32 -ParamColor::set( guint32 in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/ ) -{ - _value = in; - - gchar * prefname = this->pref_name(); - std::string value; - string(value); - prefs_set_string_attribute(PREF_DIR, prefname, value.c_str()); - g_free(prefname); - - return _value; -} - -/** \brief Initialize the object, to do that, copy the data. */ -ParamColor::ParamColor (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) -{ - const char * defaulthex = NULL; - if (sp_repr_children(xml) != NULL) - defaulthex = 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) - defaulthex = paramval; - - _value = atoi(defaulthex); - - return; -} - -void -ParamColor::string (std::string &string) -{ - char str[16]; - sprintf(str, "%i", _value); - string += str; - return; -} - -Gtk::Widget * -ParamColor::get_widget( SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal * changeSignal ) -{ - _changeSignal = new sigc::signal(*changeSignal); - Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); - SPColorSelector* spColorSelector = (SPColorSelector*)sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK); - - ColorSelector* colorSelector = spColorSelector->base; - if (_value < 1) { - _value = 0xFF000000; - } - SPColor *color = new SPColor( _value ); - float alpha = (_value & 0xff) / 255.0F; - colorSelector->setColorAlpha(*color, alpha); - - hbox->pack_start (*Glib::wrap(&spColorSelector->vbox), true, true, 0); - g_signal_connect(G_OBJECT(spColorSelector), "changed", G_CALLBACK(sp_color_param_changed), (void*)this); - - gtk_widget_show(GTK_WIDGET(spColorSelector)); - hbox->show(); - - return dynamic_cast(hbox); -} - -void -sp_color_param_changed(SPColorSelector *csel, GObject *obj) -{ - const SPColor color = csel->base->getColor(); - float alpha = csel->base->getAlpha(); - - ParamColor* ptr = (ParamColor*)obj; - ptr->set(color.toRGBA32( alpha ), NULL, NULL); - - ptr->_changeSignal->emit(); -} - -}; /* namespace Extension */ -}; /* namespace Inkscape */ diff --git a/src/extension/paramcolor.h b/src/extension/paramcolor.h deleted file mode 100644 index 87c0fdd9c..000000000 --- a/src/extension/paramcolor.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef __INK_EXTENSION_PARAMCOLOR_H__ -#define __INK_EXTENSION_PARAMCOLOR_H__ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include -#include -#include -#include "color.h" -#include "parameter.h" - -namespace Inkscape { -namespace Extension { - -class ParamColor : public Parameter { -private: - guint32 _value; -public: - ParamColor(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - virtual ~ParamColor(void); - /** \brief Returns \c _value, with a \i const to protect it. */ - guint32 get( const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/ ) { return _value; } - guint32 set (guint32 in, SPDocument * doc, Inkscape::XML::Node * node); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::string &string); - sigc::signal * _changeSignal; -}; /* class ParamColor */ - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* __INK_EXTENSION_PARAMCOLOR_H__ */ diff --git a/src/extension/paramdescription.cpp b/src/extension/paramdescription.cpp deleted file mode 100644 index f0c9fd8b7..000000000 --- a/src/extension/paramdescription.cpp +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#ifdef linux // does the dollar sign need escaping when passed as string parameter? -# define ESCAPE_DOLLAR_COMMANDLINE -#endif - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - - -#include "paramdescription.h" - -#include -#include -#include -#include - - -#include - -#include - -#include "extension.h" -#include "prefs-utils.h" - -namespace Inkscape { -namespace Extension { - - -/** \brief Initialize the object, to do that, copy the data. */ -ParamDescription::ParamDescription (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), _value(NULL) -{ - // printf("Building Description\n"); - const char * defaultval = NULL; - if (sp_repr_children(xml) != NULL) - defaultval = sp_repr_children(xml)->content(); - - if (defaultval != NULL) - _value = g_strdup(defaultval); - - return; -} - -/** \brief Create a label for the description */ -Gtk::Widget * -ParamDescription::get_widget (SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal * /*changeSignal*/) -{ - Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_value))); - label->set_line_wrap(); - label->show(); - - Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); - hbox->pack_start(*label, true, true, 5); - hbox->show(); - - return hbox; -} - -} /* namespace Extension */ -} /* namespace Inkscape */ diff --git a/src/extension/paramdescription.h b/src/extension/paramdescription.h deleted file mode 100644 index 13b4e5eae..000000000 --- a/src/extension/paramdescription.h +++ /dev/null @@ -1,43 +0,0 @@ -#ifndef __INK_EXTENSION_PARAMDESCRIPTION_H__ -#define __INK_EXTENSION_PARAMDESCRIPTION_H__ - -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include -#include -#include -#include "parameter.h" - -namespace Inkscape { -namespace Extension { - -/** \brief A description parameter */ -class ParamDescription : public Parameter { -private: - /** \brief Internal value. */ - gchar * _value; -public: - ParamDescription(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); -}; - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* __INK_EXTENSION_PARAMDESCRIPTION_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/paramenum.cpp b/src/extension/paramenum.cpp deleted file mode 100644 index 336b4fd66..000000000 --- a/src/extension/paramenum.cpp +++ /dev/null @@ -1,256 +0,0 @@ -/** \file - * extension parameter for enumerations. - * - * It uses a Gtk:ComboBoxText widget in the extension UI. - */ - -/* - * Author: - * Johan Engelen - * - * Copyright (C) 2006-2007 Johan Engelen - * - * 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 { - -/* For internal use only. - Note that value and guitext MUST be non-NULL. This is ensured by newing only at one location in the code where non-NULL checks are made. */ -class enumentry { -public: - enumentry (Glib::ustring * val, Glib::ustring * text) { - value = val; - guitext = text; - } - ~enumentry() { - delete value; - delete guitext; - } - - Glib::ustring * value; - Glib::ustring * guitext; -}; - - -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") || !strcmp(chname, "_item")) { - Glib::ustring * newguitext = NULL; - Glib::ustring * newvalue = NULL; - const char * contents = sp_repr_children(child_repr)->content(); - if (contents != NULL) - // don't translate when 'item' but do translate when '_item' - // NOTE: internal extensions use build_from_mem and don't need _item but - // still need to include if are to be localized - newguitext = new Glib::ustring( !strcmp(chname, "_item") ? _(contents) : contents ); - else - continue; - - const char * val = child_repr->attribute("value"); - if (val != NULL) - newvalue = new Glib::ustring(val); - else - newvalue = new Glib::ustring(contents); - - if ( (newguitext) && (newvalue) ) { // logical error if this is not true here - choices = g_slist_append( choices, new enumentry(newvalue, newguitext) ); - } - } - 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(xml)->attribute("value"); - - 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)) { - delete (reinterpret_cast(list->data)); - } - 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 */ - - Glib::ustring * settext = NULL; - for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { - enumentry * entr = reinterpret_cast(list->data); - if ( !entr->guitext->compare(in) ) { - settext = entr->value; - break; // break out of for loop - } - } - if (settext) { - if (_value != NULL) g_free(_value); - _value = g_strdup(settext->c_str()); - gchar * prefname = this->pref_name(); - prefs_set_string_attribute(PREF_DIR, prefname, _value); - g_free(prefname); - } - - return _value; -} - -void -ParamComboBox::changed (void) { - -} - - -/** - \brief A function to get the value of the parameter in string form - \return A string with the 'value' as command line argument -*/ -void -ParamComboBox::string (std::string &string) -{ - string += _value; - return; -} - - - - -/** \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; - sigc::signal * _changeSignal; -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, sigc::signal * changeSignal) : - Gtk::ComboBoxText(), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { - 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); - if (_changeSignal != NULL) { - _changeSignal->emit(); - } -} - -/** - \brief Creates a combobox widget for an enumeration parameter -*/ -Gtk::Widget * -ParamComboBox::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - 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, changeSignal)); - // add choice strings: - Glib::ustring * settext = 0; - for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { - enumentry * entr = reinterpret_cast(list->data); - Glib::ustring * text = entr->guitext; - combo->append_text(*text); - if ( !entr->value->compare(_value) ) { - settext = entr->guitext; - } - } - if (settext) combo->set_active_text(*settext); - - combo->show(); - hbox->pack_start(*combo, true, true); - - hbox->show(); - - return dynamic_cast(hbox); -} - - -} /* namespace Extension */ -} /* namespace Inkscape */ diff --git a/src/extension/paramenum.h b/src/extension/paramenum.h deleted file mode 100644 index 5ea4a0196..000000000 --- a/src/extension/paramenum.h +++ /dev/null @@ -1,69 +0,0 @@ -#ifndef INK_EXTENSION_PARAMENUM_H_SEEN -#define INK_EXTENSION_PARAMENUM_H_SEEN - -/** \file - * Enumeration parameter for extensions. - */ - -/* - * Author: - * Johan Engelen - * - * Copyright (C) 2006-2007 Johan Engelen - * - * 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); - virtual ~ParamComboBox(void); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::string &string); - - 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); - - void changed (void); -}; /* class ParamComboBox */ - - - - - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* INK_EXTENSION_PARAMENUM_H_SEEN */ - -/* - 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 deleted file mode 100644 index dd80cf59c..000000000 --- a/src/extension/parameter.cpp +++ /dev/null @@ -1,440 +0,0 @@ -/** \file - * Parameters for extensions. - */ - -/* - * Author: - * Ted Gould - * Johan Engelen - * - * Copyright (C) 2005-2007 Authors - * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#ifdef linux // does the dollar sign need escaping when passed as string parameter? -# define ESCAPE_DOLLAR_COMMANDLINE -#endif - -#include -#include -#include - -#include - -#include "extension.h" -#include "document-private.h" -#include "sp-object.h" -#include "color.h" -#include "widgets/sp-color-selector.h" -#include "widgets/sp-color-notebook.h" - -#include "parameter.h" -#include "parambool.h" -#include "paramcolor.h" -#include "paramdescription.h" -#include "paramenum.h" -#include "paramfloat.h" -#include "paramint.h" -#include "paramnotebook.h" -#include "paramradiobutton.h" -#include "paramstring.h" - -namespace Inkscape { -namespace Extension { - -class ParamEnum : public Parameter { -private: - class Choice { - public: - gchar * _gui_name; - gchar * _value; - Choice(gchar * gui_name, gchar * value) : _gui_name(NULL), _value(NULL) { - if (gui_name != NULL) - _gui_name = g_strdup(_(gui_name)); - if (value != NULL) - _value = g_strdup(value); - return; - }; - ~Choice (void) { - g_free(_gui_name); - g_free(_value); - }; - }; /* class Choice */ - /** \brief Internal value. This should point to a string that has - been allocated in memory. And should be free'd. */ - Choice * _current_choice; - typedef std::list choice_list_t; - choice_list_t _choice_list; -public: - ParamEnum(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - ~ParamEnum(void); - /** \brief Returns \c _value, with a \i const to protect it. */ - const gchar * get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _current_choice != NULL ? _current_choice->_value : NULL; } - const gchar * set (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - Glib::ustring * string (void); -}; /* class ParamEnum */ - -/** - \return None - \brief This function creates a parameter that can be used later. This - is typically done in the creation of the extension and defined - in the XML file describing the extension (it's private so people - have to use the system) :) - \param in_repr The XML describing the parameter - - This function first grabs all of the data out of the Repr and puts - it into local variables. Actually, these are just pointers, and the - data is not duplicated so we need to be careful with it. If there - isn't a name or a type in the XML, then no parameter is created as - the function just returns. - - From this point on, we're pretty committed as we've allocated an - object and we're starting to fill it. The name is set first, and - is created with a strdup to actually allocate memory for it. Then - there is a case statement (roughly because strcmp requires 'ifs') - based on what type of parameter this is. Depending which type it - is, the value is interpreted differently, but they are relatively - straight forward. In all cases the value is set to the default - value from the XML and the type is set to the interpreted type. -*/ -Parameter * -Parameter::make (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext) -{ - const char * name; - const char * type; - const char * guitext; - const char * desc; - const char * scope_str; - Parameter::_scope_t scope = Parameter::SCOPE_USER; - - name = in_repr->attribute("name"); - type = in_repr->attribute("type"); - guitext = in_repr->attribute("gui-text"); - if (guitext == NULL) - guitext = in_repr->attribute("_gui-text"); - desc = in_repr->attribute("gui-description"); - if (desc == NULL) - desc = in_repr->attribute("_gui-description"); - scope_str = in_repr->attribute("scope"); - - /* In this case we just don't have enough information */ - if (name == NULL || type == NULL) { - return NULL; - } - - if (scope_str != NULL) { - if (!strcmp(scope_str, "user")) { - scope = Parameter::SCOPE_USER; - } else if (!strcmp(scope_str, "document")) { - scope = Parameter::SCOPE_DOCUMENT; - } else if (!strcmp(scope_str, "node")) { - scope = Parameter::SCOPE_NODE; - } - } - - Parameter * param = NULL; - if (!strcmp(type, "boolean")) { - param = new ParamBool(name, guitext, desc, scope, in_ext, in_repr); - } else if (!strcmp(type, "int")) { - param = new ParamInt(name, guitext, desc, scope, in_ext, in_repr); - } else if (!strcmp(type, "float")) { - param = new ParamFloat(name, guitext, desc, scope, in_ext, in_repr); - } else if (!strcmp(type, "string")) { - param = new ParamString(name, guitext, desc, scope, in_ext, in_repr); - } else if (!strcmp(type, "description")) { - param = new ParamDescription(name, guitext, desc, scope, in_ext, in_repr); - } else if (!strcmp(type, "enum")) { - 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); - } else if (!strcmp(type, "optiongroup")) { - param = new ParamRadioButton(name, guitext, desc, scope, in_ext, in_repr); - } else if (!strcmp(type, "color")) { - param = new ParamColor(name, guitext, desc, scope, in_ext, in_repr); - } - - /* Note: param could equal NULL */ - return param; -} - - - -/** \brief Wrapper to cast to the object and use it's function. */ -bool -Parameter::get_bool (const SPDocument * doc, const Inkscape::XML::Node * node) -{ - ParamBool * boolpntr = dynamic_cast(this); - if (boolpntr == NULL) - throw Extension::param_not_bool_param(); - return boolpntr->get(doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -int -Parameter::get_int (const SPDocument * doc, const Inkscape::XML::Node * node) -{ - ParamInt * intpntr = dynamic_cast(this); - if (intpntr == NULL) - throw Extension::param_not_int_param(); - return intpntr->get(doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -float -Parameter::get_float (const SPDocument * doc, const Inkscape::XML::Node * node) -{ - ParamFloat * floatpntr = dynamic_cast(this); - if (floatpntr == NULL) - throw Extension::param_not_float_param(); - return floatpntr->get(doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -const gchar * -Parameter::get_string (const SPDocument * doc, const Inkscape::XML::Node * node) -{ - ParamString * stringpntr = dynamic_cast(this); - if (stringpntr == NULL) - throw Extension::param_not_string_param(); - return stringpntr->get(doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -const gchar * -Parameter::get_enum (const SPDocument * doc, const Inkscape::XML::Node * node) -{ - ParamComboBox * param = dynamic_cast(this); - if (param == NULL) - throw Extension::param_not_enum_param(); - return param->get(doc, node); -} - -guint32 -Parameter::get_color(const SPDocument* doc, const Inkscape::XML::Node* node) -{ - ParamColor* param = dynamic_cast(this); - if (param == NULL) - throw Extension::param_not_color_param(); - return param->get(doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -bool -Parameter::set_bool (bool in, SPDocument * doc, Inkscape::XML::Node * node) -{ - ParamBool * boolpntr = dynamic_cast(this); - if (boolpntr == NULL) - throw Extension::param_not_bool_param(); - return boolpntr->set(in, doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -int -Parameter::set_int (int in, SPDocument * doc, Inkscape::XML::Node * node) -{ - ParamInt * intpntr = dynamic_cast(this); - if (intpntr == NULL) - throw Extension::param_not_int_param(); - return intpntr->set(in, doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -float -Parameter::set_float (float in, SPDocument * doc, Inkscape::XML::Node * node) -{ - ParamFloat * floatpntr; - floatpntr = dynamic_cast(this); - if (floatpntr == NULL) - throw Extension::param_not_float_param(); - return floatpntr->set(in, doc, node); -} - -/** \brief Wrapper to cast to the object and use it's function. */ -const gchar * -Parameter::set_string (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node) -{ - ParamString * stringpntr = dynamic_cast(this); - if (stringpntr == NULL) - throw Extension::param_not_string_param(); - return stringpntr->set(in, doc, node); -} -/** \brief Wrapper to cast to the object and use it's function. */ -guint32 -Parameter::set_color (guint32 in, SPDocument * doc, Inkscape::XML::Node * node) -{ - ParamColor* param = dynamic_cast(this); - if (param == NULL) - throw Extension::param_not_color_param(); - return param->set(in, doc, node); -} - - -/** \brief Oop, now that we need a parameter, we need it's name. */ -Parameter::Parameter (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext) : - extension(ext), _name(NULL), _desc(NULL), _scope(scope), _text(NULL) -{ - if (name != NULL) - _name = g_strdup(name); - if (desc != NULL) { - _desc = g_strdup(desc); - // printf("Adding description: '%s' on '%s'\n", _desc, _name); - } - - - if (guitext != NULL) - _text = g_strdup(guitext); - else - _text = g_strdup(name); - - return; -} - -/** \brief Just free the allocated name. */ -Parameter::~Parameter (void) -{ - g_free(_name); - g_free(_text); -} - -/** \brief Build the name to write the parameter from the extension's - ID and the name of this parameter. */ -gchar * -Parameter::pref_name (void) -{ - return g_strdup_printf("%s.%s", extension->get_id(), _name); -} - -Inkscape::XML::Node * -Parameter::find_child (Inkscape::XML::Node * adult) -{ - return sp_repr_lookup_child(adult, "name", _name); -} - -Inkscape::XML::Node * -Parameter::new_child (Inkscape::XML::Node * parent) -{ - Inkscape::XML::Node * retval; - retval = parent->document()->createElement("inkscape:extension-param"); - retval->setAttribute("name", _name); - - parent->appendChild(retval); - return retval; -} - -Inkscape::XML::Node * -Parameter::document_param_node (SPDocument * doc) -{ - Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc); - Inkscape::XML::Node * defs = SP_OBJECT_REPR(SP_DOCUMENT_DEFS(doc)); - Inkscape::XML::Node * params = NULL; - - GQuark const name_quark = g_quark_from_string("inkscape:extension-params"); - - for (Inkscape::XML::Node * child = defs->firstChild(); - child != NULL; - child = child->next()) { - if ((GQuark)child->code() == name_quark && - !strcmp(child->attribute("extension"), extension->get_id())) { - params = child; - break; - } - } - - if (params == NULL) { - params = xml_doc->createElement("inkscape:extension-param"); - params->setAttribute("extension", extension->get_id()); - defs->appendChild(params); - } - - return params; -} - -/** \brief Basically, if there is no widget pass a NULL. */ -Gtk::Widget * -Parameter::get_widget (SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal * /*changeSignal*/) -{ - return NULL; -} - -/** \brief If I'm not sure which it is, just don't return a value. */ -void -Parameter::string (std::string &/*string*/) -{ - return; -} - -void -Parameter::string (std::list &list) -{ - std::string value; - string(value); - if (value == "") { - return; - } - - std::string final; - final += "--"; - final += name(); - final += "="; - final += value; - - list.insert(list.end(), final); - return; -} - - - - - -ParamEnum::ParamEnum (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), _current_choice(NULL) -{ - return; -} - -ParamEnum::~ParamEnum (void) -{ - -} - -/** \brief Return the value as a string */ -Glib::ustring * -ParamEnum::string (void) -{ - Glib::ustring * mystring = new Glib::ustring(""); - *mystring += this->get(NULL, NULL); - return mystring; -} - -Gtk::Widget * -ParamEnum::get_widget (SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/, sigc::signal * /*changeSignal*/) -{ - return NULL; -} - -const gchar * -ParamEnum::set (const gchar * /*in*/, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) -{ - return NULL; -} - - -} /* 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/parameter.h b/src/extension/parameter.h deleted file mode 100644 index 1917ffa98..000000000 --- a/src/extension/parameter.h +++ /dev/null @@ -1,125 +0,0 @@ -#ifndef __INK_EXTENSION_PARAM_H__ -#define __INK_EXTENSION_PARAM_H__ - -/** \file - * Parameters for extensions. - */ - -/* - * Authors: - * Ted Gould - * - * Copyright (C) 2005-2006 Authors - * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -/** \brief The root directory in the preferences database for extension-related parameters. */ -#define PREF_DIR "extensions" - -#include - -#include "xml/document.h" -#include "xml/node.h" -#include "document.h" -#include "extension-forward.h" -#include "prefs-utils.h" - -#include - -#include "color.h" - -namespace Inkscape { -namespace Extension { - -/** \brief A class to represent the parameter of an extension - - This is really a super class that allows them to abstract all - the different types of parameters into some that can be passed - around. There is also a few functions that are used by all the - different parameters. -*/ -class Parameter { -private: - /** \brief Which extension is this parameter attached to? */ - Inkscape::Extension::Extension * extension; - /** \brief The name of this parameter. */ - gchar * _name; - -protected: - /** \brief Description of the parameter. */ - gchar * _desc; - /** \brief List of possible scopes. */ - typedef enum { - SCOPE_USER, /**< Parameter value is saved in the user's configuration file. (default) */ - SCOPE_DOCUMENT, /**< Parameter value is saved in the document. */ - SCOPE_NODE /**< Parameter value is attached to the node. */ - } _scope_t; - /** \brief Scope of the parameter. */ - _scope_t _scope; - /** \brief Text for the GUI selection of this. */ - gchar * _text; - - - /* **** funcs **** */ - gchar * pref_name (void); - Inkscape::XML::Node * find_child (Inkscape::XML::Node * adult); - Inkscape::XML::Node * document_param_node (SPDocument * doc); - Inkscape::XML::Node * new_child (Inkscape::XML::Node * parent); - -public: - Parameter (const gchar * name, - const gchar * guitext, - const gchar * desc, - const Parameter::_scope_t scope, - Inkscape::Extension::Extension * ext); - Parameter (const gchar * name, - const gchar * guitext, - Inkscape::Extension::Extension * ext) { - Parameter(name, guitext, NULL, Parameter::SCOPE_USER, ext); - }; - virtual ~Parameter (void); - bool get_bool (const SPDocument * doc, - const Inkscape::XML::Node * node); - int get_int (const SPDocument * doc, - const Inkscape::XML::Node * node); - float get_float (const SPDocument * doc, - const Inkscape::XML::Node * node); - const gchar * get_string (const SPDocument * doc, - const Inkscape::XML::Node * node); - guint32 get_color (const SPDocument * doc, - const Inkscape::XML::Node * node); - const gchar * get_enum (const SPDocument * doc, - const Inkscape::XML::Node * node); - - bool set_bool (bool in, SPDocument * doc, Inkscape::XML::Node * node); - int set_int (int in, SPDocument * doc, Inkscape::XML::Node * node); - float set_float (float in, SPDocument * doc, Inkscape::XML::Node * node); - const gchar * set_string (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node); - guint32 set_color (guint32 in, SPDocument * doc, Inkscape::XML::Node * node); - - const gchar * name (void) {return _name;} - - static Parameter * make (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext); - virtual Gtk::Widget * get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - gchar const * get_tooltip (void) { return _desc; } - - virtual void string (std::list &list); - virtual void string (std::string &string); -}; - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* __INK_EXTENSION_PARAM_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/paramfloat.cpp b/src/extension/paramfloat.cpp deleted file mode 100644 index ee2284c8c..000000000 --- a/src/extension/paramfloat.cpp +++ /dev/null @@ -1,163 +0,0 @@ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include -#include - -#include - -#include "extension.h" -#include "paramfloat.h" - -namespace Inkscape { -namespace Extension { - - -/** \brief Use the superclass' allocator and set the \c _value */ -ParamFloat::ParamFloat (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), _value(0.0), _min(0.0), _max(10.0) -{ - const char * defaultval = NULL; - if (sp_repr_children(xml) != NULL) - defaultval = sp_repr_children(xml)->content(); - if (defaultval != NULL) { - _value = atof(defaultval); - } - - const char * maxval = xml->attribute("max"); - if (maxval != NULL) - _max = atof(maxval); - - const char * minval = xml->attribute("min"); - if (minval != NULL) - _min = atof(minval); - - _precision = 1; - const char * precision = xml->attribute("precision"); - if (precision != NULL) - _precision = atoi(precision); - - /* We're handling this by just killing both values */ - if (_max < _min) { - _max = 10.0; - _min = 0.0; - } - - gchar * pref_name = this->pref_name(); - _value = prefs_get_double_attribute(PREF_DIR, pref_name, _value); - g_free(pref_name); - - // std::cout << "New Float:: value: " << _value << " max: " << _max << " min: " << _min << std::endl; - - if (_value > _max) _value = _max; - if (_value < _min) _value = _min; - - return; -} - -/** \brief A function to set the \c _value - \param in The value to set to - \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 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. -*/ -float -ParamFloat::set (float in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) -{ - _value = in; - if (_value > _max) _value = _max; - if (_value < _min) _value = _min; - - gchar * prefname = this->pref_name(); - prefs_set_double_attribute(PREF_DIR, prefname, _value); - g_free(prefname); - - return _value; -} - -/** \brief Return the value as a string */ -void -ParamFloat::string (std::string &string) -{ - char startstring[G_ASCII_DTOSTR_BUF_SIZE]; - g_ascii_dtostr(startstring, G_ASCII_DTOSTR_BUF_SIZE, _value); - string += startstring; - return; -} - -/** \brief A class to make an adjustment that uses Extension params */ -class ParamFloatAdjustment : public Gtk::Adjustment { - /** The parameter to adjust */ - ParamFloat * _pref; - SPDocument * _doc; - Inkscape::XML::Node * _node; - sigc::signal * _changeSignal; -public: - /** \brief Make the adjustment using an extension and the string - describing the parameter. */ - ParamFloatAdjustment (ParamFloat * param, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : - Gtk::Adjustment(0.0, param->min(), param->max(), 0.1), _pref(param), _doc(doc), _node(node), _changeSignal(changeSignal) { - this->set_value(_pref->get(NULL, NULL) /* \todo fix */); - this->signal_value_changed().connect(sigc::mem_fun(this, &ParamFloatAdjustment::val_changed)); - return; - }; - - void val_changed (void); -}; /* class ParamFloatAdjustment */ - -/** \brief A function to respond to the value_changed signal from the - adjustment. - - This function just grabs the value from the adjustment and writes - it to the parameter. Very simple, but yet beautiful. -*/ -void -ParamFloatAdjustment::val_changed (void) -{ - //std::cout << "Value Changed to: " << this->get_value() << std::endl; - _pref->set(this->get_value(), _doc, _node); - if (_changeSignal != NULL) { - _changeSignal->emit(); - } - return; -} - -/** - \brief Creates a Float Adjustment for a float parameter - - Builds a hbox with a label and a float adjustment in it. -*/ -Gtk::Widget * -ParamFloat::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - 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, true, true); - - ParamFloatAdjustment * fadjust = Gtk::manage(new ParamFloatAdjustment(this, doc, node, changeSignal)); - Gtk::SpinButton * spin = Gtk::manage(new Gtk::SpinButton(*fadjust, 0.1, _precision)); - spin->show(); - hbox->pack_start(*spin, false, false); - - hbox->show(); - - return dynamic_cast(hbox); -} - - -} /* namespace Extension */ -} /* namespace Inkscape */ diff --git a/src/extension/paramfloat.h b/src/extension/paramfloat.h deleted file mode 100644 index 25edad7b2..000000000 --- a/src/extension/paramfloat.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef INK_EXTENSION_PARAMFLOAT_H_SEEN -#define INK_EXTENSION_PARAMFLOAT_H_SEEN - -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include -#include -#include -#include "parameter.h" - -namespace Inkscape { -namespace Extension { - -class ParamFloat : public Parameter { -private: - /** \brief Internal value. */ - float _value; - float _min; - float _max; - int _precision; -public: - ParamFloat (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - /** \brief Returns \c _value */ - float get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _value; } - float set (float in, SPDocument * doc, Inkscape::XML::Node * node); - float max (void) { return _max; } - float min (void) { return _min; } - float precision (void) { return _precision; } - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::string &string); -}; - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* INK_EXTENSION_PARAMFLOAT_H_SEEN */ - -/* - 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/paramint.cpp b/src/extension/paramint.cpp deleted file mode 100644 index ca938141c..000000000 --- a/src/extension/paramint.cpp +++ /dev/null @@ -1,157 +0,0 @@ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include -#include - -#include - -#include "extension.h" -#include "paramint.h" - -namespace Inkscape { -namespace Extension { - - -/** \brief Use the superclass' allocator and set the \c _value */ -ParamInt::ParamInt (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), _value(0), _min(0), _max(10) -{ - const char * defaultval = NULL; - if (sp_repr_children(xml) != NULL) - defaultval = sp_repr_children(xml)->content(); - if (defaultval != NULL) { - _value = atoi(defaultval); - } - - const char * maxval = xml->attribute("max"); - if (maxval != NULL) - _max = atoi(maxval); - - const char * minval = xml->attribute("min"); - if (minval != NULL) - _min = atoi(minval); - - /* We're handling this by just killing both values */ - if (_max < _min) { - _max = 10; - _min = 0; - } - - gchar * pref_name = this->pref_name(); - _value = prefs_get_int_attribute(PREF_DIR, pref_name, _value); - g_free(pref_name); - - // std::cout << "New Int:: value: " << _value << " max: " << _max << " min: " << _min << std::endl; - - if (_value > _max) _value = _max; - if (_value < _min) _value = _min; - - return; -} - -/** \brief A function to set the \c _value - \param in The value to set to - \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 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. -*/ -int -ParamInt::set (int in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) -{ - _value = in; - if (_value > _max) _value = _max; - if (_value < _min) _value = _min; - - gchar * prefname = this->pref_name(); - prefs_set_int_attribute(PREF_DIR, prefname, _value); - g_free(prefname); - - return _value; -} - -/** \brief A class to make an adjustment that uses Extension params */ -class ParamIntAdjustment : public Gtk::Adjustment { - /** The parameter to adjust */ - ParamInt * _pref; - SPDocument * _doc; - Inkscape::XML::Node * _node; - sigc::signal * _changeSignal; -public: - /** \brief Make the adjustment using an extension and the string - describing the parameter. */ - ParamIntAdjustment (ParamInt * param, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : - Gtk::Adjustment(0.0, param->min(), param->max(), 1.0), _pref(param), _doc(doc), _node(node), _changeSignal(changeSignal) { - this->set_value(_pref->get(NULL, NULL) /* \todo fix */); - this->signal_value_changed().connect(sigc::mem_fun(this, &ParamIntAdjustment::val_changed)); - return; - }; - - void val_changed (void); -}; /* class ParamIntAdjustment */ - -/** \brief A function to respond to the value_changed signal from the - adjustment. - - This function just grabs the value from the adjustment and writes - it to the parameter. Very simple, but yet beautiful. -*/ -void -ParamIntAdjustment::val_changed (void) -{ - //std::cout << "Value Changed to: " << this->get_value() << std::endl; - _pref->set((int)this->get_value(), _doc, _node); - if (_changeSignal != NULL) { - _changeSignal->emit(); - } - return; -} - -/** - \brief Creates a Int Adjustment for a int parameter - - Builds a hbox with a label and a int adjustment in it. -*/ -Gtk::Widget * -ParamInt::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - 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, true, true); - - ParamIntAdjustment * fadjust = Gtk::manage(new ParamIntAdjustment(this, doc, node, changeSignal)); - Gtk::SpinButton * spin = Gtk::manage(new Gtk::SpinButton(*fadjust, 1.0, 0)); - spin->show(); - hbox->pack_start(*spin, false, false); - - hbox->show(); - - return dynamic_cast(hbox); -} - -/** \brief Return the value as a string */ -void -ParamInt::string (std::string &string) -{ - char startstring[32]; - sprintf(startstring, "%d", _value); - string += startstring; - return; -} - -} /* namespace Extension */ -} /* namespace Inkscape */ diff --git a/src/extension/paramint.h b/src/extension/paramint.h deleted file mode 100644 index aa0d05aa7..000000000 --- a/src/extension/paramint.h +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef INK_EXTENSION_PARAMINT_H_SEEN -#define INK_EXTENSION_PARAMINT_H_SEEN - -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include -#include -#include -#include "parameter.h" - -namespace Inkscape { -namespace Extension { - -class ParamInt : public Parameter { -private: - /** \brief Internal value. */ - int _value; - int _min; - int _max; -public: - ParamInt (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - /** \brief Returns \c _value */ - int get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _value; } - int set (int in, SPDocument * doc, Inkscape::XML::Node * node); - int max (void) { return _max; } - int min (void) { return _min; } - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::string &string); -}; - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* INK_EXTENSION_PARAMINT_H_SEEN */ - -/* - 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/paramnotebook.cpp b/src/extension/paramnotebook.cpp deleted file mode 100644 index c80731adc..000000000 --- a/src/extension/paramnotebook.cpp +++ /dev/null @@ -1,412 +0,0 @@ -/** \file - * Notebook and NotebookPage parameters for extensions. - */ - -/* - * 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 - -#include "extension.h" -#include "prefs-utils.h" -#include "document-private.h" -#include "sp-object.h" - -#include "paramnotebook.h" - -/** \brief The root directory in the preferences database for extension - related parameters. */ -#define PREF_DIR "extensions" - -namespace Inkscape { -namespace Extension { - - -// \brief A class to represent the pages of a notebookparameter of an extension -class ParamNotebookPage : public Parameter { -private: - GSList * parameters; /**< A table to store the parameters for this page. - This only gets created if there are parameters on this - page */ - Gtk::Tooltips * _tooltips; - -public: - static ParamNotebookPage * makepage (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext); - - ParamNotebookPage(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - ~ParamNotebookPage(void); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void paramString (std::list &list); - gchar * get_guitext (void) {return _text;}; - -}; /* class ParamNotebookPage */ - - -ParamNotebookPage::ParamNotebookPage (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) -{ - parameters = NULL; - - // Read XML to build page - if (xml != NULL) { - Inkscape::XML::Node *child_repr = sp_repr_children(xml); - while (child_repr != NULL) { - char const * chname = child_repr->name(); - if (chname[0] == '_') // Allow _ for translation of tags - chname++; - if (!strcmp(chname, "param") || !strcmp(chname, "_param")) { - Parameter * param; - param = Parameter::make(child_repr, ext); - if (param != NULL) parameters = g_slist_append(parameters, param); - } - child_repr = sp_repr_next(child_repr); - } - } - - return; -} - -ParamNotebookPage::~ParamNotebookPage (void) -{ - if (_tooltips) delete _tooltips; - //destroy parameters - for (GSList * list = parameters; list != NULL; list = g_slist_next(list)) { - Parameter * param = reinterpret_cast(list->data); - delete param; - } - g_slist_free(parameters); -} - -/** \brief Return the value as a string */ -void -ParamNotebookPage::paramString (std::list &list) -{ - for (GSList * plist = parameters; plist != NULL; plist = g_slist_next(plist)) { - Parameter * param = reinterpret_cast(plist->data); - param->string(list); - } - - return; -} - - -/** - \return None - \brief This function creates a page that can be used later. This - is typically done in the creation of the notebook and defined - in the XML file describing the extension (it's private so people - have to use the system) :) - \param in_repr The XML describing the page - - This function first grabs all of the data out of the Repr and puts - it into local variables. Actually, these are just pointers, and the - data is not duplicated so we need to be careful with it. If there - isn't a name in the XML, then no page is created as - the function just returns. - - From this point on, we're pretty committed as we've allocated an - object and we're starting to fill it. The name is set first, and - is created with a strdup to actually allocate memory for it. Then - there is a case statement (roughly because strcmp requires 'ifs') - based on what type of parameter this is. Depending which type it - is, the value is interpreted differently, but they are relatively - straight forward. In all cases the value is set to the default - value from the XML and the type is set to the interpreted type. -*/ -ParamNotebookPage * -ParamNotebookPage::makepage (Inkscape::XML::Node * in_repr, Inkscape::Extension::Extension * in_ext) -{ - const char * name; - const char * guitext; - const char * desc; - const char * scope_str; - Parameter::_scope_t scope = Parameter::SCOPE_USER; - - name = in_repr->attribute("name"); - guitext = in_repr->attribute("gui-text"); - if (guitext == NULL) - guitext = in_repr->attribute("_gui-text"); - desc = in_repr->attribute("gui-description"); - if (desc == NULL) - desc = in_repr->attribute("_gui-description"); - scope_str = in_repr->attribute("scope"); - - /* In this case we just don't have enough information */ - if (name == NULL) { - return NULL; - } - - if (scope_str != NULL) { - if (!strcmp(scope_str, "user")) { - scope = Parameter::SCOPE_USER; - } else if (!strcmp(scope_str, "document")) { - scope = Parameter::SCOPE_DOCUMENT; - } else if (!strcmp(scope_str, "node")) { - scope = Parameter::SCOPE_NODE; - } - } - - ParamNotebookPage * page = new ParamNotebookPage(name, guitext, desc, scope, in_ext, in_repr); - - /* Note: page could equal NULL */ - return page; -} - - - -/** - \brief Creates a notebookpage widget for a notebook - - Builds a notebook page (a vbox) and puts parameters on it. -*/ -Gtk::Widget * -ParamNotebookPage::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - if (!_tooltips) _tooltips = new Gtk::Tooltips(); - - Gtk::VBox * vbox = Gtk::manage(new Gtk::VBox); - vbox->set_border_width(5); - - // add parameters onto page (if any) - for (GSList * list = parameters; list != NULL; list = g_slist_next(list)) { - Parameter * param = reinterpret_cast(list->data); - Gtk::Widget * widg = param->get_widget(doc, node, changeSignal); - gchar const * tip = param->get_tooltip(); - - vbox->pack_start(*widg, true, true, 2); - if (tip != NULL) { - _tooltips->set_tip(*widg, Glib::ustring(tip)); - } - } - - vbox->show(); - - return dynamic_cast(vbox); -} - - - - - - - - - -ParamNotebook::ParamNotebook (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) -{ - pages = NULL; - - // Read XML tree to add pages: - if (xml != NULL) { - Inkscape::XML::Node *child_repr = sp_repr_children(xml); - while (child_repr != NULL) { - char const * chname = child_repr->name(); - if (chname[0] == '_') // Allow _ for translation of tags - chname++; - if (!strcmp(chname, "page")) { - ParamNotebookPage * page; - page = ParamNotebookPage::makepage(child_repr, ext); - if (page != NULL) pages = g_slist_append(pages, page); - } - child_repr = sp_repr_next(child_repr); - } - } - - // Initialize _value with the current page - const char * defaultval = NULL; - // set first page as default - if (pages != NULL) { - ParamNotebookPage * defpage = reinterpret_cast(pages->data); - defaultval = defpage->name(); - } - - 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; -} - -ParamNotebook::~ParamNotebook (void) -{ - //destroy pages - for (GSList * list = pages; list != NULL; list = g_slist_next(list)) { - ParamNotebookPage * page = reinterpret_cast(list->data); - delete page; - } - g_slist_free(pages); - - g_free(_value); -} - - -/** \brief A function to set the \c _value - \param in The number of the page which value must be 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 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 * -ParamNotebook::set (const int in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) -{ - ParamNotebookPage * page = NULL; - int i = 0; - for (GSList * list = pages; (list != NULL) && (i <= in); list = g_slist_next(list)) { - page = reinterpret_cast(list->data); - i++; - } - - if (page == NULL) return _value; - - if (_value != NULL) g_free(_value); - _value = g_strdup(page->name()); - - 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 -*/ -void -ParamNotebook::string (std::list &list) -{ - std::string param_string; - param_string += "--"; - param_string += name(); - param_string += "="; - - param_string += "\""; - param_string += _value; // the name of the current page - param_string += "\""; - list.insert(list.end(), param_string); - - for (GSList * pglist = pages; pglist != NULL; pglist = g_slist_next(pglist)) { - ParamNotebookPage * page = reinterpret_cast(pglist->data); - page->paramString(list); - } - - return; -} - -/** \brief A special category of Gtk::Notebook to handle notebook parameters */ -class ParamNotebookWdg : public Gtk::Notebook { -private: - ParamNotebook * _pref; - SPDocument * _doc; - Inkscape::XML::Node * _node; -public: - /** \brief Build a notebookpage preference for the given parameter - \param pref Where to get the string (pagename) from, and where to put it - when it changes. - */ - ParamNotebookWdg (ParamNotebook * pref, SPDocument * doc, Inkscape::XML::Node * node) : - Gtk::Notebook(), _pref(pref), _doc(doc), _node(node), activated(false) { - // don't have to set the correct page: this is done in ParamNotebook::get_widget. - // hook function - this->signal_switch_page().connect(sigc::mem_fun(this, &ParamNotebookWdg::changed_page)); - return; - }; - void changed_page(GtkNotebookPage *page, guint pagenum); - bool activated; -}; - -/** \brief Respond to the selected page of notebook changing - This function responds to the changing by reporting it to - ParamNotebook. The change is only reported when the notebook - is actually visible. This to exclude 'fake' changes when the - notebookpages are added or removed. -*/ -void -ParamNotebookWdg::changed_page(GtkNotebookPage */*page*/, - guint pagenum) -{ - if (is_visible()) { - _pref->set((int)pagenum, _doc, _node); - } - return; -} - - - -/** - \brief Creates a Notebook widget for a notebook parameter - - Builds a notebook and puts pages in it. -*/ -Gtk::Widget * -ParamNotebook::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - ParamNotebookWdg * nb = Gtk::manage(new ParamNotebookWdg(this, doc, node)); - - // add pages (if any) - int i = -1; - int pagenr = i; - for (GSList * list = pages; list != NULL; list = g_slist_next(list)) { - i++; - ParamNotebookPage * page = reinterpret_cast(list->data); - Gtk::Widget * widg = page->get_widget(doc, node, changeSignal); - nb->append_page(*widg, _(page->get_guitext())); - if (!strcmp(_value, page->name())) { - pagenr = i; // this is the page to be displayed? - } - } - - nb->show(); - - if (pagenr >= 0) nb->set_current_page(pagenr); - - return dynamic_cast(nb); -} - - -} /* 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/paramnotebook.h b/src/extension/paramnotebook.h deleted file mode 100644 index 7f976113a..000000000 --- a/src/extension/paramnotebook.h +++ /dev/null @@ -1,68 +0,0 @@ -#ifndef INK_EXTENSION_PARAMNOTEBOOK_H_SEEN -#define INK_EXTENSION_PARAMNOTEBOOK_H_SEEN - -/** \file - * Notebook 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 ParamNotebook : 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 name of the current page. */ - gchar * _value; - - GSList * pages; /**< A table to store the pages with parameters for this notebook. - This only gets created if there are pages in this - notebook */ -public: - ParamNotebook(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - virtual ~ParamNotebook(void); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::list &list); - - const gchar * get (const SPDocument * /*doc*/, const Inkscape::XML::Node * /*node*/) { return _value; } - const gchar * set (const int in, SPDocument * doc, Inkscape::XML::Node * node); -}; /* class ParamNotebook */ - - - - - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* INK_EXTENSION_PARAMNOTEBOOK_H_SEEN */ - -/* - 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/paramradiobutton.cpp b/src/extension/paramradiobutton.cpp deleted file mode 100644 index 5fce66910..000000000 --- a/src/extension/paramradiobutton.cpp +++ /dev/null @@ -1,269 +0,0 @@ -/** \file - * extension parameter for radiobuttons. - * - * It uses a Gtk:ComboBoxText widget in the extension UI. - */ - -/* - * Author: - * Johan Engelen - * - * Copyright (C) 2006-2007 Johan Engelen - * - * 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 - -#include "extension.h" -#include "prefs-utils.h" -#include "document-private.h" -#include "sp-object.h" - -#include "paramradiobutton.h" - -/** \brief The root directory in the preferences database for extension - related parameters. */ -#define PREF_DIR "extensions" - -namespace Inkscape { -namespace Extension { - -/* For internal use only. - Note that value and guitext MUST be non-NULL. This is ensured by newing only at one location in the code where non-NULL checks are made. */ -class optionentry { -public: - optionentry (Glib::ustring * val, Glib::ustring * text) { - value = val; - guitext = text; - } - ~optionentry() { - delete value; - delete guitext; - } - - Glib::ustring * value; - Glib::ustring * guitext; -}; - -ParamRadioButton::ParamRadioButton (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, "option") || !strcmp(chname, "_option")) { - Glib::ustring * newguitext = NULL; - Glib::ustring * newvalue = NULL; - const char * contents = sp_repr_children(child_repr)->content(); - if (contents != NULL) - // don't translate when 'option' but do translate when '_option' - newguitext = new Glib::ustring( !strcmp(chname, "_option") ? _(contents) : contents ); - else - continue; - - const char * val = child_repr->attribute("value"); - if (val != NULL) - newvalue = new Glib::ustring(val); - else - newvalue = new Glib::ustring(contents); - - if ( (newguitext) && (newvalue) ) { // logical error if this is not true here - choices = g_slist_append( choices, new optionentry(newvalue, newguitext) ); - } - } - 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 (choices) - defaultval = ((optionentry*) choices->data)->value->c_str(); - - 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; -} - -ParamRadioButton::~ParamRadioButton (void) -{ - //destroy choice strings - for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { - delete (reinterpret_cast(list->data)); - } - 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 * -ParamRadioButton::set (const gchar * in, SPDocument * /*doc*/, Inkscape::XML::Node * /*node*/) -{ - if (in == NULL) return NULL; /* Can't have NULL string */ - - Glib::ustring * settext = NULL; - for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { - optionentry * entr = reinterpret_cast(list->data); - if ( !entr->guitext->compare(in) ) { - settext = entr->value; - break; // break out of for loop - } - } - if (settext) { - if (_value != NULL) g_free(_value); - _value = g_strdup(settext->c_str()); - gchar * prefname = this->pref_name(); - prefs_set_string_attribute(PREF_DIR, prefname, _value); - g_free(prefname); - } - - return _value; -} - - -/** - \brief A function to get the current value of the parameter in a string form - \return A string with the 'value' as command line argument -*/ -void -ParamRadioButton::string (std::string &string) -{ - string += _value; - return; -} - -/** \brief A special radiobutton class to use in ParamRadioButton */ -class ParamRadioButtonWdg : public Gtk::RadioButton { -private: - ParamRadioButton * _pref; - SPDocument * _doc; - Inkscape::XML::Node * _node; - sigc::signal * _changeSignal; -public: - /** \brief Build a string preference for the given parameter - \param pref Where to put the radiobutton's string when it is selected. - */ - ParamRadioButtonWdg ( Gtk::RadioButtonGroup& group, const Glib::ustring& label, - ParamRadioButton * pref, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal ) : - Gtk::RadioButton(group, label), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { - add_changesignal(); - }; - ParamRadioButtonWdg ( const Glib::ustring& label, - ParamRadioButton * pref, SPDocument * doc, Inkscape::XML::Node * node , sigc::signal * changeSignal) : - Gtk::RadioButton(label), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { - add_changesignal(); - }; - void add_changesignal() { - this->signal_toggled().connect(sigc::mem_fun(this, &ParamRadioButtonWdg::changed)); - }; - void changed (void); -}; - -/** \brief Respond to the selected radiobutton changing - - This function responds to the radiobutton selection changing by grabbing the value - from the text box and putting it in the parameter. -*/ -void -ParamRadioButtonWdg::changed (void) -{ - if (this->get_active()) { - Glib::ustring data = this->get_label(); - _pref->set(data.c_str(), _doc, _node); - } - if (_changeSignal != NULL) { - _changeSignal->emit(); - } -} - - - -/** - \brief Creates a combobox widget for an enumeration parameter -*/ -Gtk::Widget * -ParamRadioButton::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4)); - Gtk::VBox * vbox = Gtk::manage(new Gtk::VBox(false, 0)); - - Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP)); - label->show(); - hbox->pack_start(*label, false, false); - - // add choice strings as radiobuttons - // and select last selected option (_value) - bool first = true; - ParamRadioButtonWdg * radio; - Gtk::RadioButtonGroup group; - for (GSList * list = choices; list != NULL; list = g_slist_next(list)) { - optionentry * entr = reinterpret_cast(list->data); - Glib::ustring * text = entr->guitext; - if (first) { - radio = Gtk::manage(new ParamRadioButtonWdg(*text, this, doc, node, changeSignal)); - group = radio->get_group(); - first = false; - } else { - radio = Gtk::manage(new ParamRadioButtonWdg(group, *text, this, doc, node, changeSignal)); - } - radio->show(); - vbox->pack_start(*radio, true, true); - if (!entr->value->compare(_value)) { - radio->set_active(); - } - } - - vbox->show(); - hbox->pack_end(*vbox, false, false); - hbox->show(); - - - return dynamic_cast(hbox); -} - - -} /* namespace Extension */ -} /* namespace Inkscape */ - diff --git a/src/extension/paramradiobutton.h b/src/extension/paramradiobutton.h deleted file mode 100644 index d7d034d60..000000000 --- a/src/extension/paramradiobutton.h +++ /dev/null @@ -1,57 +0,0 @@ -#ifndef INK_EXTENSION_PARAMRADIOBUTTON_H_SEEN -#define INK_EXTENSION_PARAMRADIOBUTTON_H_SEEN - -/** \file - * Radiobutton parameter for extensions. - */ - -/* - * Author: - * Johan Engelen - * - * Copyright (C) 2006-2007 Johan Engelen - * - * 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 radiobutton parameter of an extension -class ParamRadioButton : 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: - ParamRadioButton(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - virtual ~ParamRadioButton(void); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::string &string); - - 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 ParamRadioButton */ - - - - - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* INK_EXTENSION_PARAMRADIOBUTTON_H_SEEN */ - diff --git a/src/extension/paramstring.cpp b/src/extension/paramstring.cpp deleted file mode 100644 index 953cb7daf..000000000 --- a/src/extension/paramstring.cpp +++ /dev/null @@ -1,153 +0,0 @@ -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include -#include - -#include - -#include "extension.h" -#include "paramstring.h" - -namespace Inkscape { -namespace Extension { - - -/** \brief Free the allocated data. */ -ParamString::~ParamString(void) -{ - g_free(_value); -} - -/** \brief A function to set the \c _value - \param in The value to set to - \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 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 * -ParamString::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 Return the value as a string */ -void -ParamString::string (std::string &string) -{ - if (_value == NULL) - return; - - string += _value; - return; -} - -/** \brief Initialize the object, to do that, copy the data. */ -ParamString::ParamString (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), _value(NULL) -{ - const char * defaultval = NULL; - if (sp_repr_children(xml) != NULL) - defaultval = 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); - - return; -} - -/** \brief A special category of Gtk::Entry to handle string parameteres */ -class ParamStringEntry : public Gtk::Entry { -private: - ParamString * _pref; - SPDocument * _doc; - Inkscape::XML::Node * _node; - sigc::signal * _changeSignal; -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. - */ - ParamStringEntry (ParamString * pref, SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) : - Gtk::Entry(), _pref(pref), _doc(doc), _node(node), _changeSignal(changeSignal) { - if (_pref->get(NULL, NULL) != NULL) - this->set_text(Glib::ustring(_pref->get(NULL, NULL))); - this->signal_changed().connect(sigc::mem_fun(this, &ParamStringEntry::changed_text)); - }; - void changed_text (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 -ParamStringEntry::changed_text (void) -{ - Glib::ustring data = this->get_text(); - _pref->set(data.c_str(), _doc, _node); - if (_changeSignal != NULL) { - _changeSignal->emit(); - } - return; -} - -/** - \brief Creates a text box for the string parameter - - Builds a hbox with a label and a text box in it. -*/ -Gtk::Widget * -ParamString::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal) -{ - 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); - - ParamStringEntry * textbox = new ParamStringEntry(this, doc, node, changeSignal); - textbox->show(); - hbox->pack_start(*textbox, true, true); - - hbox->show(); - - return dynamic_cast(hbox); -} - -} /* namespace Extension */ -} /* namespace Inkscape */ diff --git a/src/extension/paramstring.h b/src/extension/paramstring.h deleted file mode 100644 index 14a3f622f..000000000 --- a/src/extension/paramstring.h +++ /dev/null @@ -1,49 +0,0 @@ -#ifndef INK_EXTENSION_PARAMSTRING_H_SEEN -#define INK_EXTENSION_PARAMSTRING_H_SEEN - -/* - * Copyright (C) 2005-2007 Authors: - * Ted Gould - * Johan Engelen * - * Released under GNU GPL, read the file 'COPYING' for more information - */ - -#include -#include -#include -#include "parameter.h" - -namespace Inkscape { -namespace Extension { - -class ParamString : public Parameter { -private: - /** \brief Internal value. This should point to a string that has - been allocated in memory. And should be free'd. */ - gchar * _value; -public: - ParamString(const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml); - virtual ~ParamString(void); - /** \brief Returns \c _value, with a \i const to protect it. */ - 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); - Gtk::Widget * get_widget(SPDocument * doc, Inkscape::XML::Node * node, sigc::signal * changeSignal); - void string (std::string &string); -}; - - -} /* namespace Extension */ -} /* namespace Inkscape */ - -#endif /* INK_EXTENSION_PARAMSTRING_H_SEEN */ - -/* - 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/prefdialog.h b/src/extension/prefdialog.h index 195ce8ea5..0a10881d6 100644 --- a/src/extension/prefdialog.h +++ b/src/extension/prefdialog.h @@ -19,7 +19,7 @@ #include #include "execution-env.h" -#include "parameter.h" +#include "param/parameter.h" namespace Inkscape { namespace Extension {