[repsnapper] New upstream version 2.3.1a0
Miro Hrončok
churchyard at fedoraproject.org
Tue Nov 26 18:15:10 UTC 2013
commit 506ddcb17aaa1f2b7c963e6475aaa169d1739d82
Author: Miro Hrončok <miro at hroncok.cz>
Date: Tue Nov 26 19:14:59 2013 +0100
New upstream version 2.3.1a0
.gitignore | 1 +
repsnapper-old-clipper.patch | 399 ++++++++++++++++++++++++++++++++++++++
repsnapper-use-system-libs.patch | 14 +-
repsnapper.spec | 11 +-
sources | 2 +-
5 files changed, 415 insertions(+), 12 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index 4cfcdd3..d88a78d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
/repsnapper-2.2.0-65a056a.tar.gz
/repsnapper-2.2.0-89847f5.tar.gz
/repsnapper-2.2.0-f6f3df0.tar.gz
+/repsnapper-2.3.1-e41fb0b.tar.gz
diff --git a/repsnapper-old-clipper.patch b/repsnapper-old-clipper.patch
new file mode 100644
index 0000000..c52682c
--- /dev/null
+++ b/repsnapper-old-clipper.patch
@@ -0,0 +1,399 @@
+diff --git a/src/slicer/clipping.cpp b/src/slicer/clipping.cpp
+index aa2c63a..f3dfc9d 100644
+--- a/src/slicer/clipping.cpp
++++ b/src/slicer/clipping.cpp
+@@ -55,26 +55,20 @@ void Clipping::PolyTreeToExPolygons(const CL::PolyTree * polytree, ExPolygons& e
+
+
+
+-void printCLpolygon(CL::Path &p) {
+- cout << p.size() << endl;
+- for (uint k = 0; k < p.size(); k++) {
+- cout << p[k].X <<", " << p[k].Y << "," << endl;
+- }
+- cout << endl;
+-}
++//CL::Clipper Clipping::clpr; // not static
+
+-void printCLpolygons(CL::Paths &p) {
+- for (uint j = 0; j < p.size(); j++) {
+- printCLpolygon(p[j]);
+- cout << endl;
+- }
+-}
+-void printCLpolygons(vector<CL::Paths> &p) {
++void printCLpolygons(vector<CL::Polygons> &p) {
+ uint numpolys = 0;
+ for (uint i = 0; i < p.size(); i++) numpolys += p[i].size();
+ cout << numpolys << endl;
+ for (uint i = 0; i < p.size(); i++) {
+- printCLpolygons(p[i]);
++ for (uint j = 0; j < p[i].size(); j++) {
++ cout << p[i][j].size() << endl;
++ for (uint k = 0; k < p[i][j].size(); k++) {
++ cout << p[i][j][k].X <<", " << p[i][j][k].Y << "," << endl;
++ }
++ cout << endl;
++ }
+ }
+ }
+
+@@ -99,9 +93,9 @@ Vector2d Clipping::getPoint(const CL::IntPoint &p)
+ p.Y/CL_FACTOR-CL_OFFSET);
+ }
+
+-CL::Path Clipping::getClipperPolygon(const Poly &poly)
++CL::Polygon Clipping::getClipperPolygon(const Poly &poly)
+ {
+- CL::Path cpoly(poly.vertices.size());
++ CL::Polygon cpoly(poly.vertices.size());
+ for(size_t i=0; i<poly.vertices.size();i++){
+ Vector2d P1;
+ // if (reverse)
+@@ -118,7 +112,7 @@ CL::Path Clipping::getClipperPolygon(const Poly &poly)
+ return cpoly;
+ }
+
+-CL::Paths Clipping::getClipperPolygons(const vector<Poly> &polys)
++CL::Polygons Clipping::getClipperPolygons(const vector<Poly> &polys)
+ {
+ ClipperLib::Polygons cpolys(polys.size());
+ for (uint i=0; i<polys.size(); i++)
+@@ -127,7 +121,7 @@ CL::Paths Clipping::getClipperPolygons(const vector<Poly> &polys)
+ }
+ return cpolys;
+ }
+-CL::Paths Clipping::getClipperPolygons(const ExPoly &expoly)
++CL::Polygons Clipping::getClipperPolygons(const ExPoly &expoly)
+ {
+ return getClipperPolygons(getPolys(expoly));
+ }
+@@ -172,34 +166,21 @@ CL::PolyType Clipping::CLType(PolyType type)
+
+ void Clipping::addPoly(const Poly &poly, PolyType type)
+ {
+- clpr.AddPath(getClipperPolygon(poly), CLType(type), true);
++ clpr.AddPolygon(getClipperPolygon(poly),CLType(type));
+ lastZ = poly.getZ();
+ lastExtrF = poly.getExtrusionFactor();
+ }
+
+ void Clipping::addPolys(const vector<Poly> &polys, PolyType type)
+ {
+- CL::Paths cp = getClipperPolygons(polys);
++ CL::Polygons cp = getClipperPolygons(polys);
+ if(debug) {
+ if (type==clip)
+ clippolygons.push_back(cp);
+ else if (type==subject)
+ subjpolygons.push_back(cp);
+ }
+- // try {
+- clpr.AddPaths(cp, CLType(type), true);
+- // } catch (...) {
+- // vector<CL::Paths> vcp;
+- // vcp.push_back(cp);
+- // printCLpolygons(vcp);
+- // for (uint i = 0; i < cp.size(); i++) {
+- // cerr << "try polygon "<< i << endl;
+- // clpr.Clear();
+- // printCLpolygon(cp[i]);
+- // clpr.AddPath(cp[i],CLType(type), true);
+- // }
+- // throw("end");
+- // }
++ clpr.AddPolygons(cp,CLType(type));
+ if (polys.size()>0) {
+ lastZ = polys.back().getZ();
+ lastExtrF = polys.back().getExtrusionFactor();
+@@ -215,29 +196,28 @@ void Clipping::addPolys(const vector<ExPoly> &expolys, PolyType type)
+ for (uint i = 0; i < expolys.size(); i++)
+ addPolys(expolys[i], type);
+ }
+-void Clipping::addPolygons(const CL::Paths &cp, PolyType type)
++void Clipping::addPolygons(const CL::Polygons &cp, PolyType type)
+ {
+- clpr.AddPaths(cp, CLType(type), true);
++ clpr.AddPolygons(cp, CLType(type));
+ }
+
+
+-
+ // // return intersection polys
+ // vector< vector<Vector2d> > Clipping::intersect(const Poly poly1, const Poly poly2)
+ // {
+-// CL::Path cpoly1 = getClipperPolygon(poly1),
++// CL::Polygon cpoly1 = getClipperPolygon(poly1),
+ // cpoly2 = getClipperPolygon(poly2);
+ // clpr.Clear();
+-// CL::Paths sol;
+-// clpr.AddPath(cpoly1,CL::ptSubject);
+-// clpr.AddPath(cpoly2,CL::ptClip);
++// CL::Polygons sol;
++// clpr.AddPolygon(cpoly1,CL::ptSubject);
++// clpr.AddPolygon(cpoly2,CL::ptClip);
+ // clpr.Execute(CL::ctIntersection, sol, CL::pftEvenOdd, CL::pftEvenOdd);
+
+ // vector< vector<Vector2d> > result;
+ // for(size_t i=0; i<sol.size();i++)
+ // {
+ // vector<Vector2d> polypoints;
+-// CL::Path cpoly = sol[i];
++// CL::Polygon cpoly = sol[i];
+ // for(size_t j=0; j<cpoly.size();j++){
+ // polypoints.push_back(Vector2d(cpoly[j].X,cpoly[j].Y));
+ // }
+@@ -250,7 +230,7 @@ void Clipping::addPolygons(const CL::Paths &cp, PolyType type)
+ vector<Poly> Clipping::intersect(CL::PolyFillType sft,
+ CL::PolyFillType cft)
+ {
+- CL::Paths inter;
++ CL::Polygons inter;
+ clpr.Execute(CL::ctIntersection, inter, sft, cft);
+ return getPolys(inter, lastZ, lastExtrF);
+ }
+@@ -266,7 +246,7 @@ vector<ExPoly> Clipping::ext_intersect(CL::PolyFillType sft,
+ vector<Poly> Clipping::unite(CL::PolyFillType sft,
+ CL::PolyFillType cft)
+ {
+- CL::Paths united;
++ CL::Polygons united;
+ clpr.Execute(CL::ctUnion, united, sft, cft);
+ return getPolys(united, lastZ, lastExtrF);
+ }
+@@ -283,7 +263,7 @@ vector<ExPoly> Clipping::ext_unite(CL::PolyFillType sft,
+ vector<Poly> Clipping::subtract(CL::PolyFillType sft,
+ CL::PolyFillType cft)
+ {
+- CL::Paths diff;
++ CL::Polygons diff;
+ clpr.Execute(CL::ctDifference, diff, sft, cft);
+ return getPolys(diff, lastZ, lastExtrF);
+ }
+@@ -314,7 +294,7 @@ vector<Poly> Clipping::subtractMerged(double dist,
+ CL::PolyFillType sft,
+ CL::PolyFillType cft)
+ {
+- CL::Paths diff;
++ CL::Polygons diff;
+ clpr.Execute(CL::ctDifference, diff, sft, cft);
+ return getPolys(getMerged(diff, dist), lastZ, lastExtrF);
+ }
+@@ -322,7 +302,7 @@ vector<Poly> Clipping::subtractMerged(double dist,
+ vector<Poly> Clipping::Xor(CL::PolyFillType sft,
+ CL::PolyFillType cft)
+ {
+- CL::Paths xored;
++ CL::Polygons xored;
+ clpr.Execute(CL::ctXor, xored, sft, cft);
+ return getPolys(xored, lastZ, lastExtrF);
+ }
+@@ -330,15 +310,15 @@ vector<Poly> Clipping::Xor(CL::PolyFillType sft,
+ vector<Poly> Clipping::getOffset(const Poly &poly, double distance,
+ JoinType jtype, double miterdist)
+ {
+- CL::Paths cpolys(1); cpolys[0]=getClipperPolygon(poly);
+- CL::Paths offset = CLOffset(cpolys, CL_FACTOR*distance, CLType(jtype), miterdist);
++ CL::Polygons cpolys(1); cpolys[0]=getClipperPolygon(poly);
++ CL::Polygons offset = CLOffset(cpolys, CL_FACTOR*distance, CLType(jtype), miterdist);
+ return getPolys(offset, poly.getZ(), poly.getExtrusionFactor());
+ }
+ vector<Poly> Clipping::getOffset(const vector<Poly> &polys, double distance,
+ JoinType jtype, double miterdist)
+ {
+- CL::Paths cpolys = getClipperPolygons(polys);
+- CL::Paths offset = CLOffset(cpolys, CL_FACTOR*distance, CLType(jtype), miterdist);
++ CL::Polygons cpolys = getClipperPolygons(polys);
++ CL::Polygons offset = CLOffset(cpolys, CL_FACTOR*distance, CLType(jtype), miterdist);
+ double z=0, extrf=1.;;
+ if (polys.size()>0) {
+ z = polys.back().getZ();
+@@ -371,12 +351,12 @@ vector<Poly> Clipping::getOffset(const vector<ExPoly> &expolys, double distance,
+ // extrf = expolys.back().outer.getExtrusionFactor();
+ // }
+ // for (uint i = 0 ; i < expolys.size(); i++) {
+-// CL::Paths outer = CLOffset(excpolys[i].outer,
++// CL::Polygons outer = CLOffset(excpolys[i].outer,
+ // CL_FACTOR*distance, CLType(jtype), miterdist);
+ // polys[i].outer = getPoly(outer, z, extrusionfactor);
+ // vector<Poly> polys[i].holes;
+ // for (uint h = 0 ; h < polys[i].holes.size(); h++) {
+-// CL::Paths holes = CLOffset(excpolys[i].holes[h],
++// CL::Polygons holes = CLOffset(excpolys[i].holes[h],
+ // CL_FACTOR*distance, CLType(jtype), miterdist);
+ // vector<Poly> hpolys = CL:getPolys(holes, z, extrusionfactor);
+ // polys[i].holes.insert(polys[i].holes.end(),hpolys.begin(),hpolys.end());
+@@ -389,9 +369,9 @@ vector<Poly> Clipping::getOffset(const vector<ExPoly> &expolys, double distance,
+ vector<Poly> Clipping::getShrinkedCapped(const vector<Poly> &polys, double distance,
+ JoinType jtype, double miterdist)
+ {
+- CL::Paths cpolys = getClipperPolygons(polys);
+- CL::Paths offset1 = CLOffset(cpolys, -2*CL_FACTOR*distance, CLType(jtype), 0);// CL::jtRound);
+- CL::Paths offset = CLOffset(offset1, 1*CL_FACTOR*distance, CLType(jtype), 0);
++ CL::Polygons cpolys = getClipperPolygons(polys);
++ CL::Polygons offset1 = CLOffset(cpolys, -2*CL_FACTOR*distance, CLType(jtype), 0);// CL::jtRound);
++ CL::Polygons offset = CLOffset(offset1, 1*CL_FACTOR*distance, CLType(jtype), 0);
+ double z=0, extrf=1.;;
+ if (polys.size()>0) {
+ z= polys.back().getZ();
+@@ -402,10 +382,10 @@ vector<Poly> Clipping::getShrinkedCapped(const vector<Poly> &polys, double dista
+
+
+ // offset with reverse test
+- CL::Paths Clipping::CLOffset(const CL::Paths &cpolys, int cldist,
++ CL::Polygons Clipping::CLOffset(const CL::Polygons &cpolys, int cldist,
+ CL::JoinType cljtype, double miter_limit, bool reverse)
+ {
+- CL::Paths opolys;
++ CL::Polygons opolys;
+ if (reverse)
+ CL::ReversePolygons(opolys);
+ CL::OffsetPolygons(cpolys, opolys, cldist, cljtype, miter_limit);
+@@ -416,8 +396,8 @@ vector<Poly> Clipping::getShrinkedCapped(const vector<Poly> &polys, double dista
+ // overlap a bit and unite to merge adjacent polys
+ vector<Poly> Clipping::getMerged(const vector<Poly> &polys, double overlap)
+ {
+- CL::Paths cpolys = getClipperPolygons(polys);
+- CL::Paths merged = getMerged(cpolys, CL_FACTOR*overlap);
++ CL::Polygons cpolys = getClipperPolygons(polys);
++ CL::Polygons merged = getMerged(cpolys, CL_FACTOR*overlap);
+ double z=0, extrf = 1.;
+ if (polys.size()>0) {
+ z= polys.back().getZ();
+@@ -426,24 +406,24 @@ vector<Poly> Clipping::getMerged(const vector<Poly> &polys, double overlap)
+ return getPolys(merged, z, extrf);
+ }
+ // overlap a bit and unite to merge adjacent polys
+-CL::Paths Clipping::getMerged(const CL::Paths &cpolys, int overlap)
++CL::Polygons Clipping::getMerged(const CL::Polygons &cpolys, int overlap)
+ {
+ CL::Clipper clpr;
+ // return polys;
+ // make wider to get overlap
+- CL::Paths offset;
++ CL::Polygons offset;
+ offset = CLOffset(cpolys, overlap, CL::jtMiter, 1);
+ //CL::OffsetPolygons(cpolys, offset, 10, ClipperLib::jtMiter, 1);
+ // return getPolys(offset, polys.back().getZ(),polys.back().getExtrusionFactor());
+- clpr.AddPaths(offset, CL::ptSubject, true);
+- CL::Paths cpolys3;
++ clpr.AddPolygons(offset, CL::ptSubject);
++ CL::Polygons cpolys3;
+ clpr.Execute(CL::ctUnion, cpolys3, CL::pftEvenOdd, CL::pftEvenOdd);
+ //cerr << cpolys3.size() << " - "<<offset.size() << endl;
+ // shrink the result
+ return CLOffset(cpolys3, -overlap, CL::jtMiter, 1);
+ }
+
+-Poly Clipping::getPoly(const CL::Path &cpoly, double z, double extrusionfactor)
++Poly Clipping::getPoly(const CL::Polygon &cpoly, double z, double extrusionfactor)
+ {
+ Poly p(z, extrusionfactor);
+ p.vertices.clear();
+@@ -457,7 +437,7 @@ Poly Clipping::getPoly(const CL::Path &cpoly, double z, double extrusionfactor)
+ return p;
+ }
+
+-vector<Poly> Clipping::getPolys(const CL::Paths &cpolys, double z, double extrusionfactor)
++vector<Poly> Clipping::getPolys(const CL::Polygons &cpolys, double z, double extrusionfactor)
+ {
+ uint count = cpolys.size();
+ vector<Poly> polys(count);
+@@ -536,16 +516,16 @@ vector<ExPoly> Clipping::getExPolys(const vector<Poly> &polys,
+
+ CL::PolyTree Clipping::getClipperTree(const vector<Poly> &polys)
+ {
+- CL::Paths cpolys = getClipperPolygons(polys);
++ CL::Polygons cpolys = getClipperPolygons(polys);
+ CL::Clipper clpr;
+- clpr.AddPaths(cpolys, CL::ptSubject, true);
++ clpr.AddPolygons(cpolys, CL::ptSubject);
+ CL::PolyTree ctree;
+ clpr.Execute(CL::ctUnion, ctree, CL::pftEvenOdd, CL::pftEvenOdd);
+ return ctree;
+ }
+
+ double Clipping::Area(const Poly &poly){
+- CL::Path cp = getClipperPolygon(poly);
++ CL::Polygon cp = getClipperPolygon(poly);
+ return (double)((long double)(CL::Area(cp))/CL_FACTOR/CL_FACTOR);
+ }
+ double Clipping::Area(const vector<Poly> &polys){
+diff --git a/src/slicer/clipping.h b/src/slicer/clipping.h
+index 9441458..dfaf33b 100644
+--- a/src/slicer/clipping.h
++++ b/src/slicer/clipping.h
+@@ -57,13 +57,13 @@ class Clipping
+ static CL::IntPoint ClipperPoint(const Vector2d &v);
+ static Vector2d getPoint(const CL::IntPoint &p);
+
+- static CL::Paths CLOffset(const CL::Paths &cpolys, int cldist,
+- CL::JoinType cljtype, double miter_limit=1,
+- bool reverse=false);
++ static CL::Polygons CLOffset(const CL::Polygons &cpolys, int cldist,
++ CL::JoinType cljtype, double miter_limit=1,
++ bool reverse=false);
+
+ bool debug;
+- vector<CL::Paths> subjpolygons; // for debugging
+- vector<CL::Paths> clippolygons;
++ vector<CL::Polygons> subjpolygons; // for debugging
++ vector<CL::Polygons> clippolygons;
+
+ public:
+ Clipping(bool debugclipper=false){debug = debugclipper;};
+@@ -75,7 +75,7 @@ public:
+ void addPolys (const vector<Poly> &poly, PolyType type);
+ void addPolys (const vector<ExPoly> &expolys, PolyType type);
+ void addPolys (const ExPoly &poly, PolyType type);
+- void addPolygons(const CL::Paths &cp, PolyType type);
++ void addPolygons(const CL::Polygons &cp, PolyType type);
+
+ // do after addPoly... and before clipping/results
+ void setZ(double z) {lastZ = z;};
+@@ -101,7 +101,7 @@ public:
+ CL::PolyFillType cft=CL::pftEvenOdd);
+
+ static vector<Poly> getMerged(const vector<Poly> &polys, double overlap=0.001);
+- static CL::Paths getMerged(const CL::Paths &cpolys, int overlap=3);
++ static CL::Polygons getMerged(const CL::Polygons &cpolys, int overlap=3);
+
+ static vector<Poly> getOffset(const Poly &poly, double distance,
+ JoinType jtype=jmiter, double miterdist=1);
+@@ -117,10 +117,10 @@ public:
+
+ //vector< vector<Vector2d> > intersect(const Poly poly1, const Poly poly2) const;
+
+- static Poly getPoly(const CL::Path &cpoly, double z, double extrusionfactor);
++ static Poly getPoly(const CL::Polygon &cpoly, double z, double extrusionfactor);
+ static vector<Poly> getPolys(const ExPoly &expoly);
+ static vector<Poly> getPolys(const vector<ExPoly> &expolys);
+- static vector<Poly> getPolys(const CL::Paths &cpoly, double z, double extrusionfactor);
++ static vector<Poly> getPolys(const CL::Polygons &cpoly, double z, double extrusionfactor);
+ static vector<ExPoly> getExPolys(const CL::PolyTree &ctree, double z,
+ double extrusionfactor);
+
+@@ -129,9 +129,9 @@ public:
+ static vector<ExPoly> getExPolys(const vector<Poly> &polys);
+ static CL::PolyTree getClipperTree(const vector<Poly> &polys);
+
+- static CL::Path getClipperPolygon (const Poly &poly);
+- static CL::Paths getClipperPolygons(const vector<Poly> &polys);
+- static CL::Paths getClipperPolygons(const ExPoly &expoly);
++ static CL::Polygon getClipperPolygon (const Poly &poly);
++ static CL::Polygons getClipperPolygons(const vector<Poly> &polys);
++ static CL::Polygons getClipperPolygons(const ExPoly &expoly);
+ //static CL::PolyTree getClipperTree(const vector<ExPoly> &expolys);
+
+ static double Area(const Poly &poly);
+@@ -145,8 +145,8 @@ public:
+ // old API compatibility
+ // polytree to expolygons
+ struct ExPolygon {
+- CL::Path outer;
+- CL::Paths holes;
++ CL::Polygon outer;
++ CL::Polygons holes;
+ };
+ typedef std::vector< ExPolygon > ExPolygons;
+ static void AddOuterPolyNodeToExPolygons(const CL::PolyNode *polynode,
diff --git a/repsnapper-use-system-libs.patch b/repsnapper-use-system-libs.patch
index 8de3298..e7ae955 100644
--- a/repsnapper-use-system-libs.patch
+++ b/repsnapper-use-system-libs.patch
@@ -24,10 +24,10 @@ index ee85dde..7bda7e9 100644
# po doesn't use automake, so it can't be included.
SUBDIRS = po
diff --git a/configure.ac b/configure.ac
-index 1def91c..3894738 100644
+index 3970442..84f5232 100644
--- a/configure.ac
+++ b/configure.ac
-@@ -38,7 +38,7 @@ AC_LANG_CPLUSPLUS
+@@ -48,7 +48,7 @@ AC_LANG_CPLUSPLUS
dnl check for installed clipperlib newer than 5.1.0 (has PolyNode)
AC_DEFINE([HAVE_CLIPPERLIB],[0],[Have external clipper])
@@ -37,7 +37,7 @@ index 1def91c..3894738 100644
[AC_DEFINE([HAVE_CLIPPERLIB],[1]) CLIPPER_LIBS="-lpolyclipping"],
[AC_MSG_WARN([libclipper is not installed. Using internal copy.])])
diff --git a/src/Makefile.am b/src/Makefile.am
-index 061e82c..6a7d0e3 100644
+index 5e34c94..0b912bb 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -14,8 +14,6 @@ LIB_DIR=$(top_srcdir)/libraries
@@ -45,7 +45,7 @@ index 061e82c..6a7d0e3 100644
repsnapper_CPPFLAGS = \
- -I$(LIB_DIR)/vmmlib/include \
-- -I$(LIB_DIR)/lmfit/lmfit-3.2/lib \
+- -I$(LIB_DIR)/lmfit/lmfit-5.0/lib \
-I$(top_srcdir) \
-I$(top_srcdir)/src \
-I$(top_srcdir)/src/slicer \
@@ -77,7 +77,7 @@ index 341e782..2226ab1 100644
{
double _scale;
diff --git a/src/slicer/clipping.h b/src/slicer/clipping.h
-index dfaf33b..37a58aa 100644
+index 9441458..78411a4 100644
--- a/src/slicer/clipping.h
+++ b/src/slicer/clipping.h
@@ -22,11 +22,7 @@
@@ -94,10 +94,10 @@ index dfaf33b..37a58aa 100644
#include "poly.h"
diff --git a/src/slicer/geometry.cpp b/src/slicer/geometry.cpp
-index 451aded..0d4a48d 100644
+index 7b41bbf..20c4249 100644
--- a/src/slicer/geometry.cpp
+++ b/src/slicer/geometry.cpp
-@@ -968,7 +968,7 @@ vector<Vector2d> simplified(const vector<Vector2d> &vert, double epsilon)
+@@ -966,7 +966,7 @@ vector<Vector2d> simplified(const vector<Vector2d> &vert, double epsilon)
///////////////////// POLY2TRI TRIANG ////////////////////
diff --git a/repsnapper.spec b/repsnapper.spec
index 78b704c..73dcb58 100644
--- a/repsnapper.spec
+++ b/repsnapper.spec
@@ -1,6 +1,6 @@
Name: repsnapper
-Version: 2.2.0
-Release: 0.6.b3%{?dist}
+Version: 2.3.1
+Release: 0.1.a0%{?dist}
Summary: RepRap control software
# repsnapper is GPLv2 as noted in licensing.txt
@@ -17,12 +17,12 @@ Summary: RepRap control software
License: GPLv2 and MIT and softSurfer and CC-BY
URL: https://github.com/timschmidt/%{name}
-%global commit f6f3df01654469cf4d9aafe5b3b7f09db80820fe
+%global commit e41fb0b0daf88b3f0bd234c39b0363347f74c6ae
%global shortcommit %(c=%{commit}; echo ${c:0:7})
Source0: https://github.com/timschmidt/%{name}/archive/%{commit}/%{name}-%{version}-%{shortcommit}.tar.gz
Source1: %{name}-softsurfer-copyright-email.txt
Patch0: %{name}-use-system-libs.patch
-Patch1: %{name}-lmfit50.patch
+Patch1: %{name}-old-clipper.patch
BuildRequires: amftools-devel
BuildRequires: cairomm-devel
BuildRequires: desktop-file-utils
@@ -97,6 +97,9 @@ fi
%{_datadir}/icons/hicolor/scalable/apps/%{name}.svg
%changelog
+* Tue Nov 26 2013 Miro Hrončok <mhroncok at redhat.com> - 2.3.1-0.1.a0
+- New upstream version 2.3.1a0
+
* Tue Aug 27 2013 Miro Hrončok <mhroncok at redhat.com> - 2.2.0-0.6.b3
- New upstream betaversion
- Rebuild for new lmfit, added patch to support it
diff --git a/sources b/sources
index dc59a04..e9d57e1 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-865e9718f7b080dc0fd22ae323e0d926 repsnapper-2.2.0-f6f3df0.tar.gz
+6621b674a034c948acb7c39db87ac03d repsnapper-2.3.1-e41fb0b.tar.gz
More information about the scm-commits
mailing list