void SPTextPath::build(SPDocument *doc, Inkscape::XML::Node *repr) {
this->readAttr( "x" );
this->readAttr( "y" );
this->readAttr( "dx" );
this->readAttr( "dy" );
this->readAttr( "rotate" );
this->readAttr( "startOffset" );
this->readAttr( "xlink:href" );
bool no_content = true;
for (Inkscape::XML::Node* rch = repr->firstChild() ; rch != NULL; rch = rch->next()) {
if ( rch->type() == Inkscape::XML::TEXT_NODE )
{
no_content = false;
break;
}
}
if ( no_content ) {
Inkscape::XML::Document *xml_doc = doc->getReprDoc();
Inkscape::XML::Node* rch = xml_doc->createTextNode("");
repr->addChild(rch, NULL);
}
SPItem::build(doc, repr);
}
Inkscape::XML::Node *Parameter::document_param_node(SPDocument * doc)
{
Inkscape::XML::Document *xml_doc = doc->getReprDoc();
Inkscape::XML::Node * defs = doc->getDefs()->getRepr();
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);
Inkscape::GC::release(params);
}
return params;
}
void SPObject::build(SPDocument *document, Inkscape::XML::Node *repr) {
SPObject* object = this;
/* Nothing specific here */
debug("id=%p, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
object->readAttr("xml:space");
object->readAttr("inkscape:label");
object->readAttr("inkscape:collect");
for (Inkscape::XML::Node *rchild = repr->firstChild() ; rchild != NULL; rchild = rchild->next()) {
const std::string typeString = NodeTraits::get_type_string(*rchild);
SPObject* child = SPFactory::instance().createObject(typeString);
if (child == NULL) {
// Currenty, there are many node types that do not have
// corresponding classes in the SPObject tree.
// (rdf:RDF, inkscape:clipboard, ...)
// Thus, simply ignore this case for now.
continue;
}
object->attach(child, object->lastChild());
sp_object_unref(child, NULL);
child->invoke_build(document, rchild, object->cloned);
}
}
static void
sp_textpath_build(SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr)
{
//SPTextPath *textpath = SP_TEXTPATH(object);
sp_object_read_attr(object, "x");
sp_object_read_attr(object, "y");
sp_object_read_attr(object, "dx");
sp_object_read_attr(object, "dy");
sp_object_read_attr(object, "rotate");
sp_object_read_attr(object, "startOffset");
sp_object_read_attr(object, "xlink:href");
bool no_content=true;
for (Inkscape::XML::Node* rch = repr->firstChild() ; rch != NULL; rch = rch->next()) {
if ( rch->type() == Inkscape::XML::TEXT_NODE ) {no_content=false;break;}
}
if ( no_content ) {
Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
Inkscape::XML::Node* rch = xml_doc->createTextNode("");
repr->addChild(rch, NULL);
}
if (((SPObjectClass *) textpath_parent_class)->build)
((SPObjectClass *) textpath_parent_class)->build(object, doc, repr);
}
Inkscape::XML::Node *
Effect::find_menu (Inkscape::XML::Node * menustruct, const gchar *name)
{
if (menustruct == NULL) return NULL;
for (Inkscape::XML::Node * child = menustruct;
child != NULL;
child = child->next()) {
if (!strcmp(child->name(), name)) {
return child;
}
Inkscape::XML::Node * firstchild = child->firstChild();
if (firstchild != NULL) {
Inkscape::XML::Node *found = find_menu (firstchild, name);
if (found)
return found;
}
}
return NULL;
}
/**
* Using depth-first search, build up a string by concatenating all SPStrings
* found in the tree starting at the root
*/
static void
build_string_from_root(Inkscape::XML::Node *root, Glib::ustring *retString)
{
if (root && retString) {
// Stop and concatenate when a SPString is found
if (root->type() == Inkscape::XML::TEXT_NODE) {
*retString += (root->content());
debug("%s", retString->c_str());
// Otherwise, continue searching down the tree (with the assumption that no children nodes
// of a SPString are actually legal)
} else {
Inkscape::XML::Node *childNode;
for (childNode = root->firstChild(); childNode; childNode = childNode->next()) {
build_string_from_root(childNode, retString);
}
}
}
}
/**
* Clears the gradient's svg:stop children from its repr.
*/
void
sp_gradient_repr_clear_vector(SPGradient *gr)
{
Inkscape::XML::Node *repr = gr->getRepr();
/* Collect stops from original repr */
GSList *sl = NULL;
for (Inkscape::XML::Node *child = repr->firstChild() ; child != NULL; child = child->next() ) {
if (!strcmp(child->name(), "svg:stop")) {
sl = g_slist_prepend(sl, child);
}
}
/* Remove all stops */
while (sl) {
/** \todo
* fixme: This should work, unless we make gradient
* into generic group.
*/
sp_repr_unparent((Inkscape::XML::Node *)sl->data);
sl = g_slist_remove(sl, sl->data);
}
}
SPItem *SPUse::unlink() {
Inkscape::XML::Node *repr = this->getRepr();
if (!repr) {
return NULL;
}
Inkscape::XML::Node *parent = repr->parent();
SPDocument *document = this->document;
Inkscape::XML::Document *xml_doc = document->getReprDoc();
// Track the ultimate source of a chain of uses.
SPItem *orig = this->root();
if (!orig) {
return NULL;
}
// Calculate the accumulated transform, starting from the original.
Geom::Affine t = this->get_root_transform();
Inkscape::XML::Node *copy = NULL;
if (dynamic_cast<SPSymbol *>(orig)) { // make a group, copy children
copy = xml_doc->createElement("svg:g");
for (Inkscape::XML::Node *child = orig->getRepr()->firstChild() ; child != NULL; child = child->next()) {
Inkscape::XML::Node *newchild = child->duplicate(xml_doc);
copy->appendChild(newchild);
}
} else { // just copy
copy = orig->getRepr()->duplicate(xml_doc);
}
// Add the duplicate repr just after the existing one.
parent->addChild(copy, repr);
// Retrieve the SPItem of the resulting repr.
SPObject *unlinked = document->getObjectByRepr(copy);
// Merge style from the use.
unlinked->style->merge( this->style );
unlinked->style->cascade( unlinked->parent->style );
unlinked->updateRepr();
// Hold onto our SPObject and repr for now.
sp_object_ref(this, NULL);
Inkscape::GC::anchor(repr);
// Remove ourselves, not propagating delete events to avoid a
// chain-reaction with other elements that might reference us.
this->deleteObject(false);
// Give the copy our old id and let go of our old repr.
copy->setAttribute("id", repr->attribute("id"));
Inkscape::GC::release(repr);
// Remove tiled clone attrs.
copy->setAttribute("inkscape:tiled-clone-of", NULL);
copy->setAttribute("inkscape:tile-w", NULL);
copy->setAttribute("inkscape:tile-h", NULL);
copy->setAttribute("inkscape:tile-cx", NULL);
copy->setAttribute("inkscape:tile-cy", NULL);
// Establish the succession and let go of our object.
this->setSuccessor(unlinked);
sp_object_unref(this, NULL);
SPItem *item = dynamic_cast<SPItem *>(unlinked);
g_assert(item != NULL);
// Set the accummulated transform.
{
Geom::Affine nomove(Geom::identity());
// Advertise ourselves as not moving.
item->doWriteTransform(item->getRepr(), t, &nomove);
}
return item;
}
Effect::Effect (Inkscape::XML::Node * in_repr, Implementation::Implementation * in_imp)
: Extension(in_repr, in_imp),
_id_noprefs(Glib::ustring(get_id()) + ".noprefs"),
_name_noprefs(Glib::ustring(_(get_name())) + _(" (No preferences)")),
_verb(get_id(), get_name(), NULL, NULL, this, true),
_verb_nopref(_id_noprefs.c_str(), _name_noprefs.c_str(), NULL, NULL, this, false),
_menu_node(NULL), _workingDialog(true),
_prefDialog(NULL)
{
Inkscape::XML::Node * local_effects_menu = NULL;
// This is a weird hack
if (!strcmp(this->get_id(), "org.inkscape.filter.dropshadow"))
return;
bool hidden = false;
no_doc = false;
no_live_preview = false;
if (repr != NULL) {
for (Inkscape::XML::Node *child = sp_repr_children(repr); child != NULL; child = child->next()) {
if (!strcmp(child->name(), INKSCAPE_EXTENSION_NS "effect")) {
if (child->attribute("needs-document") && !strcmp(child->attribute("needs-document"), "false")) {
no_doc = true;
}
if (child->attribute("needs-live-preview") && !strcmp(child->attribute("needs-live-preview"), "false")) {
no_live_preview = true;
}
for (Inkscape::XML::Node *effect_child = sp_repr_children(child); effect_child != NULL; effect_child = effect_child->next()) {
if (!strcmp(effect_child->name(), INKSCAPE_EXTENSION_NS "effects-menu")) {
// printf("Found local effects menu in %s\n", this->get_name());
local_effects_menu = sp_repr_children(effect_child);
if (effect_child->attribute("hidden") && !strcmp(effect_child->attribute("hidden"), "true")) {
hidden = true;
}
}
if (!strcmp(effect_child->name(), INKSCAPE_EXTENSION_NS "menu-name") ||
!strcmp(effect_child->name(), INKSCAPE_EXTENSION_NS "_menu-name")) {
// printf("Found local effects menu in %s\n", this->get_name());
_verb.set_name(sp_repr_children(effect_child)->content());
}
if (!strcmp(effect_child->name(), INKSCAPE_EXTENSION_NS "menu-tip") ||
!strcmp(effect_child->name(), INKSCAPE_EXTENSION_NS "_menu-tip")) {
// printf("Found local effects menu in %s\n", this->get_name());
_verb.set_tip(sp_repr_children(effect_child)->content());
}
} // children of "effect"
break; // there can only be one effect
} // find "effect"
} // children of "inkscape-extension"
} // if we have an XML file
if (INKSCAPE != NULL) {
if (_effects_list == NULL)
_effects_list = find_menu(inkscape_get_menus(INKSCAPE), EFFECTS_LIST);
if (_filters_list == NULL)
_filters_list = find_menu(inkscape_get_menus(INKSCAPE), FILTERS_LIST);
}
if ((_effects_list != NULL || _filters_list != NULL)) {
Inkscape::XML::Document *xml_doc;
xml_doc = _effects_list->document();
_menu_node = xml_doc->createElement("verb");
_menu_node->setAttribute("verb-id", this->get_id(), false);
if (!hidden) {
if (_filters_list &&
local_effects_menu &&
local_effects_menu->attribute("name") &&
!strcmp(local_effects_menu->attribute("name"), ("Filters"))) {
merge_menu(_filters_list->parent(), _filters_list, sp_repr_children(local_effects_menu), _menu_node);
} else if (_effects_list) {
merge_menu(_effects_list->parent(), _effects_list, local_effects_menu, _menu_node);
}
}
}
return;
}
void
Effect::merge_menu (Inkscape::XML::Node * base,
Inkscape::XML::Node * start,
Inkscape::XML::Node * patern,
Inkscape::XML::Node * mergee) {
Glib::ustring mergename;
Inkscape::XML::Node * tomerge = NULL;
Inkscape::XML::Node * submenu = NULL;
/* printf("Merge menu with '%s' '%s' '%s'\n",
base != NULL ? base->name() : "NULL",
patern != NULL ? patern->name() : "NULL",
mergee != NULL ? mergee->name() : "NULL"); */
if (patern == NULL) {
// Merge the verb name
tomerge = mergee;
mergename = _(this->get_name());
} else {
gchar const * menuname = patern->attribute("name");
if (menuname == NULL) menuname = patern->attribute("_name");
if (menuname == NULL) return;
Inkscape::XML::Document *xml_doc;
xml_doc = base->document();
tomerge = xml_doc->createElement("submenu");
tomerge->setAttribute("name", menuname, false);
mergename = _(menuname);
}
int position = -1;
if (start != NULL) {
Inkscape::XML::Node * menupass;
for (menupass = start; menupass != NULL && strcmp(menupass->name(), "separator"); menupass = menupass->next()) {
gchar const * compare_char = NULL;
if (!strcmp(menupass->name(), "verb")) {
gchar const * verbid = menupass->attribute("verb-id");
Inkscape::Verb * verb = Inkscape::Verb::getbyid(verbid);
if (verb == NULL) {
g_warning("Unable to find verb '%s' which is referred to in the menus.", verbid);
continue;
}
compare_char = verb->get_name();
} else if (!strcmp(menupass->name(), "submenu")) {
compare_char = menupass->attribute("name");
if (compare_char == NULL)
compare_char = menupass->attribute("_name");
}
position = menupass->position() + 1;
/* This will cause us to skip tags we don't understand */
if (compare_char == NULL) {
continue;
}
Glib::ustring compare(_(compare_char));
if (mergename == compare) {
Inkscape::GC::release(tomerge);
tomerge = NULL;
submenu = menupass;
break;
}
if (mergename < compare) {
position = menupass->position();
break;
}
} // for menu items
} // start != NULL
if (tomerge != NULL) {
base->appendChild(tomerge);
Inkscape::GC::release(tomerge);
if (position != -1)
tomerge->setPosition(position);
}
if (patern != NULL) {
if (submenu == NULL)
submenu = tomerge;
merge_menu(submenu, submenu->firstChild(), patern->firstChild(), mergee);
}
return;
}
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)
, _value(NULL)
, _indent(0)
, choices(NULL)
{
const char *xmlval = NULL; // the value stored in XML
if (xml != NULL) {
// Read XML tree to add enumeration items:
for (Inkscape::XML::Node *node = xml->firstChild(); node; node = node->next()) {
char const * chname = node->name();
if (!strcmp(chname, INKSCAPE_EXTENSION_NS "item") || !strcmp(chname, INKSCAPE_EXTENSION_NS "_item")) {
Glib::ustring newguitext, newvalue;
const char * contents = NULL;
if (node->firstChild()) {
contents = node->firstChild()->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
if (!strcmp(chname, INKSCAPE_EXTENSION_NS "_item")) {
if (node->attribute("msgctxt") != NULL) {
newguitext = g_dpgettext2(NULL, node->attribute("msgctxt"), contents);
} else {
newguitext = _(contents);
}
} else {
newguitext = contents;
}
} else
continue;
const char * val = node->attribute("value");
if (val != NULL) {
newvalue = val;
} else {
newvalue = contents;
}
if ( (!newguitext.empty()) && (!newvalue.empty()) ) { // logical error if this is not true here
choices = g_slist_append( choices, new enumentry(newvalue, newguitext) );
}
}
}
// Initialize _value with the default value from xml
// for simplicity : default to the contents of the first xml-child
if (xml->firstChild() && xml->firstChild()->firstChild()) {
xmlval = xml->firstChild()->attribute("value");
}
const char *indent = xml->attribute("indent");
if (indent != NULL) {
_indent = atoi(indent) * 12;
}
}
gchar * pref_name = this->pref_name();
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Glib::ustring paramval = prefs ? prefs->getString(extension_pref_root + pref_name) : "";
g_free(pref_name);
if (!paramval.empty()) {
_value = g_strdup(paramval.data());
} else if (xmlval) {
_value = g_strdup(xmlval);
}
}