From: Carlos Lopez Date: Sat, 1 Aug 2009 18:14:08 +0000 (+0200) Subject: Merge branch 'genete_master' X-Git-Url: https://git.pterodactylus.net/?a=commitdiff_plain;h=4be650adcbea49129f3869d8596255ace7f987b1;hp=dc1319ebadcd6f7746f4faa43dcb2005f05c490d;p=synfig.git Merge branch 'genete_master' --- diff --git a/.gitignore b/.gitignore index 36dc72b..e990be0 100644 --- a/.gitignore +++ b/.gitignore @@ -64,6 +64,7 @@ synfig-core/trunk/src/synfig/proto/nodebase.h synfig-core/trunk/src/tool/synfig synfig-core/trunk/synfig.pc.in +synfig-core/trunk/autorevision.h synfig-core/trunk/m4/codeset.m4 synfig-core/trunk/m4/gettext.m4 synfig-core/trunk/m4/glibc2.m4 diff --git a/synfig-core/trunk/Makefile.am b/synfig-core/trunk/Makefile.am index bb201ca..22ad14d 100644 --- a/synfig-core/trunk/Makefile.am +++ b/synfig-core/trunk/Makefile.am @@ -43,6 +43,7 @@ MAINTAINERCLEANFILES = \ SUBDIRS = \ libltdl \ + build_tools \ src \ examples \ po diff --git a/synfig-core/trunk/build_tools/Makefile.am b/synfig-core/trunk/build_tools/Makefile.am new file mode 100644 index 0000000..29b053f --- /dev/null +++ b/synfig-core/trunk/build_tools/Makefile.am @@ -0,0 +1,8 @@ +dist_noinst_SCRIPTS = autorevision.sh + +all-local: + sh $(srcdir)/autorevision.sh "$(top_srcdir)" "$(top_builddir)" + +clean-local: + -rm -f $(top_builddir)/autorevision.h + diff --git a/synfig-core/trunk/build_tools/autorevision.sh b/synfig-core/trunk/build_tools/autorevision.sh new file mode 100644 index 0000000..c8f4cf2 --- /dev/null +++ b/synfig-core/trunk/build_tools/autorevision.sh @@ -0,0 +1,107 @@ +#!/bin/sh + +# Copyright 2008 Paul Wise +# Copyright 2009 Konstantin Dmitriev +# +# 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. + +get_git_id(){ + export SCM=git + export REVISION_ID=`cd "$1"; git log --no-color -1 | head -n 1 | cut -f 2 -d ' '` + export BRANCH="`cd "$1"; git branch -a --no-color --contains HEAD | sed -e s/\*\ // | sed -e s/\(no\ branch\)// | tr '\n' ' ' | tr -s ' ' | sed s/^' '//`" + if ( echo $BRANCH | egrep origin/master > /dev/null ); then + #give a priority to master branch + BRANCH='master' + else + BRANCH=`echo $BRANCH | cut -d ' ' -f 1` + BRANCH=${BRANCH##*/} + fi + export REVISION=`git show --pretty=format:%ci HEAD | head -c 10 | tr -d '-'` + export COMPARE=`git rev-parse --git-dir` + # The extra * at the end is for Modified + #REVISION="$REVISION"`cd "$1"; [[ $(git status 2> /dev/null | tail -n1) != "nothing to commit (working directory clean)" ]] && echo "*"` +} + +get_git_svn_id(){ + export SCM=git-svn + export REVISION=`cd "$1"; git svn find-rev HEAD` + export COMPARE="$1/.git/" + if [ x = "x$REVISION" ] ; then + # The extra M at the end is for Modified + export REVISION=`cd "$1"; git svn find-rev \`git rev-list --max-count=1 --grep='git-svn-id: ' HEAD\``M + else + export REVISION="$REVISION"`cd "$1"; git diff --quiet HEAD || echo M` + fi +} + +get_svn_id(){ + export SCM=svn + export REVISION=`cd "$1"; svnversion || svn info | sed -n 's/^Revision: \(.*\)/\1/p'` +} + + +HEADER="$2/autorevision.h" +SCM=none + + +if [ ! -f "$HEADER" ] ; then + touch -t 197001010101 "$HEADER" +fi + + +# Extract the revision from SVN/git/etc +if git rev-parse --git-dir > /dev/null 2>&1 ; then + get_git_id "." +elif [ -d "$1/.git/svn" ] ; then + get_git_svn_id "$1" +elif [ -d "$1/../.git/svn" ] ; then + get_git_svn_id "$1/.." +elif [ -d "$1/../../.git/svn" ] ; then + get_git_svn_id "$1/../.." +elif [ -d "$1/.svn" ] ; then + COMPARE="$1/.svn" + get_svn_id "$1" +elif [ -d "$1/_svn" ] ; then + COMPARE="$1/_svn" + get_svn_id "$1" +fi + + +# Allow overriding both REVISION and DEVEL_VERSION +if [ -f "$2/autorevision.conf" ] ; then + SCM=manual + . "$2/autorevision.conf" +fi + + +# Abort if the header is newer +if [ "$COMPARE" -ot "$HEADER" ] ; then exit; fi + +# Set the development version string +if [ x = "x$DEVEL_VERSION" ] ; then + if [ x != "x$REVISION" ] ; then + if [ $SCM = svn ] ; then + DEVEL_VERSION="SVN r$REVISION" + elif [ $SCM = git-svn ] ; then + DEVEL_VERSION="SVN r$REVISION (via git)" + elif [ $SCM = git ] ; then + DEVEL_VERSION="Revision: ${REVISION}\\\\nBranch: ${BRANCH}\\\\nRevision ID: ${REVISION_ID}" + elif [ $SCM = manual ] ; then + DEVEL_VERSION="$REVISION (manually configured)" + fi + fi +fi + + +# Output the header +if [ x != "x$DEVEL_VERSION" ] ; then + printf "#define DEVEL_VERSION \"$DEVEL_VERSION\"\n" > "$HEADER" +fi diff --git a/synfig-core/trunk/configure.ac b/synfig-core/trunk/configure.ac index 66a6407..3f1b7b6 100644 --- a/synfig-core/trunk/configure.ac +++ b/synfig-core/trunk/configure.ac @@ -651,6 +651,7 @@ synfigincludedir=$includedir/synfig-$API_VERSION AC_SUBST(synfigincludedir) AC_CONFIG_FILES([synfig-config +build_tools/Makefile synfig.pc doxygen.cfg Makefile @@ -678,6 +679,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-core/trunk/src/tool/main.cpp b/synfig-core/trunk/src/tool/main.cpp index 38a7c64..fbf64b0 100644 --- a/synfig-core/trunk/src/tool/main.cpp +++ b/synfig-core/trunk/src/tool/main.cpp @@ -50,6 +50,7 @@ #include #include #include +#include #endif using namespace std; @@ -396,6 +397,9 @@ int process_global_flags(arg_list_t &arg_list) if(*iter == "--info") { cout<>8)<<'.'<<((__TCPLUSPLUS__&255)>>4)<<'.'<<(__TCPLUSPLUS__&15); #endif - cout< /dev/null ); then + #give a priority to master branch + BRANCH='master' + else + BRANCH=`echo $BRANCH | cut -d ' ' -f 1` + BRANCH=${BRANCH##*/} + fi + export REVISION=`git show --pretty=format:%ci HEAD | head -c 10 | tr -d '-'` + export COMPARE=`git rev-parse --git-dir` + # The extra * at the end is for Modified + #REVISION="$REVISION"`cd "$1"; [[ $(git status 2> /dev/null | tail -n1) != "nothing to commit (working directory clean)" ]] && echo "*"` +} get_git_svn_id(){ export SCM=git-svn @@ -41,7 +58,9 @@ fi # Extract the revision from SVN/git/etc -if [ -d "$1/.git/svn" ] ; then +if git rev-parse --git-dir > /dev/null 2>&1 ; then + get_git_id "." +elif [ -d "$1/.git/svn" ] ; then get_git_svn_id "$1" elif [ -d "$1/../.git/svn" ] ; then get_git_svn_id "$1/.." @@ -66,7 +85,6 @@ fi # Abort if the header is newer if [ "$COMPARE" -ot "$HEADER" ] ; then exit; fi - # Set the development version string if [ x = "x$DEVEL_VERSION" ] ; then if [ x != "x$REVISION" ] ; then @@ -74,6 +92,8 @@ if [ x = "x$DEVEL_VERSION" ] ; then DEVEL_VERSION="SVN r$REVISION" elif [ $SCM = git-svn ] ; then DEVEL_VERSION="SVN r$REVISION (via git)" + elif [ $SCM = git ] ; then + DEVEL_VERSION="Revision: ${REVISION}\\\\nBranch: ${BRANCH}\\\\nRevision ID: ${REVISION_ID}" elif [ $SCM = manual ] ; then DEVEL_VERSION="$REVISION (manually configured)" fi @@ -83,6 +103,6 @@ fi # Output the header if [ x != "x$DEVEL_VERSION" ] ; then - echo "#define SHOW_EXTRA_INFO" > "$HEADER" - echo "#define DEVEL_VERSION \"$DEVEL_VERSION\"" >> "$HEADER" + printf "#define SHOW_EXTRA_INFO\n" > "$HEADER" + printf "#define DEVEL_VERSION \"$DEVEL_VERSION\"\n" >> "$HEADER" fi diff --git a/synfig-studio/trunk/src/gtkmm/Makefile.am b/synfig-studio/trunk/src/gtkmm/Makefile.am index 1be3e71..c5cc73d 100644 --- a/synfig-studio/trunk/src/gtkmm/Makefile.am +++ b/synfig-studio/trunk/src/gtkmm/Makefile.am @@ -138,7 +138,8 @@ WIDGET_HH = \ widget_value.h \ widget_vector.h \ widget_waypoint.h \ - widget_waypointmodel.h + widget_waypointmodel.h \ + widget_keyframe_list.h WIDGET_CC = \ widget_canvaschooser.cpp \ @@ -157,7 +158,8 @@ WIDGET_CC = \ widget_value.cpp \ widget_vector.cpp \ widget_waypoint.cpp \ - widget_waypointmodel.cpp + widget_waypointmodel.cpp \ + widget_keyframe_list.cpp STATE_HH = \ diff --git a/synfig-studio/trunk/src/gtkmm/canvasview.cpp b/synfig-studio/trunk/src/gtkmm/canvasview.cpp index a76b1a0..53a6ccc 100644 --- a/synfig-studio/trunk/src/gtkmm/canvasview.cpp +++ b/synfig-studio/trunk/src/gtkmm/canvasview.cpp @@ -690,6 +690,7 @@ CanvasView::CanvasView(etl::loose_handle instance,etl::handleset_time_adjustment(&time_adjustment()); timeslider->set_bounds_adjustment(&time_window_adjustment()); //layout_table->attach(*timeslider, 0, 1, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL); + //Setup the keyframe list widget + widget_kf_list->set_time_adjustment(&time_adjustment()); + widget_kf_list->set_canvas_interface(canvas_interface()); + widget_kf_list->show(); tooltips.set_tip(*time_window_scroll,_("Moves the time window")); tooltips.set_tip(*timeslider,_("Changes the current time")); @@ -1033,16 +1038,26 @@ CanvasView::create_time_bar() keyframedial->show(); keyframebutton=keyframedial->get_lock_button(); - timebar = manage(new class Gtk::Table(5, 4, false)); + timebar = Gtk::manage(new class Gtk::Table(5, 4, false)); + + //Adjust both widgets to be the same as the + int header_height = 0; + if(getenv("SYNFIG_TIMETRACK_HEADER_HEIGHT")) + header_height = atoi(getenv("SYNFIG_TIMETRACK_HEADER_HEIGHT")); + if (header_height < 3) + header_height = 24; + timeslider->set_size_request(-1,header_height-header_height/3+1); + widget_kf_list->set_size_request(-1,header_height/3+1); //Attach widgets to the timebar - timebar->attach(*manage(disp_audio), 1, 5, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK); - timebar->attach(*framedial, 0, 1, 2, 3,Gtk::SHRINK, Gtk::SHRINK); - timebar->attach(*current_time_widget, 0, 1, 1, 2, Gtk::SHRINK|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0); - timebar->attach(*timeslider, 1, 3, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK); + //timebar->attach(*manage(disp_audio), 1, 5, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK); + timebar->attach(*current_time_widget, 0, 1, 0, 2, Gtk::SHRINK|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0); + timebar->attach(*framedial, 0, 1, 2, 3, Gtk::SHRINK, Gtk::SHRINK); + timebar->attach(*timeslider, 1, 3, 1, 2, Gtk::FILL|Gtk::SHRINK, Gtk::FILL|Gtk::SHRINK); + timebar->attach(*widget_kf_list, 1, 3, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK); timebar->attach(*time_window_scroll, 1, 3, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK); - timebar->attach(*keyframedial, 3, 4, 1, 2, Gtk::SHRINK, Gtk::SHRINK); - timebar->attach(*animatebutton, 4, 5, 1, 2, Gtk::SHRINK, Gtk::SHRINK); + timebar->attach(*keyframedial, 3, 4, 0, 2, Gtk::SHRINK, Gtk::SHRINK); + timebar->attach(*animatebutton, 4, 5, 0, 2, Gtk::SHRINK, Gtk::SHRINK); //timebar->attach(*keyframebutton, 1, 2, 3, 4, Gtk::SHRINK, Gtk::SHRINK); timebar->show(); diff --git a/synfig-studio/trunk/src/gtkmm/canvasview.h b/synfig-studio/trunk/src/gtkmm/canvasview.h index a33fb26..cddcbe2 100644 --- a/synfig-studio/trunk/src/gtkmm/canvasview.h +++ b/synfig-studio/trunk/src/gtkmm/canvasview.h @@ -70,6 +70,7 @@ #include "framedial.h" #include "toggleducksdial.h" #include "resolutiondial.h" +#include "widget_keyframe_list.h" #include "duckmatic.h" #include @@ -294,6 +295,9 @@ private: //! Time slider class. Same than the Time track panel std::auto_ptr timeslider; + //!Keyframe list slider + std::auto_ptr widget_kf_list; + std::list duck_changed_connections; /* DEBUGPOINT_CLASS(8); diff --git a/synfig-studio/trunk/src/gtkmm/dock_timetrack.cpp b/synfig-studio/trunk/src/gtkmm/dock_timetrack.cpp index a0f7fca..7a6139a 100644 --- a/synfig-studio/trunk/src/gtkmm/dock_timetrack.cpp +++ b/synfig-studio/trunk/src/gtkmm/dock_timetrack.cpp @@ -43,6 +43,7 @@ #include "layerparamtreestore.h" #include "workarea.h" #include "widget_timeslider.h" +#include "widget_keyframe_list.h" #include "layerparamtreestore.h" #include "general.h" #include @@ -405,14 +406,17 @@ Dock_Timetrack::Dock_Timetrack(): { table_=0; widget_timeslider_= new Widget_Timeslider(); + widget_kf_list_= new Widget_Keyframe_List(); int header_height = 0; if(getenv("SYNFIG_TIMETRACK_HEADER_HEIGHT")) header_height = atoi(getenv("SYNFIG_TIMETRACK_HEADER_HEIGHT")); if (header_height < 3) - header_height = 22; + header_height = 24; + + widget_timeslider_->set_size_request(-1,header_height-header_height/3+1); + widget_kf_list_->set_size_request(-1,header_height/3+1); - widget_timeslider_->set_size_request(-1,header_height); hscrollbar_=new Gtk::HScrollbar(); vscrollbar_=new Gtk::VScrollbar(); } @@ -423,6 +427,7 @@ Dock_Timetrack::~Dock_Timetrack() delete hscrollbar_; delete vscrollbar_; delete widget_timeslider_; + delete widget_kf_list_; } void @@ -493,17 +498,22 @@ Dock_Timetrack::changed_canvas_view_vfunc(etl::loose_handle canvas_v assert(tree_view); + widget_timeslider_->set_time_adjustment(&canvas_view->time_adjustment()); widget_timeslider_->set_bounds_adjustment(&canvas_view->time_window_adjustment()); widget_timeslider_->set_global_fps(canvas_view->get_canvas()->rend_desc().get_frame_rate()); + widget_kf_list_->set_time_adjustment(&canvas_view->time_adjustment()); + widget_kf_list_->set_canvas_interface(canvas_view->canvas_interface()); + vscrollbar_->set_adjustment(*tree_view->get_vadjustment()); hscrollbar_->set_adjustment(canvas_view->time_window_adjustment()); - table_=new Gtk::Table(2,2); - table_->attach(*widget_timeslider_, 0, 1, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK); - table_->attach(*tree_view, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); - table_->attach(*hscrollbar_, 0, 1, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK); - table_->attach(*vscrollbar_, 1, 2, 0, 2, Gtk::FILL|Gtk::SHRINK, Gtk::FILL|Gtk::EXPAND); + table_=new Gtk::Table(2,3); + table_->attach(*widget_timeslider_, 0, 1, 1, 2, Gtk::FILL|Gtk::SHRINK, Gtk::FILL|Gtk::SHRINK); + table_->attach(*widget_kf_list_, 0, 1, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK); + table_->attach(*tree_view, 0, 1, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND); + table_->attach(*hscrollbar_, 0, 1, 3, 4, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK); + table_->attach(*vscrollbar_, 1, 2, 0, 3, Gtk::FILL|Gtk::SHRINK, Gtk::FILL|Gtk::EXPAND); add(*table_); //add(*last_widget_curves_); diff --git a/synfig-studio/trunk/src/gtkmm/dock_timetrack.h b/synfig-studio/trunk/src/gtkmm/dock_timetrack.h index d103d9a..9da19fd 100644 --- a/synfig-studio/trunk/src/gtkmm/dock_timetrack.h +++ b/synfig-studio/trunk/src/gtkmm/dock_timetrack.h @@ -6,6 +6,7 @@ ** ** \legal ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2009 Carlos López ** ** This package is free software; you can redistribute it and/or ** modify it under the terms of the GNU General Public License as @@ -40,12 +41,14 @@ namespace studio { class Widget_Timeslider; +class Widget_Keyframe_List; class Dock_Timetrack : public Dock_CanvasSpecific { Gtk::HScrollbar* hscrollbar_; Gtk::VScrollbar* vscrollbar_; Widget_Timeslider* widget_timeslider_; + Widget_Keyframe_List* widget_kf_list_; Gtk::Table* table_; protected: @@ -59,7 +62,7 @@ public: Dock_Timetrack(); ~Dock_Timetrack(); -}; // END of Dock_Keyframes +}; // END of Dock_Timetrack }; // END of namespace studio diff --git a/synfig-studio/trunk/src/gtkmm/widget_keyframe_list.cpp b/synfig-studio/trunk/src/gtkmm/widget_keyframe_list.cpp new file mode 100644 index 0000000..ace2b98 --- /dev/null +++ b/synfig-studio/trunk/src/gtkmm/widget_keyframe_list.cpp @@ -0,0 +1,425 @@ +/* === S Y N F I G ========================================================= */ +/*! \file widget_keyframe_list.cpp +** \brief A custom widget to manage keyframes in the timeline. +** +** $Id$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2007 Chris Moore +** Copyright (c) 2009 Carlos López +** +** 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 "widget_keyframe_list.h" +#include "app.h" +#include +#include +#include + +#include "general.h" + +#endif + +/* === U S I N G =========================================================== */ + +using namespace std; +using namespace etl; +using namespace synfig; +using namespace studio; + + +/* === M A C R O S ========================================================= */ +#define WIDGET_KEYFRAME_LIST_DEFAULT_FPS 24.0 +/* === G L O B A L S ======================================================= */ + +/* === P R O C E D U R E S ================================================= */ + +/* === M E T H O D S ======================================================= */ + +Widget_Keyframe_List::Widget_Keyframe_List(): + adj_default(0,0,2,1/WIDGET_KEYFRAME_LIST_DEFAULT_FPS,10/WIDGET_KEYFRAME_LIST_DEFAULT_FPS), + kf_list_(&default_kf_list_), + time_ratio("4f", WIDGET_KEYFRAME_LIST_DEFAULT_FPS) +{ + adj_timescale=0; + editable_=true; + fps=WIDGET_KEYFRAME_LIST_DEFAULT_FPS; + set_size_request(-1,64); + //!This signal is called when the widget need to be redrawn + signal_expose_event().connect(sigc::mem_fun(*this, &studio::Widget_Keyframe_List::redraw)); + //! The widget respond to mouse button press and release and to + //! left button motion + add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK); + add_events(Gdk::BUTTON1_MOTION_MASK /*| Gdk::BUTTON3_MOTION_MASK*/); + add_events(Gdk::POINTER_MOTION_MASK); + set_time_adjustment(&adj_default); + queue_draw(); +} + +Widget_Keyframe_List::~Widget_Keyframe_List() +{ +} + +bool +Widget_Keyframe_List::redraw(GdkEventExpose */*bleh*/) +{ + + const int h(get_height()); + const int w(get_width()); + + //!Boundaries of the drawing area in time units. + synfig::Time top(adj_timescale->get_upper()); + synfig::Time bottom(adj_timescale->get_lower()); + + //! The graphic context + Glib::RefPtr gc(Gdk::GC::create(get_window())); + //! A rectangle that defines the drawing area. + Gdk::Rectangle area(0,0,w,h); + + //! draw a background + gc->set_rgb_fg_color(Gdk::Color("#9d9d9d")); + get_window()->draw_rectangle(gc, true, 0, 0, w, h); + + if(!editable_) + { + return true; //needs fixing! + } + //!Returns if there are not keyframes to draw. + if (kf_list_->empty()) return false; + + //!Loop all the keyframes + synfig::KeyframeList::iterator iter,selected_iter; + bool show_selected(false); + for(iter=kf_list_->begin();iter!=kf_list_->end();iter++) + { + //!do not draw keyframes out of the widget boundaries + if (iter->get_time()>top || iter->get_time()get_time()-bottom) * (w/(top-bottom)) ) ); + get_style()->paint_arrow(get_window(), Gtk::STATE_NORMAL, + Gtk::SHADOW_OUT, area, *this, " ", Gtk::ARROW_DOWN, 1, + x-h/2+1, 0, h, h ); + } + else + { + selected_iter=iter; + show_selected=true; + } + } + + // we do this so that we can be sure that + // the selected keyframe is shown on top + if(show_selected) + { + // If not dragging just show the selected keyframe + if (!dragging_) + { + int x((int)((float)(selected_iter->get_time()-bottom) * (w/(top-bottom)) ) ); + get_style()->paint_arrow(get_window(), Gtk::STATE_SELECTED, + Gtk::SHADOW_OUT, area, *this, " ", Gtk::ARROW_DOWN, 1, + x-h/2+1, 0, h, h ); + } + // If dragging then show the selected as insensitive and the + // dragged as selected + else + { + int x((int)((float)(selected_iter->get_time()-bottom) * (w/(top-bottom)) ) ); + get_style()->paint_arrow(get_window(), Gtk::STATE_INSENSITIVE, + Gtk::SHADOW_OUT, area, *this, " ", Gtk::ARROW_DOWN, 1, + x-h/2, 0, h, h ); + x=(int)((float)(dragging_kf_time-bottom) * (w/(top-bottom)) ) ; + get_style()->paint_arrow(get_window(), Gtk::STATE_SELECTED, + Gtk::SHADOW_OUT, area, *this, " ", Gtk::ARROW_DOWN, 1, + x-h/2+1, 0, h, h ); + } + } + return true; +} + + +void +Widget_Keyframe_List::set_kf_list(synfig::KeyframeList* x) +{ + kf_list_=x; + set_selected_keyframe(selected_none); + selected_=false; + dragging_=false; +} + +void +Widget_Keyframe_List::set_selected_keyframe(const synfig::Keyframe &x) +{ + selected_kf=x; + selected_=true; + dragging_kf_time=selected_kf.get_time(); + //signal_keyframe_selected_(selected_kf); + dragging_=false; + queue_draw(); +} + +bool +Widget_Keyframe_List::perform_move_kf(bool delta=false) +{ + if(!selected_) + return false; + if(dragging_kf_time == selected_kf.get_time()) + return false; // change this checking if not sticked to integer frames + Time selected_kf_time(selected_kf.get_time()); + Time prev, next; + kf_list_->find_prev_next(selected_kf_time, prev, next); + // Not possible to set delta to the first keyframe + // perform normal movement + // As suggested by Zelgadis it is better to not perform anything. + if (prev==Time::begin() && delta==true) + { + synfig::info(_("Not possible to ALT-drag the first keyframe")); + return false; + } + if(!delta) + { + synfigapp::Action::Handle action(synfigapp::Action::create("KeyframeSet")); + if(!action) + return false; + selected_kf.set_time(dragging_kf_time); + action->set_param("canvas",canvas_interface_->get_canvas()); + action->set_param("canvas_interface",canvas_interface_); + action->set_param("keyframe",selected_kf); + try + { + canvas_interface_->get_instance()->perform_action(action); + } + catch(...) + { + return false; + } + } + else + { + Keyframe prev_kf(*kf_list_->find_prev(selected_kf_time)); + Time prev_kf_time(prev_kf.get_time()); + if (prev_kf_time >= dragging_kf_time) //Not allowed + { + synfig::warning(_("Delta set not allowed")); + synfig::info(_("Widget_Keyframe_List::perform_move_kf(%i)::prev_kf_time=%s"), delta, prev_kf_time.get_string().c_str()); + synfig::info(_("Widget_Keyframe_List::perform_move_kf(%i)::dragging_kf_time=%s"), delta, dragging_kf_time.get_string().c_str()); + return false; + } + else + { + Time old_delta_time(selected_kf_time-prev_kf_time); + Time new_delta_time(dragging_kf_time-prev_kf_time); + Time change_delta(new_delta_time-old_delta_time); + synfigapp::Action::Handle action(synfigapp::Action::create("KeyframeSetDelta")); + if(!action) + return false; + action->set_param("canvas",canvas_interface_->get_canvas()); + action->set_param("canvas_interface",canvas_interface_); + action->set_param("keyframe",prev_kf); + action->set_param("delta",change_delta); + canvas_interface_->get_instance()->perform_action(action); + } + } + queue_draw(); + return true; +} + +bool +Widget_Keyframe_List::on_event(GdkEvent *event) +{ + const int x(static_cast(event->button.x)); + //const int y(static_cast(event->button.y)); + //!Boundaries of the drawing area in time units. + synfig::Time top(adj_timescale->get_upper()); + synfig::Time bottom(adj_timescale->get_lower()); + //!pos is the [0,1] relative horizontal place on the widget + float pos((float)x/(get_width())); + if(pos<0.0f)pos=0.0f; + if(pos>1.0f)pos=1.0f; + //! The time where the event x is + synfig::Time t((float)(bottom+pos*(top-bottom))); + //Do not respond mouse events if the list is empty + if(!kf_list_->size()) + return true; + + //! here the guts of the event + switch(event->type) + { + case GDK_MOTION_NOTIFY: + if(editable_) + { + // here is captured mouse motion + // AND left or right mouse button pressed + if (event->motion.state & (GDK_BUTTON1_MASK /*| GDK_BUTTON3_MASK*/)) + { + // stick to integer frames. It can be optional in the future + if(fps) t = floor(t*fps + 0.5)/fps; + dragging_kf_time=t; + dragging_=true; + queue_draw(); + return true; + } + // here is captured mouse motion + // AND NOT left or right mouse button pressed + else + { + Glib::ustring ttip=""; + synfig::Time p_t,n_t; + kf_list_->find_prev_next(t, p_t, n_t); + if( (p_t==Time::begin() && n_t==Time::end()) + || + ((t-p_t)>time_ratio && (n_t-t)>time_ratio) + ) + { + ttip = _("Click and drag keyframes"); + } + else if ((t-p_t)<(n_t-t)) + { + synfig::Keyframe kf(*kf_list_->find_prev(t)); + synfig::String kf_name(kf.get_description().c_str()); + ttip = kf_name.c_str(); + } + else + { + synfig::Keyframe kf(*kf_list_->find_next(t)); + synfig::String kf_name(kf.get_description().c_str()); + ttip = kf_name.c_str(); + } + tooltips.set_tip(*this, ttip); + dragging_=false; + queue_draw(); + return true; + } + } + break; + case GDK_BUTTON_PRESS: + changed_=false; + dragging_=false; + if(event->button.button==1 /*|| event->button.button==3*/) + { + if(editable_) + { + synfig::Time prev_t,next_t; + kf_list_->find_prev_next(t, prev_t, next_t); + if( (prev_t==Time::begin() && next_t==Time::end()) + || + ((t-prev_t)>time_ratio && (next_t-t)>time_ratio) + ) + { + set_selected_keyframe(selected_none); + selected_=false; + queue_draw(); + } + else if ((t-prev_t)<(next_t-t)) + { + set_selected_keyframe(*(kf_list_->find_prev(t))); + queue_draw(); + selected_=true; + } + else + { + set_selected_keyframe(*(kf_list_->find_next(t))); + queue_draw(); + selected_=true; + } + return true; + } + else + { + return false; + } + } + + break; + case GDK_BUTTON_RELEASE: + if(editable_ && (event->button.button==1 /*|| event->button.button==3*/)) + { + // stick to integer frames. + if(fps) t = floor(t*fps + 0.5)/fps; + bool stat=false; + if(dragging_) + { + //if (event->button.button==3) + if(event->button.state & GDK_MOD1_MASK) + { + stat=perform_move_kf(true); + } + else + { + stat=perform_move_kf(false); + } + } + dragging_=false; + return stat; + } + break; + default: + break; + } + return false; +} + + +void Widget_Keyframe_List::set_time_adjustment(Gtk::Adjustment *x) +{ + //disconnect old connections + time_value_change.disconnect(); + time_other_change.disconnect(); + + //connect update function to new adjustment + adj_timescale = x; + + if(x) + { + time_value_change = x->signal_value_changed().connect(sigc::mem_fun(*this,&Widget_Keyframe_List::queue_draw)); + time_other_change = x->signal_changed().connect(sigc::mem_fun(*this,&Widget_Keyframe_List::queue_draw)); + } +} + +void +Widget_Keyframe_List::set_fps(float d) +{ + if(fps != d) + { + fps = d; + //update everything since we need to redraw already + queue_draw(); + } +} + +void +Widget_Keyframe_List::set_canvas_interface(etl::loose_handle h) +{ + canvas_interface_=h; + // Store the values used fomr the canvas interface. + if (canvas_interface_) + { + set_fps(canvas_interface_->get_canvas()->rend_desc().get_frame_rate()); + set_kf_list(&canvas_interface_->get_canvas()->keyframe_list()); + } +} + + diff --git a/synfig-studio/trunk/src/gtkmm/widget_keyframe_list.h b/synfig-studio/trunk/src/gtkmm/widget_keyframe_list.h new file mode 100644 index 0000000..1e41770 --- /dev/null +++ b/synfig-studio/trunk/src/gtkmm/widget_keyframe_list.h @@ -0,0 +1,150 @@ +/* === S Y N F I G ========================================================= */ +/*! \file widget_keyframe_list.h +** \brief A custom widget to manage keyframes in the timeline. +** +** $Id$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2009 Carlos López +** +** 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_STUDIO_WIDGET_KEYFRAME_LIST_H +#define __SYNFIG_STUDIO_WIDGET_KEYFRAME_LIST_H + +/* === H E A D E R S ======================================================= */ + +#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 studio { + +class Widget_Keyframe_List : public Gtk::DrawingArea +{ + //! Tooltips class. It is deprecated since gtkmm 2.12 + //! replace with Tooltip class or use the own tooltip widget's members + Gtk::Tooltips tooltips; + + //! The canvas interface being watched + etl::loose_handle canvas_interface_; + + //! Time adjustment window + Gtk::Adjustment adj_default; + Gtk::Adjustment *adj_timescale; + + //!The list of keyframes to be drawn on the widget and moved with mouse + synfig::KeyframeList default_kf_list_; + mutable synfig::KeyframeList* kf_list_; + + //! The frames per second of the canvas + float fps; + + //! Time radius to click a keyframe + synfig::Time time_ratio; + + //!True if it is editable. Keyframes can be moved. + bool editable_; + + //!True if a keyframe is being dragged. + bool dragging_; + + //!True if a keyframe has been moved + bool changed_; + + //!Holds the selected keyframe of the keyframe list + synfig::Keyframe selected_kf; + synfig::Keyframe selected_none; + bool selected_; + + //!The time of the selected keyframe + synfig::Time selected_kf_time; + + //!The time of the selected keyframe during draging + synfig::Time dragging_kf_time; + + //!Connectors for handling the signals of the time adjustment + sigc::connection time_value_change; + sigc::connection time_other_change; + +public: + + //!Default constructor + Widget_Keyframe_List(); + + //!Destructror + ~Widget_Keyframe_List(); + + //!Loads a new keyframe list on the widget. + void set_kf_list(synfig::KeyframeList* x); + + //!Member for private data. + synfig::KeyframeList* get_kf_list()const { return kf_list_; } + + //!Member for private data + void set_editable(bool x=true) { editable_=x; } + + //!Member for private data + bool get_editable()const { return editable_; } + + + //!Store the selected keyframe value + void set_selected_keyframe(const synfig::Keyframe &x); + + //!Returns the selected keyframe + const synfig::Keyframe& get_selected_keyframe() { return selected_kf; } + + //! Set the time adjustment and proper connects its change signals + void set_time_adjustment(Gtk::Adjustment *x); + + //! Set the fps + void set_fps(float x); + + //! Set the canvas interface + void set_canvas_interface(etl::loose_handle h); + + //! Performs the keyframe movement. Returns true if it was sucessful + //! @return true: if success otherwise false + //! |delta=false: permorm normal move. true: perform delta movement + bool perform_move_kf(bool delta); + + + +/* ======================= EVENTS HANDLERS ===========================*/ + //!Redraw event. Should draw all the keyframes + the selected + the dragged + bool redraw(GdkEventExpose*bleh=NULL); + + //!Mouse event handler. + bool on_event(GdkEvent *event); +}; // END of class Keyframe_List + +}; // END of namespace studio + + +/* === E N D =============================================================== */ + +#endif diff --git a/synfig-studio/trunk/src/gtkmm/widget_timeslider.cpp b/synfig-studio/trunk/src/gtkmm/widget_timeslider.cpp index ba57435..ed5d63c 100644 --- a/synfig-studio/trunk/src/gtkmm/widget_timeslider.cpp +++ b/synfig-studio/trunk/src/gtkmm/widget_timeslider.cpp @@ -576,7 +576,17 @@ bool Widget_Timeslider::redraw(bool /*doublebuffer*/) //gc->set_rgb_fg_color(Gdk::Color("#000000")); layout->set_text(timecode); - window->draw_layout(gc,xpx+2,heightsmall,layout); + Pango::AttrList attr_list; + // Aproximately a font size of 8 pixels. + // Pango::SCALE = 1024 + // create_attr_size waits a number in 1000th of pixels. + // Should be user customizable in the future. Now it is fixed to 10 + Pango::AttrInt pango_size(Pango::Attribute::create_attr_size(Pango::SCALE*10)); + pango_size.set_start_index(0); + pango_size.set_end_index(64); + attr_list.change(pango_size); + layout->set_attributes(attr_list); + window->draw_layout(gc,xpx+2,0,layout); }else { window->draw_line(gc,xpx,0,xpx,heightsmall); diff --git a/synfig-studio/trunk/src/synfigapp/actions/keyframesetdelta.cpp b/synfig-studio/trunk/src/synfigapp/actions/keyframesetdelta.cpp index 97898c3..6cd262a 100644 --- a/synfig-studio/trunk/src/synfigapp/actions/keyframesetdelta.cpp +++ b/synfig-studio/trunk/src/synfigapp/actions/keyframesetdelta.cpp @@ -178,7 +178,10 @@ Action::KeyframeSetDelta::perform() // Time location(keyframe.get_time()); Time location(get_canvas()->keyframe_list().find(keyframe)->get_time()); - Time delta(delta); +// This line sets delta to 0s regardless to any previous value of delta. +// I think it was here for symmetry to the undo() operation. +// It was causing that the Set delta operation was faulty. Now works! +// Time delta(delta); get_canvas()->keyframe_list().insert_time(location,delta); 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 { diff --git a/synfig-studio/trunk/synfigstudio-cph-monitor b/synfig-studio/trunk/synfigstudio-cph-monitor new file mode 100755 index 0000000..6dcc2bc --- /dev/null +++ b/synfig-studio/trunk/synfigstudio-cph-monitor @@ -0,0 +1,163 @@ +#!/bin/bash + +# Synfig Crash Monitor script +# Copyright (c) 2009 Konstantin Dmitriev +# 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. + +set -e +trap writelog INT + +init() +{ +echo "SynfigStudio Crash Monitor is a tool to collect statistics about synfig crashes." +echo "All information is collected locally in ~/.synfig/cph directory." +echo +STARTED=0 +RUNTIME=0 +VERSION='' +RELEASE='' +BRANCH='' +REVISION_ID='' +CRASH=0 +[ ! -d ~/.synfig/cph ] && mkdir -p ~/.synfig/cph || true + +# Detect if crash monitor is already started +PDIR=${0%`basename $0`} +LCK_FILE=~/.synfig/cph/`basename $0`.lck +if [ -f "${LCK_FILE}" ]; then + MYPID=`head -n 1 "${LCK_FILE}"` + if ! ( ps -p ${MYPID} | grep ${MYPID} >/dev/null ); then + # The process is not running + # Echo current PID into lock file + echo $$ > "${LCK_FILE}" + else + echo "`basename $0` is already running [${MYPID}]. Aborting." + sleep 5 + exit 0 + fi +else + # The process is not running + # Echo current PID into lock file + echo $$ > "${LCK_FILE}" +fi +echo `date +%H:%M` "Synfig Crash Monitor started." +} + +writelog() +{ + if [[ $STARTED != 0 ]]; then + if [[ $CRASH == 0 ]]; then + echo `date +%H:%M` "Synfig exited normally. Session time: $RUNTIME." + else + echo `date +%H:%M` "Crash detected. Version $VERSION.$RELEASE.$BRANCH, session time: $RUNTIME." + fi + if [ -e ~/.synfig/cph/log ]; then + #check if dump needed + CURRENTDATE=`date +%Y-%m-%d` + LOGMODDATE=`stat -c %y ~/.synfig/cph/log` + LOGMODDATE=${LOGMODDATE%% *} + if [[ $LOGMODDATE != $CURRENTDATE ]]; then + dumpstats + fi + fi + #write log + echo $VERSION/$BRANCH/$RELEASE/$REVISION_ID $RUNTIME $CRASH >> ~/.synfig/cph/log + CRASH=0 + RUNTIME=0 + else + echo + fi +} + +dumpstats() +{ + echo `date +%H:%M` 'Dumping stats for previous session...' + LOGMODDATE=`stat -c %y ~/.synfig/cph/log` + LOGMODDATE=${LOGMODDATE%% *} + #get versions + VERSIONS='' + while read LINE; do + FOUND=0 + for VER in $VERSIONS; do + if [[ $VER == ${LINE%% *} ]]; then + FOUND=1 + break + fi + done + [[ $FOUND == 0 ]] && VERSIONS="$VERSIONS ${LINE%% *}" + done < ~/.synfig/cph/log + echo " Logged versions: ${VERSIONS}" + for VER in $VERSIONS; do + #generating random record ID + ID=$( echo `date` `ps` | md5sum | md5sum ) + ID="${ID:2:16}" + #summarizing time and counting crashes + CRASHCOUNT=0 + TIMECOUNT=0 + while read LINE; do + if [[ ${LINE%% *} == $VER ]]; then + TIMECOUNT=`expr $TIMECOUNT + $(echo $LINE| cut -f 2 -d ' ')` || true + CRASHCOUNT=`expr $CRASHCOUNT + $(echo $LINE| cut -f 3 -d ' ')` || true + fi + done < ~/.synfig/cph/log + echo " $LOGMODDATE $ID $VER $TIMECOUNT $CRASHCOUNT" + echo "$LOGMODDATE $ID $VER $TIMECOUNT $CRASHCOUNT" >> ~/.synfig/cph/stats + done + rm -f ~/.synfig/cph/log + echo ' Done.' +} + +mainloop() +{ + while true; do + if ( ps --no-headers -f -Csynfigstudio |egrep "^`whoami`" > /dev/null ) ; then + #synfigstudio process exist + if [[ $STARTED == 0 ]]; then + STARTED=1 + RUNTIME=0 + #get version + P=$(ps --no-headers -f -Csynfigstudio |egrep "^`whoami`" | tr -s ' '| cut -d ' ' -f 8) + echo + if [ ! -e $P ]; then + P=`which $P` + fi + P=`dirname $P` + VERSION=`$P/synfig --info|head -n 1|cut -d '-' -f 2` + RELEASE=`$P/synfig --info|egrep "Revision:"|cut -d ' ' -f 2` + BRANCH=`$P/synfig --info|egrep "Branch:"|cut -d ' ' -f 2-3` + REVISION_ID=`$P/synfig --info|egrep "Revision ID:"|cut -d ' ' -f 3` + if [[ $BRANCH == '(no branch)' ]]; then + BRANCH=$REVISION_ID + fi + echo `date +%H:%M` "Synfig $VERSION.$RELEASE.$BRANCH.$REVISION_ID started." + echo `date +%H:%M` "Assuming Synfig installed in $P." + else + let RUNTIME=$RUNTIME+1 + fi + else + #no synfigstudio process exist + if [[ $STARTED == 1 ]]; then + #detect crash + if [ -e ~/.synfig/fifo ]; then + CRASH=1 + fi + writelog + CRASH=0 + STARTED=0 + fi + fi + sleep 1 + done +} + + +init +mainloop