From: Carlos Lopez Date: Sun, 26 Jul 2009 06:26:02 +0000 (+0200) Subject: Apply akagogo's patch for importing SVG files. X-Git-Url: https://git.pterodactylus.net/?p=synfig.git;a=commitdiff_plain;h=7c1abe51ca9fa3743536b52a3325483878f6cd4d Apply akagogo's patch for importing SVG files. --- diff --git a/synfig-core/trunk/configure.ac b/synfig-core/trunk/configure.ac index 66a6407..c75e817 100644 --- a/synfig-core/trunk/configure.ac +++ b/synfig-core/trunk/configure.ac @@ -678,6 +678,7 @@ src/modules/mod_particle/Makefile src/modules/mod_png/Makefile src/modules/mod_ppm/Makefile src/modules/mod_yuv420p/Makefile +src/modules/mod_svg/Makefile src/modules/example/Makefile src/tool/Makefile src/modules/synfig_modules.cfg diff --git a/synfig-core/trunk/src/modules/Makefile.am b/synfig-core/trunk/src/modules/Makefile.am index 0e76ee7..4a40d3e 100644 --- a/synfig-core/trunk/src/modules/Makefile.am +++ b/synfig-core/trunk/src/modules/Makefile.am @@ -25,6 +25,7 @@ SUBDIRS = \ lyr_freetype \ lyr_std \ mod_mng \ + mod_svg \ mod_magickpp \ example diff --git a/synfig-core/trunk/src/modules/mod_svg/Makefile.am b/synfig-core/trunk/src/modules/mod_svg/Makefile.am new file mode 100644 index 0000000..25eb5a6 --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/Makefile.am @@ -0,0 +1,14 @@ +# $Id$ + +MAINTAINERCLEANFILES=Makefile.in +INCLUDES = -I$(top_builddir) -I$(top_srcdir)/src + +moduledir=@MODULE_DIR@ + +module_LTLIBRARIES = libmod_svg.la +libmod_svg_la_SOURCES = main.cpp layer_svg.h layer_svg.cpp svg_parser.h svg_parser.cpp +libmod_svg_la_LDFLAGS = -module -no-undefined -avoid-version +libmod_svg_la_CXXFLAGS = @SYNFIG_CFLAGS@ +libmod_svg_la_LIBADD = ../../synfig/libsynfig.la @SYNFIG_LIBS@ +EXTRA_DIST= mod_svg.nsh unmod_svg.nsh + diff --git a/synfig-core/trunk/src/modules/mod_svg/layer_svg.cpp b/synfig-core/trunk/src/modules/mod_svg/layer_svg.cpp new file mode 100644 index 0000000..2906079 --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/layer_svg.cpp @@ -0,0 +1,103 @@ +/* === S Y N F I G ========================================================= */ +/*! \file layer_svg.cpp +** \brief Implementation of the Svg layer +** +** $Id:$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2008 Chris Moore +** Copyright (c) 2009 Carlos A. Sosa Navarro +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +*/ +/* ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#ifdef USING_PCH +# include "pch.h" +#else +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include + +#include "layer_svg.h" + +#endif + +/* === U S I N G =========================================================== */ + +using namespace etl; +using namespace std; +using namespace synfig; + +/* === G L O B A L S ======================================================= */ + +SYNFIG_LAYER_INIT(svg_layer); +SYNFIG_LAYER_SET_NAME(svg_layer,"svg_layer"); +SYNFIG_LAYER_SET_LOCAL_NAME(svg_layer,N_("Import Svg")); +SYNFIG_LAYER_SET_CATEGORY(svg_layer,N_("NotVisible"));//this is auxiliar +SYNFIG_LAYER_SET_VERSION(svg_layer,"0.1"); +SYNFIG_LAYER_SET_CVS_ID(svg_layer,"$Id: layer_svg.cpp 2240 2008-11-22 15:35:33Z dooglus $"); + +/* === P R O C E D U R E S ================================================= */ + +svg_layer::svg_layer(): + Layer_PasteCanvas(), + filename("none") +{ +} + +bool +svg_layer::set_param(const String & param, const ValueBase &value) +{ + if(param=="filename"){ + Canvas::Handle canvas; + //if ext of filename == "svg" then + canvas=open_svg(value.get(String()),errors,warnings); + //else other parsers maybe + if(canvas){ + canvas->set_inline(get_canvas()); + set_sub_canvas(canvas); + IMPORT(filename); + } + } + return Layer_PasteCanvas::set_param(param,value); +} + +ValueBase +svg_layer::get_param(const String ¶m)const +{ + EXPORT(filename); + EXPORT_NAME(); + EXPORT_VERSION(); + + return Layer_PasteCanvas::get_param(param); +} + +Layer::Vocab +svg_layer::get_param_vocab()const +{ + Layer::Vocab ret(Layer_PasteCanvas::get_param_vocab()); + + ret.push_back(ParamDesc("filename") + .set_local_name(_("Filename")) + ); + return ret; +} + diff --git a/synfig-core/trunk/src/modules/mod_svg/layer_svg.h b/synfig-core/trunk/src/modules/mod_svg/layer_svg.h new file mode 100644 index 0000000..b7aa25b --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/layer_svg.h @@ -0,0 +1,67 @@ +/* === S Y N F I G ========================================================= */ +/*! \file layer_svg.h +** \brief Header file for implementation of the Svg Canvas layer +** +** $Id:$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2009 Carlos A. Sosa Navarro +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +*/ +/* ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __SYNFIG_SVG_LAYER_H +#define __SYNFIG_SVG_LAYER_H + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include + +#include "svg_parser.h" + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +class svg_layer : public synfig::Layer_PasteCanvas +{ + SYNFIG_LAYER_MODULE_EXT + +private: + + synfig::String filename; + synfig::String errors,warnings; + +public: + + svg_layer(); + + virtual bool set_param(const synfig::String & param, const synfig::ValueBase &value); + + virtual synfig::ValueBase get_param(const synfig::String & param)const; + + virtual Vocab get_param_vocab()const; +}; // END of class svg_layer + +/* === E N D =============================================================== */ + +#endif + diff --git a/synfig-core/trunk/src/modules/mod_svg/main.cpp b/synfig-core/trunk/src/modules/mod_svg/main.cpp new file mode 100644 index 0000000..1f5be67 --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/main.cpp @@ -0,0 +1,57 @@ +/* === S Y N F I G ========================================================= */ +/*! \file mod_svg/main.cpp +** \brief writeme +** +** $Id:$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2009 Carlos A. Sosa Navarro +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +*/ +/* ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#define SYNFIG_NO_ANGLE + +#ifdef USING_PCH +# include "pch.h" +#else +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include "layer_svg.h" + +#endif + +/* === E N T R Y P O I N T ================================================= */ + +MODULE_DESC_BEGIN(mod_svg) + MODULE_NAME("SVG Importer") + MODULE_DESCRIPTION("Provides a svg importer") + MODULE_AUTHOR("Carlos Sosa Navarro") + MODULE_VERSION("0.1") + MODULE_COPYRIGHT(SYNFIG_COPYRIGHT) +MODULE_DESC_END + +MODULE_INVENTORY_BEGIN(mod_svg) + BEGIN_LAYERS + LAYER(svg_layer) + END_LAYERS +MODULE_INVENTORY_END diff --git a/synfig-core/trunk/src/modules/mod_svg/mod_svg.nsh b/synfig-core/trunk/src/modules/mod_svg/mod_svg.nsh new file mode 100644 index 0000000..03b31d5 --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/mod_svg.nsh @@ -0,0 +1,20 @@ +; The stuff to install +Section "mod_svg" Sec_mod_svg + +; SectionIn RO + + ; Set output path to the installation directory. + SetOutPath "$INSTDIR\lib\synfig\modules" + + ; Put file there + File /oname=mod_svg.dll "src\modules\mod_svg\.libs\libmod_svg.dll" + + + FileOpen $0 $INSTDIR\etc\synfig_modules.cfg a + FileSeek $0 0 END + FileWrite $0 "mod_svg" + FileWriteByte $0 "13" + FileWriteByte $0 "10" + FileClose $0 + +SectionEnd diff --git a/synfig-core/trunk/src/modules/mod_svg/svg_parser.cpp b/synfig-core/trunk/src/modules/mod_svg/svg_parser.cpp new file mode 100644 index 0000000..2897d64 --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/svg_parser.cpp @@ -0,0 +1,1934 @@ +/* === S Y N F I G ========================================================= */ +/*! \file svg_parser.cpp +** \brief Implementation of the Svg parser +** \brief Based on SVG XML specification 1.1 +** \brief See: http://www.w3.org/TR/xml11/ for deatils +** +** $Id:$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2008 Chris Moore +** Copyright (c) 2009 Carlos A. Sosa Navarro +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +*/ +/* ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include "svg_parser.h" + +/* === U S I N G =========================================================== */ + +using namespace synfig; + +/* === G L O B A L S ======================================================= */ + +/* === P R O C E D U R E S ================================================= */ + +Canvas::Handle +synfig::open_svg(std::string _filepath,String &errors, String &warnings){ + Canvas::Handle canvas; + Svg_parser parser; + try + { + canvas=parser.load_svg_canvas(_filepath,errors,warnings); + //canvas->set_id(parser.get_id()); + }catch(...){ + std::cout<<"error"<get_root_node(); + parser_node(pNode); + } + #ifdef LIBXMLCPP_EXCEPTIONS_ENABLED + }catch(const std::exception& ex){ + std::cout << "Exception caught: " << ex.what() << std::endl; + } + #endif //LIBXMLCPP_EXCEPTIONS_ENABLED + Canvas::Handle canvas; + if(nodeRoot){ + //canvas=synfig::open_canvas(nodeRoot,_filepath,errors,warnings); + canvas=synfig::open_canvas(nodeRoot,errors,warnings); + } + return canvas; +} + +Svg_parser::Svg_parser(){ + uid=0; + kux=60; + set_canvas=0;//we must run parser_canvas method + // 0.5 in gamma parameter of color correct layer is 1/0.5 = 2 (thinking) it must be 2.2!!!! + gamma.set_gamma(2.2); +} +/* +String +Svg_parser::get_id(){ + if(!id_name.empty()) return id_name; + return "id_arbitrario"; +} +void +Svg_parser::set_id(String source){ + const char bad_chars[]=" :#@$^&()*"; + int inicio= source.find_last_of('/')+1; + int fin= source.find_last_of('.'); + String x=source.substr(inicio,fin-inicio); + if(!x.empty()){ + for(unsigned int i=0;i(node); + const xmlpp::TextNode* nodeText = dynamic_cast(node); + const xmlpp::CommentNode* nodeComment = dynamic_cast(node); + + if(nodeText && nodeText->is_white_space()) //Let's ignore the indenting - you don't always want to do this. + return; + + Glib::ustring nodename = node->get_name(); + if(!nodeText && !nodeComment && !nodename.empty()){ + if(nodename.compare("svg")==0){ + parser_svg (node); + }else if(nodename.compare("namedview")==0){ + parser_canvas(node); + }else if(nodename.compare("defs")==0){ + parser_defs (node); + }else if(nodename.compare("g")==0){ + if(set_canvas==0) parser_canvas (node); + parser_layer (node,nodeRoot->add_child("layer"),"",NULL); + return; + }else if(nodename.compare("rect")==0){ + if(set_canvas==0) parser_canvas (node); + parser_rect(node,nodeRoot,"",NULL); + }else if(nodename.compare("polygon")==0){ + if(set_canvas==0) parser_canvas (node); + parser_polygon(node,nodeRoot,"",NULL); + }else if(nodename.compare("path")==0){ + if(set_canvas==0) parser_canvas (node); + parser_path (node,nodeRoot,"",NULL); + } + } + if(!nodeContent){ + xmlpp::Node::NodeList list = node->get_children(); + for(xmlpp::Node::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter){ + parser_node(*iter); //recursive + } + } +} + +//parser elements +void +Svg_parser::parser_svg (const xmlpp::Node* node){ + //printf("un dia en algun lugar de la tierra media\n"); + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + width =etl::strprintf("%f",getDimension(nodeElement->get_attribute_value("width"))); + height =etl::strprintf("%f",getDimension(nodeElement->get_attribute_value("height"))); + docname=nodeElement->get_attribute_value("docname",""); + } +} +void +Svg_parser::parser_canvas (const xmlpp::Node* node){ + //printf("el campo de batalla parecia un lienzo de pintura\n"); + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + if(width.compare("")==0){ + width=nodeElement->get_attribute_value("width",""); + } + if(height.compare("")==0){ + height=nodeElement->get_attribute_value("height",""); + } + if(width.compare("")==0 && height.compare("")!=0){ + width=height; + } + if(width.compare("")!=0 && height.compare("")==0){ + height=width; + } + if(height.compare("")==0 && width.compare("")==0){ + width="1024"; + height="768"; + } + //build + nodeRoot=document.create_root_node("canvas", "", ""); + nodeRoot->set_attribute("version","0.5"); + nodeRoot->set_attribute("width",width); + nodeRoot->set_attribute("height",height); + nodeRoot->set_attribute("xres","2834.645752"); + nodeRoot->set_attribute("yres","2834.645752"); + float view_x; + float view_y; + view_x=atof(width.c_str())/kux; + view_y=atof(height.c_str())/kux; + view_x=view_x/2.0; + view_y=view_y/2.0; + char attr_view_box[60]; + sprintf(attr_view_box,"%f %f %f %f",-1.0*view_x,view_y,view_x,-1.0*view_y); + nodeRoot->set_attribute("view-box",attr_view_box); + ox=atof(width.c_str() )/2; + oy=atof(height.c_str())/2; + nodeRoot->set_attribute("antialias","1"); + nodeRoot->set_attribute("fps","24.000"); + nodeRoot->set_attribute("begin-time","0f"); + nodeRoot->set_attribute("end-time","5s"); + nodeRoot->set_attribute("bgcolor","0.500000 0.500000 0.500000 1.000000"); + //nodeRoot->add_child("name")->set_child_text("Synfig Animation 1"); + if(!id_name.empty()) nodeRoot->add_child("name")->set_child_text(id_name); + else nodeRoot->add_child("name")->set_child_text("Synfig Animation 1"); + } + set_canvas=1; + AdjustPointUrl (); +} + +void +Svg_parser::parser_rect(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent){ + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + Glib::ustring rect_id =nodeElement->get_attribute_value("id"); + Glib::ustring rect_style =nodeElement->get_attribute_value("style"); + Glib::ustring rect_x =nodeElement->get_attribute_value("x"); + Glib::ustring rect_y =nodeElement->get_attribute_value("y"); + Glib::ustring rect_width =nodeElement->get_attribute_value("width"); + Glib::ustring rect_height =nodeElement->get_attribute_value("height"); + //style + String fill =loadAttribute("fill",rect_style,parent_style,"none"); + String fill_opacity =loadAttribute("fill-opacity",rect_style,parent_style,"1"); + String opacity =loadAttribute("opacity",rect_style,parent_style,"1"); + //matrix + //it's some complicated + + //build + + int typeFill=0; + if(fill.compare(0,3,"url")==0){ + typeFill=2; + root=nodeStartBasicLayer(root->add_child("layer")); + } + xmlpp::Element *child_rect=root->add_child("layer"); + child_rect->set_attribute("type","rectangle"); + child_rect->set_attribute("active","true"); + child_rect->set_attribute("version","0.2"); + child_rect->set_attribute("desc",rect_id); + + build_real(child_rect->add_child("param"),"z_depth",0.0); + build_real(child_rect->add_child("param"),"amount",1.0); + build_integer(child_rect->add_child("param"),"blend_method",0); + build_color (child_rect->add_child("param"),getRed (fill),getGreen (fill),getBlue(fill),atof(opacity.data())*atof(fill_opacity.data())); + + float auxx=atof(rect_x.c_str()); + float auxy=atof(rect_y.c_str()); + coor2vect(&auxx,&auxy); + build_vector (child_rect->add_child("param"),"point1",auxx,auxy); + auxx= atof(rect_x.c_str()) + atof(rect_width.c_str()); + auxy= atof(rect_y.c_str()) + atof(rect_height.c_str()); + coor2vect(&auxx,&auxy); + build_vector (child_rect->add_child("param"),"point2",auxx,auxy); + if(typeFill==2){ + build_url (root->add_child("layer"),fill,mtx_parent); + } + } +} +void +Svg_parser::parser_layer(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent){ + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + Glib::ustring label =nodeElement->get_attribute_value("label"); + Glib::ustring style =nodeElement->get_attribute_value("style"); + Glib::ustring fill =nodeElement->get_attribute_value("fill"); + Glib::ustring transform =nodeElement->get_attribute_value("transform"); + + String layer_style; + if(!style.empty()){ + layer_style=style; + }else if(!fill.empty()){ + layer_style.append("fill:"); + layer_style.append(fill); + }else if(!parent_style.empty()){ + layer_style=parent_style; + } + Matrix* mtx=NULL; + if(!transform.empty()) + mtx=build_transform (transform); + if(mtx_parent){ + if(mtx) + composeMatrix(&mtx,mtx_parent,mtx); + else + mtx=newMatrix (mtx_parent); + } + //build + root->set_attribute("type","PasteCanvas"); + root->set_attribute("active","true"); + root->set_attribute("version","0.1"); + if(!label.empty()) root->set_attribute("desc",label); + else root->set_attribute("desc","unknow layer"); + + build_real(root->add_child("param"),"z_depth",0.0); + build_real(root->add_child("param"),"amount",1.0); + build_integer(root->add_child("param"),"blend_method",0); + build_vector (root->add_child("param"),"origin",0,0); + + //printf(" atributos canvas "); + //canvas + xmlpp::Element *child_canvas=root->add_child("param"); + child_canvas->set_attribute("name","canvas"); + child_canvas=child_canvas->add_child("canvas"); + const xmlpp::ContentNode* nodeContent = dynamic_cast(node); + if(!nodeContent){ + xmlpp::Node::NodeList list = node->get_children(); + for(xmlpp::Node::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter){ + Glib::ustring name =(*iter)->get_name(); + if(name.compare("g")==0){ + parser_layer (*iter,child_canvas->add_child("layer"),layer_style,mtx); + }else if(name.compare("path")==0){ + parser_path (*iter,child_canvas,layer_style,mtx); + }else if(name.compare("polygon")==0){ + parser_polygon (*iter,child_canvas,layer_style,mtx); + }else if(name.compare("rect")==0){ + parser_rect (*iter,child_canvas,layer_style,mtx); + } + } + } + } +} +void +Svg_parser::parser_polygon(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent){ + //printf("sus escudos parecian rombos y sus naves unos triangulos\n"); + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + //load sub-attributes + Glib::ustring polygon_style =nodeElement->get_attribute_value("style"); + Glib::ustring polygon_id =nodeElement->get_attribute_value("id"); + Glib::ustring polygon_points =nodeElement->get_attribute_value("points"); + Glib::ustring polygon_transform =nodeElement->get_attribute_value("transform"); + Glib::ustring polygon_fill =nodeElement->get_attribute_value("fill"); + String fill =loadAttribute("fill",polygon_style,parent_style,polygon_fill,"none"); + String fill_rule =loadAttribute("fill-rule",polygon_style,parent_style,"evenodd"); + String fill_opacity =loadAttribute("fill-opacity",polygon_style,parent_style,"1"); + String opacity =loadAttribute("opacity",polygon_style,parent_style,"1"); + + //transforms + Matrix* mtx=NULL; + if(!polygon_transform.empty()) + mtx=build_transform (polygon_transform); + if(mtx_parent){ + if(mtx) + composeMatrix(&mtx,mtx_parent,mtx); + else + mtx=newMatrix (mtx_parent); + } + //points + if(polygon_points.empty()) + return; + std::list k; + std::vector tokens=get_tokens_path (polygon_points); + unsigned int i; + float ax,ay; ax=ay=0; + for(i=0;iadd_child("layer")); + } + child_polygon=root->add_child("layer"); + child_polygon->set_attribute("type","polygon"); + child_polygon->set_attribute("active","true"); + child_polygon->set_attribute("version","0.1"); + child_polygon->set_attribute("desc",polygon_id); + build_param (child_polygon->add_child("param"),"z_depth","real","0.0000000000"); + build_param (child_polygon->add_child("param"),"amount","real","1.0000000000"); + build_param (child_polygon->add_child("param"),"blend_method","integer","0"); + build_color (child_polygon->add_child("param"),getRed(fill),getGreen(fill),getBlue(fill),atof(fill_opacity.data())*atof(opacity.data())); + build_vector(child_polygon->add_child("param"),"offset",0,0); + build_param (child_polygon->add_child("param"),"invert","bool","false"); + build_param (child_polygon->add_child("param"),"antialias","bool","true"); + build_param (child_polygon->add_child("param"),"feather","real","0.0000000000"); + build_param (child_polygon->add_child("param"),"blurtype","integer","1"); + if(fill_rule.compare("evenodd")==0) build_param (child_polygon->add_child("param"),"winding_style","integer","1"); + else build_param (child_polygon->add_child("param"),"winding_style","integer","0"); + build_points (child_polygon->add_child("param"),k); + + if(typeFill==2){ + build_url(root->add_child("layer"),fill,mtx); + } + } +} +void +Svg_parser::parser_path(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent){ + //printf("pensamos que atacarian de frente pero hicieron una curva\n"); + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + //load sub-attributes + Glib::ustring path_style =nodeElement->get_attribute_value("style"); + Glib::ustring path_id =nodeElement->get_attribute_value("id"); + Glib::ustring path_d =nodeElement->get_attribute_value("d"); + Glib::ustring path_transform =nodeElement->get_attribute_value("transform"); + Glib::ustring path_fill =nodeElement->get_attribute_value("fill"); + + String fill =loadAttribute("fill",path_style,parent_style,path_fill,"none"); + String fill_rule =loadAttribute("fill-rule",path_style,parent_style,"evenodd"); + String stroke =loadAttribute("stroke",path_style,parent_style,"none"); + String stroke_width =loadAttribute("stroke-width",path_style,parent_style,"1px"); + String stroke_linecap =loadAttribute("stroke-linecap",path_style,parent_style,"butt"); + String stroke_linejoin =loadAttribute("stroke-linejoin",path_style,parent_style,"miter"); + String stroke_opacity =loadAttribute("stroke-opacity",path_style,parent_style,"1"); + String fill_opacity =loadAttribute("fill-opacity",path_style,parent_style,"1"); + String opacity =loadAttribute("opacity",path_style,parent_style,"1"); + + //resolve transformations + Matrix* mtx=NULL; + if(!path_transform.empty()) + mtx=build_transform (path_transform); + if(mtx_parent){ + if(mtx) + composeMatrix(&mtx,mtx_parent,mtx); + else + mtx=newMatrix(mtx_parent); + } + //parser path_d attribute, this is obviously important + std::list > k; + k=parser_path_d (path_d,mtx); + + //escribir + int typeFill=0; //nothing + int typeStroke=0;//nothing + //Fill + if(fill.compare("none")!=0){ + typeFill=1; //simple + } + if(typeFill==1 && fill.compare(0,3,"url")==0){ + typeFill=2; //gradient + } + //Stroke + if(stroke.compare("none")!=0){ + typeStroke=1; //simple + } + if(typeStroke==1 && stroke.compare(0,3,"url")==0){ + typeStroke=2; //gradient + } + String bline_id; + String offset_id; + int n=k.size(); + if(n!=1){ //if n is > than 1 then we must create a paste canvas for all paths + root=nodeStartBasicLayer(root->add_child("layer")); + } + std::list >::iterator aux = k.begin(); + for (; aux!=k.end(); aux++){ + if(typeFill!=0 && typeStroke!=0){ + bline_id=new_guid(); + offset_id=new_guid(); + } + if(typeFill==1 || typeFill==2){//region layer + xmlpp::Element *child_fill=root; + if(n==1 && typeFill==2){//open gradient or url (fill) + child_fill=nodeStartBasicLayer(root->add_child("layer")); + } + xmlpp::Element *child_region=child_fill->add_child("layer"); + child_region->set_attribute("type","region"); + child_region->set_attribute("active","true"); + child_region->set_attribute("version","0.1"); + child_region->set_attribute("desc",path_id); + build_param (child_region->add_child("param"),"z_depth","real","0.0000000000"); + build_param (child_region->add_child("param"),"amount","real","1.0000000000"); + build_param (child_region->add_child("param"),"blend_method","integer","0"); + build_color (child_region->add_child("param"),getRed(fill),getGreen(fill),getBlue(fill),atof(fill_opacity.data())*atof(opacity.data())); + if(offset_id.empty()) build_vector (child_region->add_child("param"),"offset",0,0); + else build_vector (child_region->add_child("param"),"offset",0,0,offset_id); + build_param (child_region->add_child("param"),"invert","bool","false"); + build_param (child_region->add_child("param"),"antialias","bool","true"); + build_param (child_region->add_child("param"),"feather","real","0.0000000000"); + build_param (child_region->add_child("param"),"blurtype","integer","1"); + if(fill_rule.compare("evenodd")==0) build_param (child_region->add_child("param"),"winding_style","integer","1"); + else build_param (child_region->add_child("param"),"winding_style","integer","0"); + + build_bline (child_region->add_child("param"),*aux,loop,bline_id); + + if(n==1 && typeFill==2){ //gradient in onto mode (fill) + build_url(child_fill->add_child("layer"),fill,mtx); + } + } + + if(typeStroke==1 || typeStroke==2){ //layer outline + xmlpp::Element *child_stroke=root; + if(n==1 && typeStroke==2){//open gradient in straigth onto (stroke) + child_stroke=nodeStartBasicLayer(root->add_child("layer")); + } + xmlpp::Element *child_outline=child_stroke->add_child("layer"); + child_outline->set_attribute("type","outline"); + child_outline->set_attribute("active","true"); + child_outline->set_attribute("version","0.2"); + child_outline->set_attribute("desc",path_id); + build_param (child_outline->add_child("param"),"z_depth","real","0.0000000000"); + build_param (child_outline->add_child("param"),"amount","real","1.0000000000"); + build_param (child_outline->add_child("param"),"blend_method","integer","0"); + build_color (child_outline->add_child("param"),getRed(stroke),getGreen(stroke),getBlue(stroke),atof(stroke_opacity.data())*atof(opacity.data())); + if(offset_id.empty()) build_vector (child_outline->add_child("param"),"offset",0,0); + else build_vector (child_outline->add_child("param"),"offset",0,0,offset_id); + build_param (child_outline->add_child("param"),"invert","bool","false"); + build_param (child_outline->add_child("param"),"antialias","bool","true"); + build_param (child_outline->add_child("param"),"feather","real","0.0000000000"); + build_param (child_outline->add_child("param"),"blurtype","integer","1"); + //outline in nonzero + build_param (child_outline->add_child("param"),"winding_style","integer","0"); + + build_bline (child_outline->add_child("param"),*aux,loop,bline_id); + + stroke_width=etl::strprintf("%f",getDimension(stroke_width)/kux); + build_param (child_outline->add_child("param"),"width","real",stroke_width); + build_param (child_outline->add_child("param"),"expand","real","0.0000000000"); + if(stroke_linejoin.compare("miter")==0) build_param (child_outline->add_child("param"),"sharp_cusps","bool","true"); + else build_param (child_outline->add_child("param"),"sharp_cusps","bool","false"); + if(stroke_linecap.compare("butt")==0){ + build_param (child_outline->add_child("param"),"round_tip[0]","bool","false"); + build_param (child_outline->add_child("param"),"round_tip[1]","bool","false"); + }else{ + build_param (child_outline->add_child("param"),"round_tip[0]","bool","true"); + build_param (child_outline->add_child("param"),"round_tip[1]","bool","true"); + } + build_param (child_outline->add_child("param"),"loopyness","real","1.0000000000"); + build_param (child_outline->add_child("param"),"homogeneous_width","bool","true"); + + if(n==1 && typeStroke==2){ //gradient in onto mode (stroke) + build_url(child_stroke->add_child("layer"),stroke,mtx); + } + } + } + if(n!=1){//only fill for several canvas in one path + if(typeFill==2){ + build_url(root->add_child("layer"),fill,mtx); + } + } + } +} + +std::vector +Svg_parser::get_tokens_path(String path){ //mini path lexico-parser + std::vector tokens; + String buffer; + int e=0; + unsigned int i=0; + char a; + while(i > +Svg_parser::parser_path_d(String path_d,Matrix* mtx){ + std::list > k; + std::list k1; + float ax,ay,tgx,tgy,tgx2,tgy2;//each method + float actual_x=0,actual_y=0;//for relative methods; + loop=false; + unsigned int i; + std::vector tokens=get_tokens_path(path_d); + for(i=0;ix,k1.back()->y,tgx2,tgy2); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,tgx,tgy); + }else{ + k1.push_back(nuevoVertice (ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); + setSplit(k1.back(),TRUE); + } + }else if(tokens.at(i).compare("Q")==0){ //absolute quadractic curve + //tg1 and tg2 + i++; tgx=ax=atof(tokens.at(i).data()); + i++; if(tokens.at(i).compare(",")==0) i++; + tgy=ay=atof(tokens.at(i).data()); + //point + i++; ax=atof(tokens.at(i).data()); + i++; if(tokens.at(i).compare(",")==0) i++; + ay=atof(tokens.at(i).data()); + actual_x=ax; + actual_y=ay; + //mtx + if(mtx){ + transformPoint2D(mtx,&ax,&ay); + transformPoint2D(mtx,&tgx,&tgy); + } + //adjust + coor2vect(&ax,&ay); + coor2vect(&tgx,&tgy); + //save + setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); + setSplit(k1.back(),FALSE); + k1.push_back(nuevoVertice (ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); + }else if(tokens.at(i).compare("L")==0){ //absolute line to + //point + i++; ax=atof(tokens.at(i).data()); + i++; if(tokens.at(i).compare(",")==0) i++; + ay=atof(tokens.at(i).data()); + actual_x=ax; + actual_y=ay; + //mtx + if(mtx) transformPoint2D(mtx,&ax,&ay); + //adjust + coor2vect(&ax,&ay); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,k1.front()->x,k1.front()->y); + }else{ + k1.push_back(nuevoVertice(ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + } + }else if(tokens.at(i).compare("l")==0){//relative line to + //point read + i++; ax=atof(tokens.at(i).data()); + i++; if(tokens.at(i).compare(",")==0) i++; + ay=atof(tokens.at(i).data()); + //relative + ax=actual_x+ax; + ay=actual_y+ay; + actual_x=ax; + actual_y=ay; + //mtx + if(mtx) transformPoint2D(mtx,&ax,&ay); + //adjust + coor2vect(&ax,&ay); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,k1.front()->x,k1.front()->y); + }else{ + k1.push_back(nuevoVertice(ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + } + }else if(tokens.at(i).compare("H")==0){//absolute horizontal move + //the same that L but only Horizontal movement + //point + i++; ax=atof(tokens.at(i).data()); + ay=actual_y; + actual_x=ax; + actual_y=ay; + //mtx + if(mtx) transformPoint2D(mtx,&ax,&ay); + //adjust + coor2vect(&ax,&ay); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,k1.front()->x,k1.front()->y); + }else{ + k1.push_back(nuevoVertice(ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + } + }else if(tokens.at(i).compare("h")==0){//horizontal relative + i++; ax=atof(tokens.at(i).data()); + ax=actual_x+ax; + ay=actual_y; + actual_x=ax; + actual_y=ay; + //mtx + if(mtx) transformPoint2D(mtx,&ax,&ay); + //adjust + coor2vect(&ax,&ay); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,k1.front()->x,k1.front()->y); + }else{ + k1.push_back(nuevoVertice(ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + } + }else if(tokens.at(i).compare("V")==0){//vertical absolute + //point + i++; ay=atof(tokens.at(i).data()); + ax=actual_x; + actual_x=ax; + actual_y=ay; + //mtx + if(mtx) transformPoint2D(mtx,&ax,&ay); + //adjust + coor2vect(&ax,&ay); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,k1.front()->x,k1.front()->y); + }else{ + k1.push_back(nuevoVertice(ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + } + }else if(tokens.at(i).compare("v")==0){//relative + //point + i++; ay=atof(tokens.at(i).data()); + ax=actual_x; + ay=actual_y+ay; + actual_x=ax; + actual_y=ay; + //mtx + if(mtx) transformPoint2D(mtx,&ax,&ay); + //adjust + coor2vect(&ax,&ay); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,k1.front()->x,k1.front()->y); + }else{ + k1.push_back(nuevoVertice(ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); + } + }else if(tokens.at(i).compare("T")==0){// I don't know what does it + }else if(tokens.at(i).compare("A")==0){//elliptic arc + + //isn't complete support, is only for circles + + //this curve have 6 parameters + //radio + float radio_x,radio_y; + float angle; + bool sweep,large; + //radio + i++; radio_x=atof(tokens.at(i).data()); + i++; if(tokens.at(i).compare(",")==0) i++; + radio_y=atof(tokens.at(i).data()); + //angle + i++; angle=atof(tokens.at(i).data()); + //flags + i++; large=atoi(tokens.at(i).data()); + i++; sweep=atoi(tokens.at(i).data()); + //point + i++; ax=atof(tokens.at(i).data()); + i++; if(tokens.at(i).compare(",")==0) i++; + ay=atof(tokens.at(i).data()); + //how to draw? + if(!large && !sweep){ + //points + tgx2 = actual_x + radio_x*0.5; + tgy2 = actual_y ; + tgx = ax; + tgy = ay + radio_y*0.5; + actual_x=ax; + actual_y=ay; + //transformations + if(mtx){ + transformPoint2D(mtx,&tgx2,&tgy2); + transformPoint2D(mtx,&ax,&ay); + transformPoint2D(mtx,&tgx,&tgy); + } + //adjust + coor2vect(&tgx2,&tgy2); + coor2vect(&ax,&ay); + coor2vect(&tgx,&tgy); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,tgx2,tgy2); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,tgx,tgy); + }else{ + k1.push_back(nuevoVertice (ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); + setSplit(k1.back(),TRUE); + } + }else if(!large && sweep){ + //points + tgx2 = actual_x; + tgy2 = actual_y + radio_y*0.5; + tgx = ax + radio_x*0.5; + tgy = ay ; + actual_x=ax; + actual_y=ay; + //transformations + if(mtx){ + transformPoint2D(mtx,&tgx2,&tgy2); + transformPoint2D(mtx,&ax,&ay); + transformPoint2D(mtx,&tgx,&tgy); + } + //adjust + coor2vect(&tgx2,&tgy2); + coor2vect(&ax,&ay); + coor2vect(&tgx,&tgy); + //save + setTg2(k1.back(),k1.back()->x,k1.back()->y,tgx2,tgy2); + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,tgx,tgy); + }else{ + k1.push_back(nuevoVertice (ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); + setSplit(k1.back(),TRUE); + } + }else if( large && !sweep){//rare + //this need more than one vertex + }else if( large && sweep){//circles in inkscape are made with this kind of arc + if(actual_y==ay){//circles + //intermediate point + int sense=1; + if(actual_x>ax) sense =-1; + float in_x,in_y,in_tgx1,in_tgy1,in_tgx2,in_tgy2; + in_x = (actual_x+ax)/2; + in_y = actual_y - sense*radio_y; + in_tgx1 = in_x - sense*(radio_x*0.5); + in_tgx2 = in_x + sense*(radio_x*0.5); + in_tgy1 = in_y; + in_tgy2 = in_y; + //start/end points + tgx2=actual_x; + tgy2=ay - sense*(radio_y*0.5); + tgx =ax; + tgy =ay - sense*(radio_y*0.5); + + actual_x=ax; + actual_y=ay; + //transformations + if(mtx){ + transformPoint2D(mtx,&tgx2,&tgy2); + transformPoint2D(mtx,&tgx ,&tgy ); + transformPoint2D(mtx,&ax,&ay); + + transformPoint2D(mtx,&in_tgx2,&in_tgy2); + transformPoint2D(mtx,&in_tgx1,&in_tgy1); + transformPoint2D(mtx,&in_x,&in_y); + } + //adjust + coor2vect(&tgx2 , &tgy2); + coor2vect(&ax , &ay ); + coor2vect(&tgx , &tgy ); + + coor2vect(&in_tgx2 , &in_tgy2); + coor2vect(&in_tgx1 , &in_tgy1); + coor2vect(&in_x , &in_y ); + + //save the last tg2 + setTg2(k1.back(),k1.back()->x,k1.back()->y,tgx2,tgy2); + //save the intermediate point + k1.push_back(nuevoVertice (in_x,in_y)); + setTg1(k1.back(),k1.back()->x,k1.back()->y, in_tgx1 , in_tgy1); + setTg2(k1.back(),k1.back()->x,k1.back()->y, in_tgx2 , in_tgy2); + setSplit(k1.back(),TRUE); //this could be changed + //save the new point + if(isFirst(k1.front(),ax,ay)){ + setTg1(k1.front(),k1.front()->x,k1.front()->y,tgx,tgy); + }else{ + k1.push_back(nuevoVertice (ax,ay)); + setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); + setSplit(k1.back(),TRUE); + } + } + } + }else if(tokens.at(i).compare("z")==0){ + loop=true; + }else{ + std::cout<<"don't supported: "<(node); + if(!nodeContent){ + xmlpp::Node::NodeList list = node->get_children(); + for(xmlpp::Node::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter){ + Glib::ustring name =(*iter)->get_name(); + if(name.compare("linearGradient")==0){ + parser_linearGradient(*iter); + }else if(name.compare("radialGradient")==0){ + parser_radialGradient(*iter); + } + } + } +} +void +Svg_parser::AdjustPointUrl(){ +/* + if(!lg.empty()){//linealgradient + std::list::iterator aux=lg.begin(); + while(aux!=lg.end()){ + LinearGradient* auxlg=*aux; + coor2vect (&auxlg->x1,&auxlg->y1); + coor2vect (&auxlg->x2,&auxlg->y2); + aux++; + } + } + if(!rg.empty()){//radialgradient + std::list::iterator aux=rg.begin(); + while(aux!=rg.end()){ + RadialGradient* auxrg=*aux; + coor2vect (&auxrg->cx,&auxrg->cy); + auxrg->r= auxrg->r/kux; + aux++; + } + } +*/ +} +std::list* +Svg_parser::find_colorStop(String name){ + if(!name.empty()){ + if(lg.empty()&& rg.empty()) + return NULL; + + String buscar= name; + if(buscar.at(0)=='#') buscar.erase(0,1); + else return NULL; + std::list::iterator aux=lg.begin(); + while(aux!=lg.end()){//only find into linear gradients + if(buscar.compare((*aux)->name)==0){ + return (*aux)->stops; + } + aux++; + } + } + return NULL; +} +void +Svg_parser::build_url(xmlpp::Element* root, String name,Matrix *mtx){ + if(!name.empty()){ + if(lg.empty()&& rg.empty()) + root->get_parent()->remove_child(root); + + int inicio=name.find_first_of("#")+1; + int fin=name.find_first_of(")"); + String buscar= name.substr(inicio,fin-inicio); + bool encontro=false; + if(!lg.empty()){ + std::list::iterator aux=lg.begin(); + while(aux!=lg.end()){ + if(buscar.compare((*aux)->name)==0){ + build_linearGradient (root,*aux,mtx); + encontro=true; + } + aux++; + } + } + if(!encontro && !rg.empty()){ + std::list::iterator aux=rg.begin(); + while(aux!=rg.end()){ + if(buscar.compare((*aux)->name)==0){ + build_radialGradient (root,*aux,mtx); + encontro=true; + } + aux++; + } + } + if(!encontro) + root->get_parent()->remove_child(root); + }else{ + root->get_parent()->remove_child(root); + } +} +void +Svg_parser::build_stop_color(xmlpp::Element* root, std::list *stops){ + std::list::iterator aux_stop=stops->begin(); + while(aux_stop!=stops->end()){ + xmlpp::Element *child=root->add_child("color"); + child->set_attribute("pos",etl::strprintf("%f",(*aux_stop)->pos)); + child->add_child("r")->set_child_text(etl::strprintf("%f",(*aux_stop)->r)); + child->add_child("g")->set_child_text(etl::strprintf("%f",(*aux_stop)->g)); + child->add_child("b")->set_child_text(etl::strprintf("%f",(*aux_stop)->b)); + child->add_child("a")->set_child_text(etl::strprintf("%f",(*aux_stop)->a)); + aux_stop++; + } +} +void +Svg_parser::build_linearGradient(xmlpp::Element* root,LinearGradient* data,Matrix* mtx){ + if(data){ + root->set_attribute("type","linear_gradient"); + root->set_attribute("active","true"); + root->set_attribute("desc","Gradient004"); + build_param (root->add_child("param"),"z_depth","real","0"); + build_param (root->add_child("param"),"amount","real","1"); + //straight onto + build_param (root->add_child("param"),"blend_method","integer","21"); + float x1,y1,x2,y2; + x1=data->x1; + y1=data->y1; + x2=data->x2; + y2=data->y2; + if(mtx){ + transformPoint2D(mtx,&x1,&y1); + transformPoint2D(mtx,&x2,&y2); + } + coor2vect (&x1,&y1); + coor2vect (&x2,&y2); + + build_vector (root->add_child("param"),"p1",x1,y1); + build_vector (root->add_child("param"),"p2",x2,y2); + //gradient link + xmlpp::Element *child=root->add_child("param"); + child->set_attribute("name","gradient"); + build_stop_color (child->add_child("gradient"),data->stops); + build_param (root->add_child("param"),"loop","bool","false"); + build_param (root->add_child("param"),"zigzag","bool","false"); + } +} +void +Svg_parser::build_radialGradient(xmlpp::Element* root,RadialGradient* data,Matrix* mtx){ +//not completed + if(data){ + root->set_attribute("type","radial_gradient"); + root->set_attribute("active","true"); + build_param (root->add_child("param"),"z_depth","real","0"); + build_param (root->add_child("param"),"amount","real","1"); + //straight onto + build_param (root->add_child("param"),"blend_method","integer","21"); + //gradient link + xmlpp::Element *child=root->add_child("param"); + child->set_attribute("name","gradient"); + build_stop_color (child->add_child("gradient"),data->stops); + //here the center point and radio + float cx=data->cx; + float cy=data->cy; + float r =data->r; + //transform + if(mtx){ + transformPoint2D(mtx,&cx,&cy); + } + //adjust + coor2vect (&cx,&cy); + r=r/kux; + build_vector (root->add_child("param"),"center",cx,cy); + build_param (root->add_child("param"),"radius","real",r); + + build_param (root->add_child("param"),"loop","bool","false"); + build_param (root->add_child("param"),"zigzag","bool","false"); + } +} + +void +Svg_parser::parser_linearGradient(const xmlpp::Node* node){ + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + Glib::ustring id =nodeElement->get_attribute_value("id"); + float x1 =atof(nodeElement->get_attribute_value("x1").data()); + float y1 =atof(nodeElement->get_attribute_value("y1").data()); + float x2 =atof(nodeElement->get_attribute_value("x2").data()); + float y2 =atof(nodeElement->get_attribute_value("y2").data()); + Glib::ustring link =nodeElement->get_attribute_value("href"); + + std::list *stops; + if(!link.empty()){ + stops=find_colorStop (link); + }else{ + //color stops + stops=new std::list(); + const xmlpp::ContentNode* nodeContent = dynamic_cast(node); + if(!nodeContent){ + xmlpp::Node::NodeList list = node->get_children(); + for(xmlpp::Node::NodeList::iterator iter = list.begin(); iter != list.end(); ++iter){ + Glib::ustring name =(*iter)->get_name(); + if(name.compare("stop")==0){ + const xmlpp::Element* nodeIter = dynamic_cast(*iter); + Glib::ustring style =nodeIter->get_attribute_value("style"); + float offset=atof(nodeIter->get_attribute_value("offset").data()); + String stop_color; + String opacity; + if(!style.empty()){ + extractSubAttribute (style,"stop-color",&stop_color); + extractSubAttribute (style,"stop-opacity",&opacity); + } + if(opacity.empty()) opacity="1"; + if(stop_color.empty()) stop_color="#000000";//black for default :S + stops->push_back(newColorStop(stop_color,atof(opacity.data()),offset)); + } + } + } + } + if(stops) + lg.push_back(newLinearGradient(id,x1,y1,x2,y2,stops)); + } +} + +void +Svg_parser::parser_radialGradient(const xmlpp::Node* node){ + if(const xmlpp::Element* nodeElement = dynamic_cast(node)){ + Glib::ustring id =nodeElement->get_attribute_value("id"); + float cx =atof(nodeElement->get_attribute_value("cx").data()); + float cy =atof(nodeElement->get_attribute_value("cy").data()); + float r =atof(nodeElement->get_attribute_value("r").data()); + Glib::ustring link =nodeElement->get_attribute_value("href");//basic + std::list *stops=NULL; + if(!link.empty()){ + //inkscape always use link, i dont need parser stops here, but it's posible + stops=find_colorStop (link); + } + if(stops) + rg.push_back(newRadialGradient(id,cx,cy,r,stops)); + } +} + +ColorStop* +Svg_parser::newColorStop(String color,float opacity,float pos){ + ColorStop* _stop; + _stop=(ColorStop*)malloc(sizeof(ColorStop)); + float r=getRed(color); + float g=getGreen(color); + float b=getBlue(color); + float a=opacity; + Color ret=adjustGamma(r/255,g/255,b/255,a); + _stop->r=ret.get_r(); + _stop->g=ret.get_g(); + _stop->b=ret.get_b(); + _stop->a=ret.get_a(); + _stop->pos=pos; + return _stop; +} +Color +Svg_parser::adjustGamma(float r,float g,float b,float a){ + Color ret(r,g,b,a); + if(gamma.get_gamma_r()!=1.0){ + if(ret.get_r() < 0) + ret.set_r(-gamma.r_F32_to_F32(-ret.get_r())); + else + ret.set_r(gamma.r_F32_to_F32(ret.get_r())); + } + if(gamma.get_gamma_g()!=1.0){ + if(ret.get_g() < 0) + ret.set_g(-gamma.g_F32_to_F32(-ret.get_g())); + else + ret.set_g(gamma.g_F32_to_F32(ret.get_g())); + } + if(gamma.get_gamma_b()!=1.0){ + if(ret.get_b() < 0) + ret.set_b(-gamma.b_F32_to_F32(-ret.get_b())); + else + ret.set_b(gamma.b_F32_to_F32(ret.get_b())); + } + return ret; +} + +LinearGradient* +Svg_parser::newLinearGradient(String name,float x1,float y1, float x2,float y2,std::list *stops){ + LinearGradient* data; + data=(LinearGradient*)malloc(sizeof(LinearGradient)); + sprintf(data->name,"%s",name.data()); + data->x1=x1; + data->y1=y1; + data->x2=x2; + data->y2=y2; + data->stops=stops; + return data; +} + +RadialGradient* +Svg_parser::newRadialGradient(String name,float cx,float cy,float r,std::list *stops){ + RadialGradient* data; + data=(RadialGradient*)malloc(sizeof(RadialGradient)); + sprintf(data->name,"%s",name.data()); + data->cx=cx; + data->cy=cy; + data->r=r; + data->stops=stops; + return data; +} + +//builds +void +Svg_parser::build_gamma(xmlpp::Element* root,float gamma){ + root->set_attribute("type","colorcorrect"); + root->set_attribute("active","true"); + root->set_attribute("version","0.1"); + root->set_attribute("desc","Gamma"); + build_real (root->add_child("param"),"gamma",gamma); +} +Matrix* +Svg_parser::build_transform(const String transform){ + Matrix* a=NULL; + String tf(transform); + removeIntoS(&tf); + std::vector tokens=tokenize(tf," "); + std::vector::iterator aux=tokens.begin(); + while(aux!=tokens.end()){ + if((*aux).compare(0,9,"translate")==0){ + float dx,dy; + int inicio,fin; + inicio =(*aux).find_first_of("(")+1; + fin =(*aux).find_first_of(","); + dx =atof((*aux).substr(inicio,fin-inicio).data()); + inicio =(*aux).find_first_of(",")+1; + fin =(*aux).size()-1; + dy =atof((*aux).substr(inicio,fin-inicio).data()); + if(matrixVacia(a)) + a=newMatrix(1,0,0,1,dx,dy); + else + multiplyMatrix(&a,newMatrix(1,0,0,1,dx,dy)); + }else if((*aux).compare(0,5,"scale")==0){ + if(matrixVacia(a)) + a=newMatrix(1,0,0,1,0,0); + }else if((*aux).compare(0,6,"rotate")==0){ + float angle,seno,coseno; + int inicio,fin; + inicio =(*aux).find_first_of("(")+1; + fin =(*aux).size()-1; + angle=getRadian (atof((*aux).substr(inicio,fin-inicio).data())); + seno =sin(angle); + coseno =cos(angle); + if(matrixVacia(a)) + a=newMatrix(coseno,seno,-1*seno,coseno,0,0); + else + multiplyMatrix(&a,newMatrix(coseno,seno,-1*seno,coseno,0,0)); + }else if((*aux).compare(0,6,"matrix")==0){ + int inicio =(*aux).find_first_of('(')+1; + int fin =(*aux).find_first_of(')'); + if(matrixVacia(a)) + a=newMatrix((*aux).substr(inicio,fin-inicio)); + else + multiplyMatrix(&a,newMatrix((*aux).substr(inicio,fin-inicio))); + }else{ + a=newMatrix(1,0,0,1,0,0); + } + aux++; + } + return a; +} + +void +Svg_parser::build_translate(xmlpp::Element* root,float dx,float dy){ + root->set_attribute("type","translate"); + root->set_attribute("active","true"); + root->set_attribute("version","0.1"); + build_vector (root->add_child("param"),"origin",dx,dy); +} +void +Svg_parser::build_rotate(xmlpp::Element* root,float dx,float dy,float angle){ + root->set_attribute("type","rotate"); + root->set_attribute("active","true"); + root->set_attribute("version","0.1"); + build_vector (root->add_child("param"),"origin",dx,dy); + build_real (root->add_child("param"),"amount",angle); +} +void +Svg_parser::build_points(xmlpp::Element* root,std::list p){ + root->set_attribute("name","vector_list"); + xmlpp::Element *child=root->add_child("dynamic_list"); + child->set_attribute("type","vector"); + std::list::iterator aux = p.begin(); + while(aux!=p.end()){ + xmlpp::Element *child_entry=child->add_child("entry"); + xmlpp::Element *child_vector=child_entry->add_child("vector"); + child_vector->add_child("x")->set_child_text(etl::strprintf("%f",(*aux)->x)); + child_vector->add_child("y")->set_child_text(etl::strprintf("%f",(*aux)->y)); + aux++; + } +} +void +Svg_parser::build_vertice(xmlpp::Element* root , Vertice *p){ + xmlpp::Element *child_comp=root->add_child("composite"); + child_comp->set_attribute("type","bline_point"); + build_vector (child_comp->add_child("param"),"point",p->x,p->y); + build_param (child_comp->add_child("width"),"","real","1.0000000000"); + build_param (child_comp->add_child("origin"),"","real","0.5000000000"); + if(p->split) build_param (child_comp->add_child("split"),"","bool","true"); + else build_param (child_comp->add_child("split"),"","bool","false"); + //tangente 1 + xmlpp::Element *child_t1=child_comp->add_child("t1"); + xmlpp::Element *child_rc=child_t1->add_child("radial_composite"); + child_rc->set_attribute("type","vector"); + build_param (child_rc->add_child("radius"),"","real",p->radio1); + build_param (child_rc->add_child("theta"),"","angle",p->angle1); + //tangente 2 + xmlpp::Element *child_t2=child_comp->add_child("t2"); + xmlpp::Element *child_rc2=child_t2->add_child("radial_composite"); + child_rc2->set_attribute("type","vector"); + build_param (child_rc2->add_child("radius"),"","real",p->radio2); + build_param (child_rc2->add_child("theta"),"","angle",p->angle2); + +} +void +Svg_parser::build_bline(xmlpp::Element* root,std::list p,bool loop,String blineguid){ + root->set_attribute("name","bline"); + xmlpp::Element *child=root->add_child("bline"); + child->set_attribute("type","bline_point"); + if(loop) + child->set_attribute("loop","true"); + else + child->set_attribute("loop","false"); + if(!blineguid.empty()) child->set_attribute("guid",blineguid); + std::list::iterator aux = p.begin(); + while(aux!=p.end()){ + if(*aux) build_vertice (child->add_child("entry"),*aux); + aux++; + } +} + +void +Svg_parser::build_param(xmlpp::Element* root,String name,String type,String value){ + if(!type.empty() && !value.empty()){ + if(!name.empty()) root->set_attribute("name",name); + xmlpp::Element *child=root->add_child(type); + child->set_attribute("value",value); + }else{ + root->get_parent()->remove_child(root); + } +} +void +Svg_parser::build_param(xmlpp::Element* root,String name,String type,float value){ + if(!type.empty()){ + if(!name.empty()) root->set_attribute("name",name); + xmlpp::Element *child=root->add_child(type); + child->set_attribute("value",etl::strprintf ("%f",value)); + }else{ + root->get_parent()->remove_child(root); + } +} +void +Svg_parser::build_param(xmlpp::Element* root,String name,String type,int value){ + if(!type.empty()){ + if(!name.empty()) root->set_attribute("name",name); + xmlpp::Element *child=root->add_child(type); + char *enteroc=new char[10]; + sprintf(enteroc,"%d",value); + child->set_attribute("value",enteroc); + delete [] enteroc; + }else{ + root->get_parent()->remove_child(root); + } +} + +void +Svg_parser::build_integer(xmlpp::Element* root,String name,int value){ + if(name.compare("")!=0) root->set_attribute("name",name); + xmlpp::Element *child=root->add_child("integer"); + char *enteroc=new char[10]; + sprintf(enteroc,"%d",value); + child->set_attribute("value",enteroc); +} +void +Svg_parser::build_real(xmlpp::Element* root,String name,float value){ + if(name.compare("")!=0) root->set_attribute("name",name); + xmlpp::Element *child=root->add_child("real"); + char *realc=new char[20]; + sprintf(realc,"%f",value); + child->set_attribute("value",realc); +} + +void +Svg_parser::build_color(xmlpp::Element* root,float r,float g,float b,float a){ + if(r>255 || g>255 || b>255 || a>1 || r<0 || g<0 || b<0 || a<0){ + root->get_parent()->remove_child(root); + printf("Color aborted\n"); + return; + } + Color ret=adjustGamma(r/255,g/255,b/255,a); + + root->set_attribute("name","color"); + xmlpp::Element *child=root->add_child("color"); + child->add_child("r")->set_child_text(etl::strprintf("%f",ret.get_r())); + child->add_child("g")->set_child_text(etl::strprintf("%f",ret.get_g())); + child->add_child("b")->set_child_text(etl::strprintf("%f",ret.get_b())); + child->add_child("a")->set_child_text(etl::strprintf("%f",ret.get_a())); +} +void +Svg_parser::build_vector(xmlpp::Element* root,String name,float x,float y){ + + if(name.compare("")!=0) root->set_attribute("name",name); + xmlpp::Element *child=root->add_child("vector"); + child->add_child("x")->set_child_text(etl::strprintf("%f",x)); + child->add_child("y")->set_child_text(etl::strprintf("%f",y)); + +} +void +Svg_parser::build_vector (xmlpp::Element* root,String name,float x,float y,String guid){ + if(name.compare("")!=0) root->set_attribute("name",name); + xmlpp::Element *child=root->add_child("vector"); + if(!guid.empty()) child->set_attribute("guid",guid); + child->add_child("x")->set_child_text(etl::strprintf("%f",x)); + child->add_child("y")->set_child_text(etl::strprintf("%f",y)); +} + +xmlpp::Element* +Svg_parser::nodeStartBasicLayer(xmlpp::Element* root){ + root->set_attribute("type","PasteCanvas"); + root->set_attribute("active","true"); + root->set_attribute("version","0.1"); + root->set_attribute("desc","Composite"); + build_param (root->add_child("param"),"z_depth","real","0"); + build_param (root->add_child("param"),"amount","real","1"); + build_param (root->add_child("param"),"blend_method","integer","0"); + build_vector (root->add_child("param"),"origin",0,0); + xmlpp::Element *child=root->add_child("param"); + child->set_attribute("name","canvas"); + return child->add_child("canvas"); +} + +//metodos extras +void +Svg_parser::coor2vect(float *x,float *y){ + float sx, sy; + sx=*x; + sy=*y; + sy= atof(height.c_str())-sy; + sx= sx - ox; + sy= sy - oy; + sx= sx / kux; + sy= sy / kux; + *x=sx; *y=sy; +} + +void +Svg_parser::setTg1(Vertice *p,float p1x,float p1y,float p2x,float p2y){ + float rd=0,ag=0; + float d1x,d1y,d2x,d2y,dx,dy; + d1x=p1x*60; + d1y=p1y*60; + d2x=p2x*60; + d2y=p2y*60; + dx=d2x-d1x; + dy=d2y-d1y; + dx=dx*3; + dy=dy*3; + dx=dx/60; + dy=dy/60; + rd=sqrt(dx*dx + dy*dy); + if(dx>0 && dy>0){ + ag=PI + atan(dy/dx); + }else if(dx>0 && dy<0){ + ag=PI + atan(dy/dx); + }else if(dx<0 && dy<0){ + ag=atan(dy/dx); + }else if(dx<0 && dy>0){ + ag= 2*PI+atan(dy/dx); + }else if(dx==0 && dy>0){ + ag=-1*PI/2; + }else if(dx==0 && dy<0){ + ag=PI/2; + }else if(dx==0 && dy==0){ + ag=0; + }else if(dx<0 && dy==0){ + ag=0; + }else if(dx>0 && dy==0){ + ag=PI; + } + ag= (ag*180)/PI; + p->radio1=rd; + p->angle1=ag; +} +void +Svg_parser::setTg2(Vertice* p,float p1x,float p1y,float p2x,float p2y){ + float rd=0,ag=0; + float d1x,d1y,d2x,d2y,dx,dy; + d1x=p1x*60; + d1y=p1y*60; + d2x=p2x*60; + d2y=p2y*60; + dx=d2x-d1x; + dy=d2y-d1y; + dx=dx*3; + dy=dy*3; + dx=dx/60; + dy=dy/60; + + rd=sqrt(dx*dx + dy*dy); + if(dx>0 && dy>0){ + ag=PI + atan(dy/dx); + // printf("caso 180-270\n"); + }else if(dx>0 && dy<0){ + ag=PI + atan(dy/dx); + // printf("caso 90-180\n"); + }else if(dx<0 && dy<0){ + ag=atan(dy/dx); + // printf("caso 0-90\n"); + }else if(dx<0 && dy>0){ + ag= 2*PI+atan(dy/dx); + // printf("caso 270-360\n"); + }else if(dx==0 && dy>0){ + ag=-1*PI/2; + }else if(dx==0 && dy<0){ + ag=PI/2; + }else if(dx==0 && dy==0){ + ag=0; + }else if(dx<0 && dy==0){ + ag=0; + }else if(dx>0 && dy==0){ + ag=PI; + } + ag= (ag*180)/PI; + ag=ag-180; + p->radio2=rd; + p->angle2=ag; +} + +void +Svg_parser::setSplit(Vertice* p,bool val){ + if(p!=NULL){ + p->split=val; + } +} +int +Svg_parser::isFirst(Vertice* nodo,float a, float b){ + if(nodo->x==a && nodo->y==b) + return 1; + return 0; +} + +Vertice* +Svg_parser::nuevoVertice(float x,float y){ + Vertice* nuevo; + nuevo=(Vertice*)malloc(sizeof(Vertice)); + nuevo->x=x; + nuevo->y=y; + nuevo->radio1=nuevo->radio2=nuevo->angle1=nuevo->angle2=0; + return nuevo; +} + +int +Svg_parser::extractSubAttribute(const String attribute, String name,String* value){ + int encontro=0; + if(!attribute.empty()){ + String str(attribute); + removeS(&str); + std::vector tokens=tokenize(str,";"); + std::vector::iterator aux=tokens.begin(); + while(aux!=tokens.end()){ + int medio= (*aux).find_first_of(":"); + if((*aux).substr(0,medio).compare(name)==0){ + int fin=(*aux).size(); + *value=(*aux).substr(medio+1,fin-medio); + return 1; + } + aux++; + } + } + return encontro; +} +String +Svg_parser::loadAttribute(String name,const String path_style,const String master_style,const String defaultVal){ + String value; + int fnd=0; + if(!path_style.empty()) + fnd=extractSubAttribute(path_style,name,&value); + if(fnd==0){ + if(!master_style.empty()) + fnd=extractSubAttribute(master_style,name,&value); + if(fnd==0) + value=defaultVal; + } + return value; +} +String +Svg_parser::loadAttribute(String name,const String path_style,const String master_style,const String subattribute,const String defaultVal){ + String value; + int fnd=0; + if(!path_style.empty()) + fnd=extractSubAttribute(path_style,name,&value); + if(fnd==0 && !master_style.empty()) + fnd=extractSubAttribute(master_style,name,&value); + if(fnd==0){ + if(!subattribute.empty()) + value=subattribute; + else + value=defaultVal; + } + return value; +} + +int +Svg_parser::randomLetter(){ + int a=rand()%2; + if(a) return (49 + rand()%9); + else return (65 + rand()%24); +} + +int +Svg_parser::getRed(String hex){ + if(hex.at(0)=='#'){ + return hextodec(hex.substr(1,2)); + }else if(hex.compare(0,3,"rgb")==0 || hex.compare(0,3,"RGB")==0){ + int inicio=hex.find_first_of("(")+1; + int fin =hex.find_last_of(")"); + String aux=tokenize(hex.substr(inicio,fin-inicio),",").at(0); + return atoi(aux.data()); + } + return 0; +} +int +Svg_parser::getGreen(String hex){ + if(hex.at(0)=='#'){ + return hextodec(hex.substr(3,2)); + }else if(hex.compare(0,3,"rgb")==0 || hex.compare(0,3,"RGB")==0){ + int inicio=hex.find_first_of("(")+1; + int fin =hex.find_last_of(")"); + String aux=tokenize(hex.substr(inicio,fin-inicio),",").at(1); + return atoi(aux.data()); + } + return 0; +} +int +Svg_parser::getBlue(String hex){ + if(hex.at(0)=='#'){ + return hextodec(hex.substr(5,2)); + }else if(hex.compare(0,3,"rgb")==0 || hex.compare(0,3,"RGB")==0){ + int inicio=hex.find_first_of("(")+1; + int fin =hex.find_last_of(")"); + String aux=tokenize(hex.substr(inicio,fin-inicio),",").at(2); + return atoi(aux.data()); + } + return 0; +} +int +Svg_parser::hextodec(String hex){ + int result=0; + if(!hex.empty()){ + int top=hex.size(); + int ihex[top]; + int i=0; + while(ia=a->a; data->b=a->b; data->c=a->c; + data->d=a->d; data->e=a->e; data->f=a->f; + return data; +} +Matrix* +Svg_parser::newMatrix(float a,float b,float c,float d,float e,float f){ + Matrix* data; + data=(Matrix*)malloc(sizeof(Matrix)); + data->a=a; data->b=b; data->c=c; + data->d=d; data->e=e; data->f=f; + return data; +} +Matrix* +Svg_parser::newMatrix(const String mvector){ + if(!mvector.empty()){ + Matrix* data=(Matrix*)malloc(sizeof(Matrix)); + std::vector tokens=tokenize(mvector,","); + if(tokens.size()!=6) return newMatrix(1,0,0,1,0,0); + data->a=atof(tokens.at(0).data()); + data->b=atof(tokens.at(1).data()); + data->c=atof(tokens.at(2).data()); + data->d=atof(tokens.at(3).data()); + data->e=atof(tokens.at(4).data()); + data->f=atof(tokens.at(5).data()); + return data; + }else{ + return newMatrix(1,0,0,1,0,0); + } +} +void +Svg_parser::transformPoint2D(Matrix *mtx,float *a,float *b){ + float auxa,auxb; + auxa=0; + auxb=0; + auxa= (*a)*(mtx->a) + (*b)*(mtx->c) + (mtx->e); + auxb= (*a)*(mtx->b) + (*b)*(mtx->d) + (mtx->f); + *a=auxa; + *b=auxb; + return; +} +void +Svg_parser::composeMatrix(Matrix **mtx,Matrix* mtx1,Matrix* mtx2){ + Matrix* aux=newMatrix(0,0,0,0,0,0); + aux->a=(mtx1->a)*(mtx2->a)+(mtx1->c)*(mtx2->b); + aux->b=(mtx1->b)*(mtx2->a)+(mtx1->d)*(mtx2->b); + aux->c=(mtx1->a)*(mtx2->c)+(mtx1->c)*(mtx2->d); + aux->d=(mtx1->b)*(mtx2->c)+(mtx1->d)*(mtx2->d); + aux->e=(mtx1->a)*(mtx2->e)+(mtx1->c)*(mtx2->f)+(mtx1->e); + aux->f=(mtx1->b)*(mtx2->e)+(mtx1->d)*(mtx2->f)+(mtx1->f); + *mtx=aux; +} +void +Svg_parser::multiplyMatrix(Matrix **mtx1,Matrix *mtx2){ + Matrix* aux=newMatrix(0,0,0,0,0,0); + aux->a=((*mtx1)->a)*(mtx2->a)+((*mtx1)->c)*(mtx2->b); + aux->b=((*mtx1)->b)*(mtx2->a)+((*mtx1)->d)*(mtx2->b); + aux->c=((*mtx1)->a)*(mtx2->c)+((*mtx1)->c)*(mtx2->d); + aux->d=((*mtx1)->b)*(mtx2->c)+((*mtx1)->d)*(mtx2->d); + aux->e=((*mtx1)->a)*(mtx2->e)+((*mtx1)->c)*(mtx2->f)+((*mtx1)->e); + aux->f=((*mtx1)->b)*(mtx2->e)+((*mtx1)->d)*(mtx2->f)+((*mtx1)->f); + (*mtx1)->a=aux->a; + (*mtx1)->b=aux->b; + (*mtx1)->c=aux->c; + (*mtx1)->d=aux->d; + (*mtx1)->e=aux->e; + (*mtx1)->f=aux->f; +} +bool +Svg_parser::matrixVacia(Matrix *mtx){ + if(mtx == NULL) return true; + return false; +} + +float +Svg_parser::getRadian(float sexa){ + return (sexa*2*PI)/360; +} +void +Svg_parser::removeS(String *input){ + for(unsigned int i=0;isize();i++){ + if(input->at(i)==' '){ + input->erase(i,1); + } + } +} +void +Svg_parser::removeIntoS(String *input){ + bool into=false; + for(unsigned int i=0;isize();i++){ + if(input->at(i)=='('){ + into=true; + }else if(input->at(i)==')'){ + into=false; + }else if(into && input->at(i)==' '){ + input->erase(i,1); + } + } +} +std::vector +Svg_parser::tokenize(const String& str,const String& delimiters){ + std::vector tokens; + String::size_type lastPos = str.find_first_not_of(delimiters, 0); + String::size_type pos = str.find_first_of(delimiters, lastPos); + while (String::npos != pos || String::npos != lastPos){ + tokens.push_back(str.substr(lastPos, pos - lastPos)); + lastPos = str.find_first_not_of(delimiters, pos); + pos = str.find_first_of(delimiters, lastPos); + } + return tokens; +} +String +Svg_parser::new_guid(){ + uid++; + return GUID::hasher(uid).get_string(); +} + diff --git a/synfig-core/trunk/src/modules/mod_svg/svg_parser.h b/synfig-core/trunk/src/modules/mod_svg/svg_parser.h new file mode 100644 index 0000000..694add7 --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/svg_parser.h @@ -0,0 +1,211 @@ +/* === S Y N F I G ========================================================= */ +/*! \file svg_parser.h +** \brief Implementation of the Svg parser +** \brief Based on SVG XML specification 1.1 +** \brief See: http://www.w3.org/TR/xml11/ for deatils +** +** $Id$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2007, 2008 Chris Moore +** Copyright (c) 2009 Carlos A. Sosa Navarro +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +*/ +/* ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __SVG_PARSER_H +#define __SVG_PARSER_H + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +namespace synfig{ + +typedef struct matrix_t{ + float a,c,e; + float b,d,f; +}Matrix; + +typedef struct stop_t{ + float r,g,b; + float a; + float pos; +}ColorStop; +typedef struct linear_g{ + char name[40]; + float x1,x2,y1,y2; + std::list *stops; //paradas de color +}LinearGradient; +typedef struct radial_g{ + char name[40]; + float cx,cy;//center point + //float fx,fy; + //focus, i dont see it in synfig + //if this value is omitted then will be = cx,cy + float r; //radio radius + std::list *stops; //paradas de color +}RadialGradient; + +typedef struct url_t{ + int type; + void* data; +}URL; + +typedef struct vertice_t{ + float x,y; + float radio1,angle1; + float radio2,angle2; + bool split; +}Vertice; +class Svg_parser +{ + //this is inkscape oriented in some cases +public: + +private: + Gamma gamma; + String filepath; + String id_name; + xmlpp::DomParser parser; + xmlpp::Document document; + xmlpp::Element* nodeRoot;//output + Glib::ustring width; + Glib::ustring height; + Glib::ustring docname; + int uid; + int kux,set_canvas; + float ox,oy; + bool loop;//aux :D + //urls + std::list lg; + std::list rg; + +public: + Svg_parser(); + Canvas::Handle load_svg_canvas(std::string _filepath,String &errors, String &warnings); + //String get_id(); + //void set_id(String source); + +private: //parser bucle + void parser_node(const xmlpp::Node* node); + //parser headers + void parser_svg(const xmlpp::Node* node); + void parser_canvas(const xmlpp::Node* node); + //layers + void parser_layer(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent); + void parser_path(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent); + void parser_polygon(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent); + void parser_rect(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent); + //defs + void parser_defs(const xmlpp::Node* node); + void parser_linearGradient(const xmlpp::Node* node); + void parser_radialGradient(const xmlpp::Node* node); + ColorStop* newColorStop(String color,float opacity,float pos); + LinearGradient* newLinearGradient(String name,float x1,float y1, float x2,float y2,std::list *stops); + RadialGradient* newRadialGradient(String name,float cx,float cy,float r,std::list *stops); + //builds urls + void AdjustPointUrl(); + std::list* find_colorStop(String name); + void build_url(xmlpp::Element* root, String name,Matrix *mtx); + void build_linearGradient(xmlpp::Element* root,LinearGradient* data,Matrix* mtx); + void build_radialGradient(xmlpp::Element* root,RadialGradient* data,Matrix* mtx); + void build_stop_color(xmlpp::Element* root, std::list *stops); + void build_stop_color(xmlpp::Element* root, std::list *stops,String name); + Color adjustGamma(float r,float g,float b,float a); + //builds + void build_gamma(xmlpp::Element* root,float gamma); + Matrix* build_transform(const String transform); + void build_rotate(xmlpp::Element* root,float dx,float dy,float angle); + void build_translate(xmlpp::Element* root,float dx,float dy); + void build_points(xmlpp::Element* root,std::list p); + void build_vertice(xmlpp::Element* root , Vertice *p); + void build_bline(xmlpp::Element* root,std::list p,bool loop,String blinegui); + void build_param (xmlpp::Element* root,String name,String type,String value); + void build_param (xmlpp::Element* root,String name,String type,float value); + void build_param (xmlpp::Element* root,String name,String type,int value); + void build_integer (xmlpp::Element* root,String name, int value); + void build_real (xmlpp::Element* root,String name,float value); + void build_vector (xmlpp::Element* root,String name,float x,float y); + void build_vector (xmlpp::Element* root,String name,float x,float y,String guid); + void build_color(xmlpp::Element* root,float r,float g,float b,float a); + xmlpp::Element* nodeStartBasicLayer(xmlpp::Element* root); + + //points,etc + void coor2vect(float *x,float *y); + void setTg2(Vertice* p,float p1x,float p1y,float p2x,float p2y); + void setTg1(Vertice *p,float p1x,float p1y,float p2x,float p2y); + void setSplit(Vertice* p,bool val); + int isFirst(Vertice* nodo,float a, float b); + Vertice* nuevoVertice(float x,float y); + + //matrix operations + Matrix* newMatrix(float a,float b,float c,float d,float e,float f); + Matrix* newMatrix(const String mvector); + Matrix* newMatrix(Matrix *a); + void transformPoint2D(Matrix *mtx,float *a,float *b); + bool matrixVacia(Matrix* mtx); + void composeMatrix(Matrix **mtx,Matrix *mtx1,Matrix *mtx2); + void multiplyMatrix(Matrix **mtx1,Matrix *mtx2); + float getRadian(float sexa); + //attributes + int extractSubAttribute(const String attribute, String name,String* value); + String loadAttribute(String name,const String path_style,const String master_style,const String subattribute,const String defaultVal); + String loadAttribute(String name,const String path_style,const String master_style,const String defaultVal); + std::vector get_tokens_path(String path); + std::list > parser_path_d(String path_d,Matrix* mtx); + int randomLetter(); + int getRed(String hex); + int getGreen(String hex); + int getBlue(String hex); + int hextodec(String hex); + float getDimension(const String ac); + //funciones string + void removeS(String *input); + void removeIntoS(String *input); + std::vector tokenize(const String& str,const String& delimiters); + void get_canvas_name(String _filepath); + String new_guid(); +}; +// END of Svg_parser class + +/* === E X T E R N S ======================================================= */ + +extern Canvas::Handle open_svg(std::string _filepath,String &errors, String &warnings); + +}; // END of namespace synfig + +/* === E N D =============================================================== */ + +#endif diff --git a/synfig-core/trunk/src/modules/mod_svg/unmod_svg.nsh b/synfig-core/trunk/src/modules/mod_svg/unmod_svg.nsh new file mode 100644 index 0000000..839ddba --- /dev/null +++ b/synfig-core/trunk/src/modules/mod_svg/unmod_svg.nsh @@ -0,0 +1,9 @@ +Section "un.mod_svg" + Delete "$INSTDIR\lib\synfig\modules\mod_svg.dll" + RMDir "$INSTDIR\lib\synfig\modules" + RMDir "$INSTDIR\lib\synfig" + RMDir "$INSTDIR\lib" + RMDir "$INSTDIR" +SectionEnd + + diff --git a/synfig-core/trunk/src/modules/synfig_modules.cfg.in b/synfig-core/trunk/src/modules/synfig_modules.cfg.in index fe45ead..899e295 100644 --- a/synfig-core/trunk/src/modules/synfig_modules.cfg.in +++ b/synfig-core/trunk/src/modules/synfig_modules.cfg.in @@ -15,3 +15,4 @@ mod_openexr mod_jpeg mod_libavcodec mod_yuv420p +mod_svg diff --git a/synfig-core/trunk/src/synfig/loadcanvas.cpp b/synfig-core/trunk/src/synfig/loadcanvas.cpp index 433eeb0..3da37e9 100644 --- a/synfig-core/trunk/src/synfig/loadcanvas.cpp +++ b/synfig-core/trunk/src/synfig/loadcanvas.cpp @@ -7,6 +7,7 @@ ** \legal ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley ** Copyright (c) 2007, 2008 Chris Moore +** Copyright (c) 2009 Carlos A. Sosa Navarro ** ** This package is free software; you can redistribute it and/or ** modify it under the terms of the GNU General Public License as @@ -2216,3 +2217,85 @@ CanvasParser::parse_from_file_as(const String &file_,const String &as_,String &e } return Canvas::Handle(); } + +Canvas::Handle +CanvasParser::parse_as(xmlpp::Element* node,String &errors) +{ + ChangeLocale change_locale(LC_NUMERIC, "C"); + try + { + total_warnings_=0; + if(node) + { + Canvas::Handle canvas(parse_canvas(node,0,false,"")); + if (!canvas) return canvas; + + const ValueNodeList& value_node_list(canvas->value_node_list()); + + again: + ValueNodeList::const_iterator iter; + for(iter=value_node_list.begin();iter!=value_node_list.end();++iter) + { + ValueNode::Handle value_node(*iter); + if(value_node->is_exported() && value_node->get_id().find("Unnamed")==0) + { + canvas->remove_value_node(value_node); + goto again; + } + } + + return canvas; + } + } + catch(Exception::BadLinkName) { synfig::error("BadLinkName Thrown"); } + catch(Exception::BadType) { synfig::error("BadType Thrown"); } + catch(Exception::FileNotFound) { synfig::error("FileNotFound Thrown"); } + catch(Exception::IDNotFound) { synfig::error("IDNotFound Thrown"); } + catch(Exception::IDAlreadyExists) { synfig::error("IDAlreadyExists Thrown"); } + catch(xmlpp::internal_error x) + { + if (!strcmp(x.what(), "Couldn't create parsing context")) + throw runtime_error(String(" * ") + _("Can't open file") + " \"" + "\""); + throw; + } + catch(const std::exception& ex) + { + synfig::error("Standard Exception: "+String(ex.what())); + errors = ex.what(); + return Canvas::Handle(); + } + catch(const String& str) + { + cerr< loading_; @@ -178,6 +180,7 @@ private: //! Loads a canvas from \a filename /*! \return The Canvas's handle on success, an empty handle on failure */ +extern Canvas::Handle open_canvas(xmlpp::Element* node,String &errors,String &warnings); extern Canvas::Handle open_canvas(const String &filename,String &errors,String &warnings); extern Canvas::Handle open_canvas_as(const String &filename,const String &as,String &errors,String &warnings); diff --git a/synfig-studio/trunk/src/synfigapp/canvasinterface.cpp b/synfig-studio/trunk/src/synfigapp/canvasinterface.cpp index bd7766f..cfc5db6 100644 --- a/synfig-studio/trunk/src/synfigapp/canvasinterface.cpp +++ b/synfig-studio/trunk/src/synfigapp/canvasinterface.cpp @@ -7,6 +7,7 @@ ** \legal ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley ** Copyright (c) 2007, 2008 Chris Moore +** Copyright (c) 2009 Carlos A. Sosa Navarro ** ** This package is free software; you can redistribute it and/or ** modify it under the terms of the GNU General Public License as @@ -52,6 +53,7 @@ #include "instance.h" #include "actions/layeradd.h" +#include "actions/layerremove.h" #include "actions/valuedescconvert.h" #include "actions/valuenodeadd.h" #include "actions/editmodeset.h" @@ -578,6 +580,33 @@ CanvasInterface::import(const synfig::String &filename, synfig::String &errors, if (ext.size()) ext = ext.substr(1); // skip initial '.' std::transform(ext.begin(),ext.end(),ext.begin(),&::tolower); + if(ext=="svg"){//I don't like it, but worse is nothing + Layer::Handle _new_layer(add_layer_to("PasteCanvas",get_canvas())); + Layer::Handle _aux_layer(add_layer_to("svg_layer",get_canvas())); + if(_aux_layer){ + _aux_layer->set_param("filename",ValueBase(filename)); + _new_layer->set_param("canvas",ValueBase(_aux_layer->get_param("canvas"))); + //remove aux layer + Action::Handle action(Action::LayerRemove::create()); + assert(action); + if(!action) + return 0; + action->set_param("canvas",get_canvas()); + action->set_param("canvas_interface",etl::loose_handle(this)); + action->set_param("layer",_aux_layer); + if(!action->is_ready()){ + get_ui_interface()->error(_("Action Not Ready")); + return 0; + } + if(!get_instance()->perform_action(action)){ + get_ui_interface()->error(_("Action Failed.")); + return 0; + } + } + signal_layer_new_description()(_new_layer,filename); + return true; + } + // If this is a SIF file, then we need to do things slightly differently if(ext=="sif" || ext=="sifz")try {