X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-core%2Fsrc%2Fmodules%2Fmod_svg%2Fsvg_parser.cpp;h=680aa4faefe508a94ceecf6b79a5187e2d8b6620;hb=91defb05c4f94290665a867c6447c47f4339d013;hp=25f3e2456aa512d51d1d20def594d0d75ad2fc03;hpb=f5ede3588e4d31eb1d28486f4e6f7467876d9c07;p=synfig.git diff --git a/synfig-core/src/modules/mod_svg/svg_parser.cpp b/synfig-core/src/modules/mod_svg/svg_parser.cpp index 25f3e24..680aa4f 100644 --- a/synfig-core/src/modules/mod_svg/svg_parser.cpp +++ b/synfig-core/src/modules/mod_svg/svg_parser.cpp @@ -10,6 +10,7 @@ ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley ** Copyright (c) 2008 Chris Moore ** Copyright (c) 2009 Carlos A. Sosa Navarro +** Copyright (c) 2009 Nikita Kitaev ** ** This package is free software; you can redistribute it and/or ** modify it under the terms of the GNU General Public License as @@ -39,6 +40,14 @@ using namespace synfig; /* === G L O B A L S ======================================================= */ +//PARSER PREFERENCES + +//Seperate transformations: apply transformations on a per-layer basis, rather than on canvases +#define SVG_SEP_TRANSFORMS 1 + +//Resolve BLine transformations: resolve transformations instead of creating transformation layers +#define SVG_RESOLVE_BLINE 1 + /* === P R O C E D U R E S ================================================= */ Canvas::Handle @@ -117,6 +126,9 @@ Svg_parser::set_id(String source){ */ //UPDATE + +/* === PARSERS ============================================================= */ + void Svg_parser::parser_node(const xmlpp::Node* node){ const xmlpp::ContentNode* nodeContent = dynamic_cast(node); @@ -203,15 +215,7 @@ Svg_parser::parser_canvas (const xmlpp::Node* node){ else nodeRoot->add_child("name")->set_child_text("Synfig Animation 1"); } set_canvas=1; - AdjustPointUrl (); } -//Toplevel parser - -//parser preferences -//Seperate transformations: apply transformations on a per-layer basis, rather than on canvases -//Resolve BLine transformations: resolve transformations instead of creating transformation layers -#define SVG_SEP_TRANSFORMS 1 -#define SVG_RESOLVE_BLINE 1 void Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx_parent){ @@ -226,7 +230,7 @@ Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String //resolve transformations Matrix* mtx=NULL; if(!transform.empty()) - mtx=build_transform (transform); + mtx=parser_transform (transform); if (SVG_SEP_TRANSFORMS) { if(mtx_parent){ @@ -275,57 +279,54 @@ Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String typeStroke=2; //gradient } - xmlpp::Element* child_layer = nodeStartBasicLayer(root->add_child("layer")); - xmlpp::Element* child_fill = child_layer; - xmlpp::Element* child_stroke = child_layer; - if(typeFill==2){ - child_fill=nodeStartBasicLayer(child_fill->add_child("layer")); - } - if(typeStroke==2){ - child_stroke=nodeStartBasicLayer(child_stroke->add_child("layer")); - } + xmlpp::Element* child_layer = root; + xmlpp::Element* child_fill; + xmlpp::Element* child_stroke; //make simple fills if(nodename.compare("rect")==0 && typeFill!=0){ - rect_simple(nodeElement,child_fill,fill,fill_opacity,opacity); + if (mtx) child_layer = nodeStartBasicLayer(root->add_child("layer"), id); + child_fill=child_layer; + parser_rect(nodeElement,child_fill,fill,fill_opacity,opacity); if(typeFill==2){ - build_url (child_fill->add_child("layer"),fill,NULL); + build_fill (child_fill,fill,NULL); } parser_effects(nodeElement,child_layer,parent_style,mtx); return; } - + if ((!(SVG_RESOLVE_BLINE) && mtx) || typeFill==2 || typeStroke==2) + child_layer = nodeStartBasicLayer(root->add_child("layer"), id); + child_fill=child_layer; + child_stroke=child_layer; //======================================================================= - std::list > k; + + std::list k; //if we are creating a bline - //First, create the list of vertices + //First, create the list of Verteces if (SVG_RESOLVE_BLINE) { if(nodename.compare("path")==0){ k=parser_path_d (nodeElement->get_attribute_value("d"),mtx); } else if(nodename.compare("polygon")==0){ - k=parser_polygon_path (nodeElement->get_attribute_value("points"),mtx); + k=parser_path_polygon (nodeElement->get_attribute_value("points"),mtx); } } else { if(nodename.compare("path")==0){ k=parser_path_d (nodeElement->get_attribute_value("d"),NULL); } else if(nodename.compare("polygon")==0){ - k=parser_polygon_path (nodeElement->get_attribute_value("points"),NULL); + k=parser_path_polygon (nodeElement->get_attribute_value("points"),NULL); } } - int n = k.size(); - String bline_id[n]; - String offset_id[n]; - for (int i=0;i::iterator aux; + //int n = k.size(); - std::list >::iterator aux = k.begin(); if(typeFill!=0){//region layer - for (int i=0; aux!=k.end(); aux++){ + /*if(typeFill==2){ + child_fill=nodeStartBasicLayer(child_fill->add_child("layer")); + }*/ + for (aux = k.begin(); aux!=k.end(); aux++){ xmlpp::Element *child_region=child_fill->add_child("layer"); child_region->set_attribute("type","region"); child_region->set_attribute("active","true"); @@ -335,7 +336,7 @@ Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String 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())); - build_vector (child_region->add_child("param"),"offset",0,0,offset_id[i]); + build_vector (child_region->add_child("param"),"offset",0,0, *(*aux)->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"); @@ -343,19 +344,20 @@ Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String 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[i]); - i++; + build_bline (child_region->add_child("param"),*(*aux)->points,(*aux)->loop,*(*aux)->bline_id); } } if(typeFill==2){ //gradient in onto mode (fill) if (SVG_RESOLVE_BLINE) - build_url(child_fill->add_child("layer"),fill,mtx); + build_fill(child_fill,fill,mtx); else - build_url(child_fill->add_child("layer"),fill,NULL); + build_fill(child_fill,fill,NULL); } if(typeStroke!=0){//outline layer - int i=0; + if(typeStroke==2){ + child_stroke=nodeStartBasicLayer(child_stroke->add_child("layer"),"stroke"); + } for (aux=k.begin(); aux!=k.end(); aux++){ xmlpp::Element *child_outline=child_stroke->add_child("layer"); child_outline->set_attribute("type","outline"); @@ -366,7 +368,7 @@ Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String 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())); - build_vector (child_outline->add_child("param"),"offset",0,0,offset_id[i]); + build_vector (child_outline->add_child("param"),"offset",0,0,*(*aux)->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"); @@ -374,7 +376,7 @@ Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String //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[i]); + build_bline (child_outline->add_child("param"),*(*aux)->points,(*aux)->loop,*(*aux)->bline_id); stroke_width=etl::strprintf("%f",getDimension(stroke_width)/kux); build_param (child_outline->add_child("param"),"width","real",stroke_width); @@ -390,56 +392,24 @@ Svg_parser::parser_graphics(const xmlpp::Node* node,xmlpp::Element* root,String } build_param (child_outline->add_child("param"),"loopyness","real","1.0000000000"); build_param (child_outline->add_child("param"),"homogeneous_width","bool","true"); - - - i++; } if(typeStroke==2){ //gradient in onto mode (stroke) - if (SVG_RESOLVE_BLINE) - build_url(child_stroke->add_child("layer"),fill,mtx); - else - build_url(child_stroke->add_child("layer"),fill,NULL); - } - if (SVG_RESOLVE_BLINE) - parser_effects(nodeElement,child_layer,parent_style,NULL); - else - parser_effects(nodeElement,child_layer,parent_style,mtx); - + if (SVG_RESOLVE_BLINE) + build_fill(child_stroke,stroke,mtx); + else + build_fill(child_stroke,stroke,NULL); + } } + + if (SVG_RESOLVE_BLINE) + parser_effects(nodeElement,child_layer,parent_style,NULL); + else + parser_effects(nodeElement,child_layer,parent_style,mtx); } } -void -Svg_parser::rect_simple(const xmlpp::Element* nodeElement,xmlpp::Element* root,String fill, String fill_opacity, String opacity){ - Glib::ustring rect_id =nodeElement->get_attribute_value("id"); - 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"); - - 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); - - -} +/* === LAYER PARSERS ======================================================= */ void Svg_parser::parser_layer(const xmlpp::Node* node,xmlpp::Element* root,String parent_style,Matrix* mtx){ @@ -482,16 +452,50 @@ Svg_parser::parser_layer(const xmlpp::Node* node,xmlpp::Element* root,String par parser_graphics (*iter,child_canvas,layer_style,mtx); } } - if (! SVG_SEP_TRANSFORMS) parser_effects(nodeElement,child_canvas,parent_style,mtx); + if (SVG_SEP_TRANSFORMS) parser_effects(nodeElement,child_canvas,parent_style,NULL); + else parser_effects(nodeElement,child_canvas,parent_style,mtx); } } -std::list > -Svg_parser::parser_polygon_path(Glib::ustring polygon_points, Matrix* mtx){ - std::list > k0; +void +Svg_parser::parser_rect(const xmlpp::Element* nodeElement,xmlpp::Element* root,String fill, String fill_opacity, String opacity){ + Glib::ustring rect_id =nodeElement->get_attribute_value("id"); + 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"); + + 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); + + +} + +/* === CONVERT TO PATH PARSERS ============================================= */ + +std::list +Svg_parser::parser_path_polygon(Glib::ustring polygon_points, Matrix* mtx){ + std::list k0; if(polygon_points.empty()) return k0; - std::list k; + std::list points; std::vector tokens=get_tokens_path (polygon_points); unsigned int i; float ax,ay; ax=ay=0; @@ -504,114 +508,24 @@ Svg_parser::parser_polygon_path(Glib::ustring polygon_points, Matrix* mtx){ //adjust coor2vect(&ax,&ay); //save - k.push_back(newVertice(ax,ay)); + points.push_back(newVertex(ax,ay)); } - k0.push_front(k); + k0.push_front(newBLine(&points, true)); return k0; } -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 > +std::list Svg_parser::parser_path_d(String path_d,Matrix* mtx){ - std::list > k; - std::list k1; + std::list k; + std::list k1; + std::vector tokens=get_tokens_path(path_d); String command="M"; //the current command float ax,ay,tgx,tgy,tgx2,tgy2;//each method ax=ay=0; float actual_x=0,actual_y=0; //in svg coordinate space float old_x=0,old_y=0; //needed in rare cases - loop=false; + float init_x=0,init_y=0; //for closepath commands for(unsigned int i=0;ix,k1.front()->y,tgx,tgy); }else{ - k1.push_back(newVertice (ax,ay)); + k1.push_back(newVertex (ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); setSplit(k1.back(),TRUE); } @@ -709,7 +626,7 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ //save setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); setSplit(k1.back(),FALSE); - k1.push_back(newVertice (ax,ay)); + k1.push_back(newVertex (ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); }else if(command.compare("L")==0 || command.compare("l")==0){ //line to //point @@ -728,7 +645,7 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ 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(newVertice(ax,ay)); + k1.push_back(newVertex(ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); } }else if(command.compare("H")==0 || command.compare("h")==0){// horizontal move @@ -747,7 +664,7 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ 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(newVertice(ax,ay)); + k1.push_back(newVertex(ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); } }else if(command.compare("V")==0 || command.compare("v")==0){//vertical @@ -765,7 +682,7 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ 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(newVertice(ax,ay)); + k1.push_back(newVertex(ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,k1.back()->x,k1.back()->y); } }else if(command.compare("T")==0 || command.compare("t")==0){// I don't know what does it @@ -777,14 +694,14 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ //isn't complete support, is only for circles //this curve have 6 parameters - //radio - float radio_x,radio_y; + //radius + float radius_x,radius_y; float angle; bool sweep,large; - //radio - radio_x=atof(tokens.at(i).data()); + //radius + radius_x=atof(tokens.at(i).data()); i++; if(tokens.at(i).compare(",")==0) i++; - radio_y=atof(tokens.at(i).data()); + radius_y=atof(tokens.at(i).data()); //angle i++; angle=atof(tokens.at(i).data()); //flags @@ -797,10 +714,10 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ //how to draw? if(!large && !sweep){ //points - tgx2 = old_x + radio_x*0.5; + tgx2 = old_x + radius_x*0.5; tgy2 = old_y ; tgx = actual_x; - tgy = actual_y + radio_y*0.5; + tgy = actual_y + radius_y*0.5; ax=actual_x; ay=actual_y; @@ -819,15 +736,15 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ if(isFirst(k1.front(),ax,ay)){ setTg1(k1.front(),k1.front()->x,k1.front()->y,tgx,tgy); }else{ - k1.push_back(newVertice (ax,ay)); + k1.push_back(newVertex (ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); setSplit(k1.back(),TRUE); } }else if(!large && sweep){ //points tgx2 = old_x; - tgy2 = old_y + radio_y*0.5; - tgx = actual_x + radio_x*0.5; + tgy2 = old_y + radius_y*0.5; + tgx = actual_x + radius_x*0.5; tgy = actual_y ; ax=actual_x; @@ -847,7 +764,7 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ if(isFirst(k1.front(),ax,ay)){ setTg1(k1.front(),k1.front()->x,k1.front()->y,tgx,tgy); }else{ - k1.push_back(newVertice (ax,ay)); + k1.push_back(newVertex (ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); setSplit(k1.back(),TRUE); } @@ -859,16 +776,16 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ if(old_x>actual_x) sense =-1; float in_x,in_y,in_tgx1,in_tgy1,in_tgx2,in_tgy2; in_x = (old_x+actual_x)/2; - in_y = old_y - sense*radio_y; - in_tgx1 = in_x - sense*(radio_x*0.5); - in_tgx2 = in_x + sense*(radio_x*0.5); + in_y = old_y - sense*radius_y; + in_tgx1 = in_x - sense*(radius_x*0.5); + in_tgx2 = in_x + sense*(radius_x*0.5); in_tgy1 = in_y; in_tgy2 = in_y; //start/end points tgx2=old_x; - tgy2=actual_y - sense*(radio_y*0.5); + tgy2=actual_y - sense*(radius_y*0.5); tgx =actual_x; - tgy =actual_y - sense*(radio_y*0.5); + tgy =actual_y - sense*(radius_y*0.5); ax=actual_x; ay=actual_y; @@ -894,7 +811,7 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ //save the last tg2 setTg2(k1.back(),k1.back()->x,k1.back()->y,tgx2,tgy2); //save the intermediate point - k1.push_back(newVertice (in_x,in_y)); + k1.push_back(newVertex (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 @@ -902,24 +819,66 @@ Svg_parser::parser_path_d(String path_d,Matrix* mtx){ if(isFirst(k1.front(),ax,ay)){ setTg1(k1.front(),k1.front()->x,k1.front()->y,tgx,tgy); }else{ - k1.push_back(newVertice (ax,ay)); + k1.push_back(newVertex (ax,ay)); setTg1(k1.back(),k1.back()->x,k1.back()->y,tgx,tgy); setSplit(k1.back(),TRUE); } } }else if(command.compare("z")==0){ - loop=true; + k.push_front(newBLine(&k1, true)); + k1.clear(); + if (i(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); + } + } + } +} + +/* === BUILDS ============================================================== */ + void -Svg_parser::parser_effects(const xmlpp::Element* nodeElement,xmlpp::Element* root,String parent_style,Matrix* mtx){ +Svg_parser::build_transform(xmlpp::Element* root,Matrix* mtx){ if (mtx) { xmlpp::Element *child_transform=root->add_child("layer"); child_transform->set_attribute("type","warp"); @@ -956,46 +915,6 @@ Svg_parser::parser_effects(const xmlpp::Element* nodeElement,xmlpp::Element* roo } } - -void -Svg_parser::parser_defs(const xmlpp::Node* node){ - 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("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()){ @@ -1015,12 +934,10 @@ Svg_parser::find_colorStop(String name){ } return NULL; } + void -Svg_parser::build_url(xmlpp::Element* root, String name,Matrix *mtx){ +Svg_parser::build_fill(xmlpp::Element* root, String name,Matrix *mtx){ if(!name.empty()){ - if(lg.empty()&& rg.empty()) - root->get_parent()->remove_child(root); - int start=name.find_first_of("#")+1; int end=name.find_first_of(")"); String find= name.substr(start,end-start); @@ -1045,10 +962,6 @@ Svg_parser::build_url(xmlpp::Element* root, String name,Matrix *mtx){ aux++; } } - if(!encounter) - root->get_parent()->remove_child(root); - }else{ - root->get_parent()->remove_child(root); } } void @@ -1067,65 +980,137 @@ Svg_parser::build_stop_color(xmlpp::Element* root, std::list *stops) 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"); + xmlpp::Element* gradient=root->add_child("layer"); + + gradient->set_attribute("type","linear_gradient"); + gradient->set_attribute("active","true"); + gradient->set_attribute("desc",data->name); + build_param (gradient->add_child("param"),"z_depth","real","0"); + build_param (gradient->add_child("param"),"amount","real","1"); //straight onto - build_param (root->add_child("param"),"blend_method","integer","21"); + build_param (gradient->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); + + + if (mtx || data->transform){ + Matrix *mtx2=NULL; + if (mtx && data->transform){ + composeMatrix(&mtx2,mtx,data->transform); + }else if (mtx){ + mtx2=mtx; + }else if (data->transform){ + mtx2=data->transform; + } + //matrix transforms the gradient as a whole + //it does not preserve angles, so we cant' simply transform both points + float x3, y3, k; + //set point (x3,y3) on the same gradient line as (x2,y2) + //the gradient line is perpendicular to (x1,y1)(x2,y2) + x3=x2+(y2-y1); + y3=y2-(x2-x1); + //transform everything + transformPoint2D(mtx2,&x1,&y1); + transformPoint2D(mtx2,&x2,&y2); + transformPoint2D(mtx2,&x3,&y3); + + if (x2!=x3 && y2!=y3) {//divide by zero check + + //set k as slope between (x2,y2) and (x3,y3) + //k is the slope of gradient lines post-transformation + k=(y3-y2)/(x3-x2); + //set point (x2,y2) on the gradient line passing through (x3,y3) + //so that the line (x1,y1)(x2,y2) is perpendicular to (x2,y2)(x3,y3) + x2= (x3*k+x1/k+y1-y3)/(k+(1/k)); + y2= k*(x2-x3)+y3; + } else if (x2==x3 && y2!=y3) { + y2=y1; + } else if (x2!=x3 && y2==y3) { + x2=x1; + } else { + std::cout<<"SVG Import warning: gradient points equal each other"<add_child("param"),"p1",x1,y1); - build_vector (root->add_child("param"),"p2",x2,y2); + build_vector (gradient->add_child("param"),"p1",x1,y1); + build_vector (gradient->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"); + xmlpp::Element *child_stops=gradient->add_child("param"); + child_stops->set_attribute("name","gradient"); + child_stops->set_attribute("guid",GUID::hasher(data->name).get_string()); + build_stop_color (child_stops->add_child("gradient"),data->stops); + build_param (gradient->add_child("param"),"loop","bool","false"); + build_param (gradient->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"); + xmlpp::Element* gradient; + + if (mtx || data->transform) { + xmlpp::Element* layer=root->add_child("layer"); + + layer->set_attribute("type","PasteCanvas"); + layer->set_attribute("active","true"); + layer->set_attribute("version","0.1"); + layer->set_attribute("desc",data->name); + build_param (layer->add_child("param"),"z_depth","real","0"); + build_param (layer->add_child("param"),"amount","real","1"); + build_param (layer->add_child("param"),"blend_method","integer","21"); //straight onto + build_vector (layer->add_child("param"),"origin",0,0); + xmlpp::Element *child=layer->add_child("param"); + child->set_attribute("name","canvas"); + xmlpp::Element* child_layer=child->add_child("canvas"); + + gradient=child_layer->add_child("layer"); + gradient->set_attribute("desc",data->name); + build_param (gradient->add_child("param"),"blend_method","integer","0"); //composite + Matrix *mtx2=NULL; + if (mtx && data->transform){ + composeMatrix(&mtx2,mtx,data->transform); + }else if (mtx){ + mtx2=mtx; + }else if (data->transform){ + mtx2=data->transform; + } + build_transform(child_layer,mtx2); + + }else { + gradient=root->add_child("layer"); + gradient->set_attribute("desc",data->name); + build_param (gradient->add_child("param"),"blend_method","integer","21"); //straight onto + } + + gradient->set_attribute("type","radial_gradient"); + gradient->set_attribute("active","true"); + build_param (gradient->add_child("param"),"z_depth","real","0"); + build_param (gradient->add_child("param"),"amount","real","1"); //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 + xmlpp::Element *child_stops=gradient->add_child("param"); + child_stops->set_attribute("name","gradient"); + child_stops->set_attribute("guid",GUID::hasher(data->name).get_string()); + build_stop_color (child_stops->add_child("gradient"),data->stops); + + //here the center point and radius 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_vector (gradient->add_child("param"),"center",cx,cy); + build_param (gradient->add_child("param"),"radius","real",r); - build_param (root->add_child("param"),"loop","bool","false"); - build_param (root->add_child("param"),"zigzag","bool","false"); + build_param (gradient->add_child("param"),"loop","bool","false"); + build_param (gradient->add_child("param"),"zigzag","bool","false"); } } @@ -1138,6 +1123,12 @@ Svg_parser::parser_linearGradient(const xmlpp::Node* node){ 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"); + Glib::ustring transform =nodeElement->get_attribute_value("gradientTransform"); + + //resolve transformations + Matrix* mtx=NULL; + if(!transform.empty()) + mtx=parser_transform (transform); std::list *stops; if(!link.empty()){ @@ -1168,7 +1159,7 @@ Svg_parser::parser_linearGradient(const xmlpp::Node* node){ } } if(stops) - lg.push_back(newLinearGradient(id,x1,y1,x2,y2,stops)); + lg.push_back(newLinearGradient(id,x1,y1,x2,y2,stops,mtx)); } } @@ -1178,15 +1169,27 @@ Svg_parser::parser_radialGradient(const xmlpp::Node* 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 fx =atof(nodeElement->get_attribute_value("fx").data()); + float fy =atof(nodeElement->get_attribute_value("fy").data()); float r =atof(nodeElement->get_attribute_value("r").data()); Glib::ustring link =nodeElement->get_attribute_value("href");//basic + Glib::ustring transform =nodeElement->get_attribute_value("gradientTransform"); + + if (cx!=fx || cy!=fy) + std::cout<<"SVG Parser: ignoring focus attributes for radial gradient"; + + //resolve transformations + Matrix* mtx=NULL; + if(!transform.empty()) + mtx=parser_transform (transform); + 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)); + rg.push_back(newRadialGradient(id,cx,cy,r,stops,mtx)); } } @@ -1231,7 +1234,7 @@ Svg_parser::adjustGamma(float r,float g,float b,float a){ } LinearGradient* -Svg_parser::newLinearGradient(String name,float x1,float y1, float x2,float y2,std::list *stops){ +Svg_parser::newLinearGradient(String name,float x1,float y1, float x2,float y2,std::list *stops, Matrix* transform){ LinearGradient* data; data=(LinearGradient*)malloc(sizeof(LinearGradient)); sprintf(data->name,"%s",name.data()); @@ -1240,11 +1243,12 @@ Svg_parser::newLinearGradient(String name,float x1,float y1, float x2,float y2,s data->x2=x2; data->y2=y2; data->stops=stops; + data->transform=transform; return data; } RadialGradient* -Svg_parser::newRadialGradient(String name,float cx,float cy,float r,std::list *stops){ +Svg_parser::newRadialGradient(String name,float cx,float cy,float r,std::list *stops, Matrix* transform){ RadialGradient* data; data=(RadialGradient*)malloc(sizeof(RadialGradient)); sprintf(data->name,"%s",name.data()); @@ -1252,10 +1256,22 @@ Svg_parser::newRadialGradient(String name,float cx,float cy,float r,std::listcy=cy; data->r=r; data->stops=stops; + data->transform=transform; + return data; +} + +BLine* +Svg_parser::newBLine(std::list *points,bool loop){ + BLine* data; + data=(BLine*)malloc(sizeof(BLine)); + //sprintf(data->name,"%s",name.data()); + data->points=new std::list (*points); + data->loop=loop; + data->bline_id=new String(new_guid()); + data->offset_id=new String(new_guid()); return data; } -//builds void Svg_parser::build_gamma(xmlpp::Element* root,float gamma){ root->set_attribute("type","colorcorrect"); @@ -1264,56 +1280,6 @@ Svg_parser::build_gamma(xmlpp::Element* root,float gamma){ 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 start,end; - start =(*aux).find_first_of("(")+1; - end =(*aux).find_first_of(","); - dx =atof((*aux).substr(start,end-start).data()); - start =(*aux).find_first_of(",")+1; - end =(*aux).size()-1; - dy =atof((*aux).substr(start,end-start).data()); - if(matrixIsNull(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(matrixIsNull(a)) - a=newMatrix(1,0,0,1,0,0); - }else if((*aux).compare(0,6,"rotate")==0){ - float angle,seno,coseno; - int start,end; - start =(*aux).find_first_of("(")+1; - end =(*aux).size()-1; - angle=getRadian (atof((*aux).substr(start,end-start).data())); - seno =sin(angle); - coseno =cos(angle); - if(matrixIsNull(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 start =(*aux).find_first_of('(')+1; - int end =(*aux).find_first_of(')'); - if(matrixIsNull(a)) - a=newMatrix((*aux).substr(start,end-start)); - else - multiplyMatrix(&a,newMatrix((*aux).substr(start,end-start))); - }else{ - a=newMatrix(1,0,0,1,0,0); - } - aux++; - } - return a; -} void Svg_parser::build_translate(xmlpp::Element* root,float dx,float dy){ @@ -1331,11 +1297,11 @@ Svg_parser::build_rotate(xmlpp::Element* root,float dx,float dy,float angle){ build_real (root->add_child("param"),"amount",angle); } void -Svg_parser::build_points(xmlpp::Element* root,std::list p){ +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(); + 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"); @@ -1345,7 +1311,7 @@ Svg_parser::build_points(xmlpp::Element* root,std::list p){ } } void -Svg_parser::build_vertice(xmlpp::Element* root , Vertice *p){ +Svg_parser::build_vertex(xmlpp::Element* root , Vertex *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); @@ -1357,18 +1323,18 @@ Svg_parser::build_vertice(xmlpp::Element* root , Vertice *p){ 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("radius"),"","real",p->radius1); build_param (child_rc->add_child("theta"),"","angle",p->angle1); //tangent 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("radius"),"","real",p->radius2); 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){ +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"); @@ -1377,9 +1343,9 @@ Svg_parser::build_bline(xmlpp::Element* root,std::list p,bool loop,Str else child->set_attribute("loop","false"); if(!blineguid.empty()) child->set_attribute("guid",blineguid); - std::list::iterator aux = p.begin(); + std::list::iterator aux = p.begin(); while(aux!=p.end()){ - if(*aux) build_vertice (child->add_child("entry"),*aux); + if(*aux) build_vertex (child->add_child("entry"),*aux); aux++; } } @@ -1470,11 +1436,11 @@ Svg_parser::build_vector (xmlpp::Element* root,String name,float x,float y,Strin } xmlpp::Element* -Svg_parser::nodeStartBasicLayer(xmlpp::Element* root){ +Svg_parser::nodeStartBasicLayer(xmlpp::Element* root, String name){ root->set_attribute("type","PasteCanvas"); root->set_attribute("active","true"); root->set_attribute("version","0.1"); - root->set_attribute("desc","Composite"); + root->set_attribute("desc",name); 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"); @@ -1484,7 +1450,7 @@ Svg_parser::nodeStartBasicLayer(xmlpp::Element* root){ return child->add_child("canvas"); } -//extra methods +/* === COORDINATES & TRANSFORMATIONS ======================================= */ void Svg_parser::coor2vect(float *x,float *y){ float sx, sy; @@ -1499,7 +1465,7 @@ Svg_parser::coor2vect(float *x,float *y){ } void -Svg_parser::setTg1(Vertice *p,float p1x,float p1y,float p2x,float p2y){ +Svg_parser::setTg1(Vertex *p,float p1x,float p1y,float p2x,float p2y){ float rd=0,ag=0; float d1x,d1y,d2x,d2y,dx,dy; d1x=p1x*60; @@ -1533,11 +1499,11 @@ Svg_parser::setTg1(Vertice *p,float p1x,float p1y,float p2x,float p2y){ ag=PI; } ag= (ag*180)/PI; - p->radio1=rd; + p->radius1=rd; p->angle1=ag; } void -Svg_parser::setTg2(Vertice* p,float p1x,float p1y,float p2x,float p2y){ +Svg_parser::setTg2(Vertex* p,float p1x,float p1y,float p2x,float p2y){ float rd=0,ag=0; float d1x,d1y,d2x,d2y,dx,dy; d1x=p1x*60; @@ -1577,33 +1543,164 @@ Svg_parser::setTg2(Vertice* p,float p1x,float p1y,float p2x,float p2y){ } ag= (ag*180)/PI; ag=ag-180; - p->radio2=rd; + p->radius2=rd; p->angle2=ag; } void -Svg_parser::setSplit(Vertice* p,bool val){ +Svg_parser::setSplit(Vertex* p,bool val){ if(p!=NULL){ p->split=val; } } int -Svg_parser::isFirst(Vertice* nodo,float a, float b){ +Svg_parser::isFirst(Vertex* nodo,float a, float b){ if(nodo->x==a && nodo->y==b) return 1; return 0; } -Vertice* -Svg_parser::newVertice(float x,float y){ - Vertice* vert; - vert=(Vertice*)malloc(sizeof(Vertice)); +Vertex* +Svg_parser::newVertex(float x,float y){ + Vertex* vert; + vert=(Vertex*)malloc(sizeof(Vertex)); vert->x=x; vert->y=y; - vert->radio1=vert->radio2=vert->angle1=vert->angle2=0; + vert->radius1=vert->radius2=vert->angle1=vert->angle2=0; return vert; } +//matrices +Matrix* +Svg_parser::parser_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 start,end; + start =(*aux).find_first_of("(")+1; + end =(*aux).find_first_of(","); + dx =atof((*aux).substr(start,end-start).data()); + start =(*aux).find_first_of(",")+1; + end =(*aux).size()-1; + dy =atof((*aux).substr(start,end-start).data()); + if(matrixIsNull(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(matrixIsNull(a)) + a=newMatrix(1,0,0,1,0,0); + }else if((*aux).compare(0,6,"rotate")==0){ + float angle,seno,coseno; + int start,end; + start =(*aux).find_first_of("(")+1; + end =(*aux).size()-1; + angle=getRadian (atof((*aux).substr(start,end-start).data())); + seno =sin(angle); + coseno =cos(angle); + if(matrixIsNull(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 start =(*aux).find_first_of('(')+1; + int end =(*aux).find_first_of(')'); + if(matrixIsNull(a)) + a=newMatrix((*aux).substr(start,end-start)); + else + multiplyMatrix(&a,newMatrix((*aux).substr(start,end-start))); + }else{ + a=newMatrix(1,0,0,1,0,0); + } + aux++; + } + return a; +} + +Matrix* +Svg_parser::newMatrix(Matrix *a){ + Matrix* data; + data=(Matrix*)malloc(sizeof(Matrix)); + data->a=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()){ + std::vector tokens=tokenize(mvector,","); + if(tokens.size()!=6) return newMatrix(1,0,0,1,0,0); + Matrix* data=(Matrix*)malloc(sizeof(Matrix)); + 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::matrixIsNull(Matrix *mtx){ + if(mtx == NULL) return true; + return false; +} + +/* === EXTRA METHODS ======================================================= */ + int Svg_parser::extractSubAttribute(const String attribute, String name,String* value){ int encounter=0; @@ -1655,6 +1752,97 @@ Svg_parser::loadAttribute(String name,const String path_style,const String maste return value; } +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(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::matrixIsNull(Matrix *mtx){ - if(mtx == NULL) return true; - return false; -} float Svg_parser::getRadian(float sexa){