src/extension/paramenum.cpp

   1 /** \file
   2  * extension parameter for enumerations.
   3  *
   4  * It uses a Gtk:ComboBoxText widget in the extension UI.
   5  */
   6
   7 /*
   8  * Author:
   9  *   Johan Engelen <johan@shouraizou.nl>
  10  *
  11  * Copyright (C) 2006-2007 Johan Engelen
  12  *
  13  * Released under GNU GPL, read the file 'COPYING' for more information
  14  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 # include "config.h"
  18 #endif
  19
  20
  21 #include <gtkmm/box.h>
  22 #include <gtkmm/comboboxtext.h>
  23 #include <gtkmm/tooltips.h>
  24 #include <gtkmm/label.h>
  25
  26 #include <glibmm/i18n.h>
  27
  28 #include <xml/node.h>
  29
  30 #include "extension.h"
  31 #include "prefs-utils.h"
  32 #include "document-private.h"
  33 #include "sp-object.h"
  34
  35 #include "paramenum.h"
  36
  37 /** \brief  The root directory in the preferences database for extension
  38             related parameters. */
  39 #define PREF_DIR "extensions"
  40
  41 namespace Inkscape {
  42 namespace Extension {
  43
  44 /* For internal use only.
  45      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. */
  46 class enumentry {
  47 public:
  48     enumentry (Glib::ustring * val, Glib::ustring * text) {
  49         value = val;
  50         guitext = text;
  51     }
  52     ~enumentry() {
  53         delete value;
  54         delete guitext;
  55     }
  56
  57     Glib::ustring * value;
  58     Glib::ustring * guitext;
  59 };
  60
  61
  62 ParamComboBox::ParamComboBox (const gchar * name, const gchar * guitext, const gchar * desc, const Parameter::_scope_t scope, Inkscape::Extension::Extension * ext, Inkscape::XML::Node * xml) :
  63     Parameter(name, guitext, desc, scope, ext)
  64 {
  65     choices = NULL;
  66     _value = NULL;
  67
  68     // Read XML tree to add enumeration items:
  69     // printf("Extension Constructor: ");
  70     if (xml != NULL) {
  71         Inkscape::XML::Node *child_repr = sp_repr_children(xml);
  72         while (child_repr != NULL) {
  73             char const * chname = child_repr->name();
  74             if (!strcmp(chname, "item")) {
  75                 Glib::ustring * newguitext = NULL;
  76                 Glib::ustring * newvalue = NULL;
  77                 const char * contents = sp_repr_children(child_repr)->content();
  78                 if (contents != NULL)
  79                      newguitext = new Glib::ustring( _(contents) );
  80                 const char * val = child_repr->attribute("value");
  81                 if (val != NULL)
  82                     newvalue = new Glib::ustring(val);
  83                 if ( (newguitext) && (newvalue) ) {
  84                     choices = g_slist_append( choices, new enumentry(newvalue, newguitext) );
  85                 }
  86             }
  87             child_repr = sp_repr_next(child_repr);
  88         }
  89     }
  90
  91     // Initialize _value with the default value from xml
  92     // for simplicity : default to the contents of the first xml-child
  93     const char * defaultval = NULL;
  94     if (sp_repr_children(sp_repr_children(xml)) != NULL)
  95         defaultval = sp_repr_children(xml)->attribute("value");
  96
  97     gchar * pref_name = this->pref_name();
  98     const gchar * paramval = prefs_get_string_attribute(PREF_DIR, pref_name);
  99     g_free(pref_name);
 100
 101     if (paramval != NULL)
 102         defaultval = paramval;
 103     if (defaultval != NULL)
 104         _value = g_strdup(defaultval);  // allocate space for _value
 105
 106     return;
 107 }
 108
 109 ParamComboBox::~ParamComboBox (void)
 110 {
 111     //destroy choice strings
 112     for (GSList * list = choices; list != NULL; list = g_slist_next(list)) {
 113         delete (reinterpret_cast<enumentry *>(list->data));
 114     }
 115     g_slist_free(choices);
 116
 117     g_free(_value);
 118 }
 119
 120
 121 /** \brief  A function to set the \c _value
 122     \param  in   The value to set
 123     \param  doc  A document that should be used to set the value.
 124     \param  node The node where the value may be placed
 125
 126     This function sets ONLY the internal value, but it also sets the value
 127     in the preferences structure.  To put it in the right place, \c PREF_DIR
 128     and \c pref_name() are used.
 129
 130     To copy the data into _value the old memory must be free'd first.
 131     It is important to note that \c g_free handles \c NULL just fine.  Then
 132     the passed in value is duplicated using \c g_strdup().
 133 */
 134 const gchar *
 135 ParamComboBox::set (const gchar * in, SPDocument * doc, Inkscape::XML::Node * node)
 136 {
 137     if (in == NULL) return NULL; /* Can't have NULL string */
 138
 139     Glib::ustring * settext = NULL;
 140     for (GSList * list = choices; list != NULL; list = g_slist_next(list)) {
 141         enumentry * entr = reinterpret_cast<enumentry *>(list->data);
 142         if ( !entr->guitext->compare(in) ) {
 143             settext = entr->value;
 144             break;  // break out of for loop
 145         }
 146     }
 147     if (settext) {
 148         if (_value != NULL) g_free(_value);
 149         _value = g_strdup(settext->c_str());
 150         gchar * prefname = this->pref_name();
 151         prefs_set_string_attribute(PREF_DIR, prefname, _value);
 152         g_free(prefname);
 153     }
 154
 155     return _value;
 156 }
 157
 158
 159 /**
 160     \brief  A function to get the value of the parameter in string form
 161     \return A string with the 'value' as command line argument
 162 */
 163 Glib::ustring *
 164 ParamComboBox::string (void)
 165 {
 166     Glib::ustring * param_string = new Glib::ustring("");
 167
 168     *param_string += "\"";
 169     *param_string += _value;
 170     *param_string += "\"";
 171
 172     return param_string;
 173 }
 174
 175 /** \brief  A special category of Gtk::Entry to handle string parameteres */
 176 class ParamComboBoxEntry : public Gtk::ComboBoxText {
 177 private:
 178     ParamComboBox * _pref;
 179     SPDocument * _doc;
 180     Inkscape::XML::Node * _node;
 181 public:
 182     /** \brief  Build a string preference for the given parameter
 183         \param  pref  Where to get the string from, and where to put it
 184                       when it changes.
 185     */
 186     ParamComboBoxEntry (ParamComboBox * pref, SPDocument * doc, Inkscape::XML::Node * node) :
 187         Gtk::ComboBoxText(), _pref(pref), _doc(doc), _node(node) {
 188         this->signal_changed().connect(sigc::mem_fun(this, &ParamComboBoxEntry::changed));
 189     };
 190     void changed (void);
 191 };
 192
 193 /** \brief  Respond to the text box changing
 194
 195     This function responds to the box changing by grabbing the value
 196     from the text box and putting it in the parameter.
 197 */
 198 void
 199 ParamComboBoxEntry::changed (void)
 200 {
 201     Glib::ustring data = this->get_active_text();
 202     _pref->set(data.c_str(), _doc, _node);
 203     return;
 204 }
 205
 206
 207
 208 /**
 209     \brief  Creates a combobox widget for an enumeration parameter
 210 */
 211 Gtk::Widget *
 212 ParamComboBox::get_widget (SPDocument * doc, Inkscape::XML::Node * node)
 213 {
 214     Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4));
 215
 216     Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_LEFT));
 217     label->show();
 218     hbox->pack_start(*label, false, false);
 219
 220     ParamComboBoxEntry * combo = Gtk::manage(new ParamComboBoxEntry(this, doc, node));
 221     // add choice strings:
 222     Glib::ustring * settext = 0;
 223     for (GSList * list = choices; list != NULL; list = g_slist_next(list)) {
 224         enumentry * entr = reinterpret_cast<enumentry *>(list->data);
 225         Glib::ustring * text = entr->guitext;
 226         combo->append_text(*text);
 227         if ( !entr->value->compare(_value) ) {
 228             settext = entr->guitext;
 229         }
 230     }
 231     if (settext) combo->set_active_text(*settext);
 232
 233     combo->show();
 234     hbox->pack_start(*combo, true, true);
 235
 236     hbox->show();
 237
 238     return dynamic_cast<Gtk::Widget *>(hbox);
 239 }
 240
 241
 242 }  /* namespace Extension */
 243 }  /* namespace Inkscape */
 244