void drvLWO::print_coords()
{
LWO_POLY *p = new LWO_POLY;
p->r = (unsigned char) (255.0 * currentR());
p->g = (unsigned char) (255.0 * currentG());
p->b = (unsigned char) (255.0 * currentB());
p->num = 0; // intial value;
// p->num = numberOfElementsInPath();
p->x = new float[numberOfElementsInPath()]; // allocate a conservative amount
p->y = new float[numberOfElementsInPath()]; // allocate a conservative amount
p->next = polys;
polys = p;
total_polys++;
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:{
const Point & pe = elem.getPoint(0);
// outf << "\t\tmoveto ";
p->x[p->num] = pe.x_ + x_offset;
p->y[p->num] = pe.y_ + y_offset;
p->num++;
}
break;
case lineto:{
const Point & pe = elem.getPoint(0);
// outf << "\t\tlineto ";
p->x[p->num] = pe.x_ + x_offset;
p->y[p->num] = pe.y_ + y_offset;
p->num++;
}
break;
case closepath: // Not supported
// outf << "\t\tclosepath ";
break;
case curveto:{ // Not supported
}
break;
default:
errf << "\t\tFatal: unexpected case in drvpdf " << endl;
abort();
break;
}
// outf << endl;
}
total_vertices += p->num;
// outf << "]" << endl;
}
void drvFIG::bbox_path()
{
for (unsigned int i = 0; i < numberOfElementsInPath(); i++) {
const basedrawingelement & elem = pathElement(i);
switch (elem.getType()) {
case curveto:
{
addtobbox(elem.getPoint(0));
addtobbox(elem.getPoint(1));
addtobbox(elem.getPoint(2));
break;
}
case moveto:
case lineto:
{
addtobbox(elem.getPoint(0));
break;
}
case closepath:
default:
{ // will get caught later
break;
}
}
}
new_depth();
}
void drvJAVA::print_coords()
{
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:{
const Point & p = elem.getPoint(0);
outf << "\tp.addPoint(";
outf << (int) (p.x_ + x_offset) << ","
<< (int) (currentDeviceHeight - p.y_ + y_offset) << ");";
}
break;
case lineto:{
const Point & p = elem.getPoint(0);
outf << "\tp.addPoint(";
outf << (int) (p.x_ + x_offset) << ","
<< (int) (currentDeviceHeight - p.y_ + y_offset) << ");";
}
break;
case closepath:
// outf << "\t\tclosepath ";
break;
case curveto:{
errf << "\t\tFatal: unexpected case in drvjava " << endl;
abort();
}
break;
default:
errf << "\t\tFatal: unexpected case in drvjava " << endl;
abort();
break;
}
outf << endl;
}
}
void drvGCODE::show_path()
{
Point currentPoint(0.0f, 0.0f);
const Point firstPoint = pathElement(0).getPoint(0);
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:{
const Point & p = elem.getPoint(0);
outf << "\nG00 Z#1000\n";
outf << "G00 X[#1003*" << p.x_ << "] Y[#1004*" << p.y_ << "]\n";
outf << "G01 Z#1002\n";
currentPoint = p;
}
break;
case lineto:{
const Point & p = elem.getPoint(0);
outf << "G01 X[#1003*" << p.x_ << "] Y[#1004*" << p.y_ << "]\n";
currentPoint = p;
}
break;
case closepath:
outf << "G01 X[#1003*" << firstPoint.x_ << "] Y[#1004*" << firstPoint.y_ << "]\n";
break;
case curveto:{
const Point & cp1 = elem.getPoint(0);
const Point & cp2 = elem.getPoint(1);
const Point & ep = elem.getPoint(2);
// curve is approximated with a variable number or linear segments.
// fitpoints should be somewhere between 5 and 50 for reasonable page size plots
// we compute distance between current point and endpoint and use that to help
// pick the number of segments to use.
const float dist = (float) pythagoras((float)(ep.x_ - currentPoint.x_),(float)(ep.y_ - currentPoint.y_));
unsigned int fitpoints = (unsigned int)(dist / 10.0);
if ( fitpoints < 5 ) fitpoints = 5;
if ( fitpoints > 50 ) fitpoints = 50;
for (unsigned int s = 1; s < fitpoints; s++) {
const float t = 1.0f * s / (fitpoints - 1);
const Point pt = PointOnBezier(t, currentPoint, cp1, cp2, ep);
outf << " G01 X[#1003*" << pt.x_ << "] Y[#1004*" << pt.y_ << "]\n";
}
currentPoint = ep;
}
break;
default:
errf << "\t\tFatal: unexpected case in drvgcode " << endl;
abort();
break;
}
}
}
// Version with multi-segment lines
void drvVTK::print_coords()
{
int bp = 0;
colorStream << fillR() << " " << fillG() << " " << fillB() << " 0.5" << endl;
polyStream << numberOfElementsInPath() << " " ;
linepoints += numberOfElementsInPath();
lineCount++;
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:{
const Point & p = elem.getPoint(0);
const int m = add_point(p);
polyStream << m-1 << " ";
bp = m;
}
break;
case lineto:{
const Point & p = elem.getPoint(0);
const int l = add_point(p);
polyStream << l-1 << " ";
}
break;
case closepath:
polyStream << bp-1 << " ";
break;
case curveto:{
errf << "\t\tFatal: unexpected case in drvVTK - curveto " << endl;
}
break;
default:
errf << "\t\tFatal: unexpected case in drvVTK : default" << endl;
abort();
break;
}
}
polyStream << endl;
}
void drvRIB::print_coords()
{
outf << "PointsGeneralPolygons[1]" << endl;
outf << "[" << numberOfElementsInPath() << "]" << endl << "[";
for (unsigned int i = 0; i < numberOfElementsInPath(); i++) {
outf << i << " ";
}
outf << "]" << endl << "\"P\" [";
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:{
const Point & p = elem.getPoint(0);
// outf << "\t\tmoveto ";
outf << p.x_ + x_offset << " " << p.y_ + y_offset << " 0 ";
}
break;
case lineto:{
const Point & p = elem.getPoint(0);
// outf << "\t\tlineto ";
outf << p.x_ + x_offset << " " << p.y_ + y_offset << " 0 ";
}
break;
case closepath: // Not supported
// outf << "\t\tclosepath ";
break;
case curveto:{ // Not supported
}
break;
default:
errf << "\t\tFatal: unexpected case in drvpdf " << endl;
abort();
break;
}
outf << endl;
}
outf << "]" << endl;
}
void drvPCBFILL::show_path()
{
// outf << "\n#Polyline:\n";
outf << "\tPolygon(0x00000010)\n\t(\n\t\t";
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
if (pathElement(n).getType() != closepath) {
const Point & p = pathElement(n).getPoint(0);
outf << "[" << (int)(p.x_*SCALE) << " "
<< (int)(500000-p.y_*SCALE) << "] ";
}
}
outf << "\n\t)\n";
}
void drvGSCHEM::show_path()
{
// outf << "\n#Polyline:\n";
for (unsigned int n = 1; n < numberOfElementsInPath(); n++) {
const Point & p1 = pathElement(n-1).getPoint(0);
const Point & p = pathElement(n).getPoint(0);
outf << "L ";
outf << (int)(p1.x_*SCALE) << " "
<< (int)(p1.y_*SCALE) << " "
<< (int)(p.x_*SCALE) << " "
<< (int)(p.y_*SCALE) << " 3 0 0 0 -1 -1\n";
}
}
void drvJAVA2::print_coords()
{
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
if (numberOfElements > limitNumberOfElements)
continue_page();
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:{
const Point & p = elem.getPoint(0);
outf << " currentPath.moveTo(" << (p.x_ +
x_offset) << "f, " <<
(currentDeviceHeight - p.y_ + y_offset) << "f);";
}
break;
case lineto:{
const Point & p = elem.getPoint(0);
outf << " currentPath.lineTo(" << (p.x_ +
x_offset) << "f, " <<
(currentDeviceHeight - p.y_ + y_offset) << "f);";
}
break;
case closepath:
outf << " currentPath.closePath();";
break;
case curveto:{
outf << " currentPath.curveTo(";
outf << (elem.getPoint(0).x_ +
x_offset) << "f, " << (currentDeviceHeight -
elem.getPoint(0).y_ + y_offset) << "f, ";
outf << (elem.getPoint(1).x_ +
x_offset) << "f, " << (currentDeviceHeight -
elem.getPoint(1).y_ + y_offset) << "f, ";
outf << (elem.getPoint(2).x_ +
x_offset) << "f, " << (currentDeviceHeight -
elem.getPoint(2).y_ + y_offset) << "f);";
}
break;
default:
errf << "\t\tFatal: unexpected case for elem.getType() in drvjava2" << endl;
abort();
break;
}
outf << endl;
numberOfElements++;
}
}
void drvJAVA::show_path()
{
outf << "\t// Path # " << currentNr() << endl;
// if fill then use a polygon
// else use line-segments.
switch (currentShowType()) {
case drvbase::stroke:{
outf << "\tl = new PSLinesObject(" << endl;
outf << "\t\t" << currentR() << "F," << currentG() << "F," <<
currentB() << "F);" << endl;
for (unsigned int t = 0; t < numberOfElementsInPath(); t++) {
const Point & p = pathElement(t).getPoint(0);
outf << "\tl.addPoint(";
outf << (int) (p.x_ + x_offset) << ","
<< (int) (currentDeviceHeight - p.y_ + y_offset) << ");\n ";
}
outf << "\tcurrentpage.theObjects.addElement(l);" << endl;
}
break;
case drvbase::fill:
case drvbase::eofill:{
outf << "\tp = new PSPolygonObject(";
outf << currentR() << "F," << currentG() << "F," << currentB()
<< "F);" << endl;
print_coords();
if (!isPolygon()) {
// make closed polygon anyway
const basedrawingelement & elem = pathElement(0);
const Point & p = elem.getPoint(0);
outf << "\tp.addPoint(";
outf << (int) (p.x_ + x_offset) << ","
<< (int) (currentDeviceHeight - p.y_ + y_offset) << ");\n ";
}
outf << "\tcurrentpage.theObjects.addElement(p);" << endl;
}
break;
default:
// cannot happen
outf << "unexpected ShowType " << (int) currentShowType();
break;
}
// outf << "\tcurrentLineWidth: " << currentLineWidth() << endl;
}
void drvFIG::print_polyline_coords()
{
int j = 0;
// const Point & p;
unsigned int last = numberOfElementsInPath() - 1;
for (unsigned int n = 0; n <= last; n++) {
const basedrawingelement & elem = pathElement(n);
if (j == 0) {
buffer << "\t";
}
switch (elem.getType()) {
case lineto:
case moveto:
{
const Point & p = pathElement(n).getPoint(0);
prpoint(buffer, p, (n != last));
}
break;
case closepath:
{
const Point & p = pathElement(0).getPoint(0);
prpoint(buffer, p, (n != last));
}
break;
case curveto:
default:
errf << "\t\tFatal: unexpected case in drvfig " << endl;
abort();
break;
}
j++;
if (j == 5) {
j = 0;
buffer << "\n";
}
}
if (j != 0) {
buffer << "\n";
}
}
void drvSAMPL::show_path()
{
outf << "Path # " << currentNr();
if (isPolygon())
outf << " (polygon): " << endl;
else
outf << " (polyline): " << endl;
outf << "\tcurrentShowType: ";
switch (currentShowType()) {
case drvbase::stroke:
outf << "stroked";
break;
case drvbase::fill:
outf << "filled";
break;
case drvbase::eofill:
outf << "eofilled";
break;
default:
// cannot happen
outf << "unexpected ShowType " << (int) currentShowType();
break;
}
outf << endl;
outf << "\tcurrentLineWidth: " << currentLineWidth() << endl;
outf << "\tcurrentR: " << currentR() << endl;
outf << "\tcurrentG: " << currentG() << endl;
outf << "\tcurrentB: " << currentB() << endl;
outf << "\tedgeR: " << edgeR() << endl;
outf << "\tedgeG: " << edgeG() << endl;
outf << "\tedgeB: " << edgeB() << endl;
outf << "\tfillR: " << fillR() << endl;
outf << "\tfillG: " << fillG() << endl;
outf << "\tfillB: " << fillB() << endl;
outf << "\tcurrentLineCap: " << currentLineCap() << endl;
outf << "\tdashPattern: " << dashPattern() << endl;
outf << "\tPath Elements 0 to " << numberOfElementsInPath() - 1 << endl;
print_coords();
}
void drvFIG::show_path()
{
float localLineWidth = currentLineWidth();
localLineWidth *= 80.0f/72.0f; // xfig scales width differently - added in 3.50 - wogl
// dont know whether this should be synchronized with -usecorrectfontsize option.
/*
3.50:
Originally, the resolution of Fig lines was 1/80 inch, and it was thought that the line width of "1" looked too thick, so it was reduced.
Therefore, the final width of lines in PostScript/EPS is:
Figwidth == 1: 7.5
Figwidth > 1: (Figwidth-1)*15
Regards,
Brian Smith
in reverse:
l < (15+7.5)/2 : f = 1
f = (l /15) + 1
*/
const float boundaryforOneCase = (((15.0f + 7.5f)/2.0f) / 15.0f); // 0.75
// if calculated linewidth is (without "+1 correction") > 0.75
// then apply correction by 1
// for the 0.75 case itself it means - map it to 1.75 and from there to 2
// if it is < 0.75, then leave it so and create in fig a 1 ( (int) 0.75+0.5 )
if (Verbose() ) {
cerr << "localLineWidth " << localLineWidth << " b " << boundaryforOneCase << endl;
}
if (localLineWidth > boundaryforOneCase) {
localLineWidth += 1.0f; // see above
} else {
// line width of 0 remain 0 - everything else is at least 1
if ((localLineWidth < 0.0) || ((localLineWidth > 0.0) && (localLineWidth <= 1.0))) {
localLineWidth = 1.0;
}
}
unsigned int linestyle = 0;
switch (currentLineType()) {
case solid:
linestyle = 0;
break;
case dashed:
linestyle = 1;
break;
case dotted:
linestyle = 2;
break;
case dashdot:
linestyle = 3;
break;
case dashdotdot:
linestyle = 4;
break;
}
const unsigned int linecap = currentLineCap();
const unsigned int linejoin = currentLineJoin();
// Calculate BBox
bbox_path();
const unsigned int curvetos = nrOfCurvetos();
if (curvetos == 0) // polyline
{
buffer << "# polyline\n";
buffer << "2 1 " << linestyle << " " << (int) (localLineWidth + 0.5f) << " ";
const unsigned int color = registercolor(currentR(), currentG(), currentB());
const int fill_or_nofill = (currentShowType() == drvbase::stroke) ? -1 : 20;
if (objectId)
objectId--; // don't let it get < 0
buffer << color << " " << color << " " << objectId << " 0 " <<
fill_or_nofill << " " << "4.0" <<
" " << linejoin << " " << linecap
//" 0 0"
<< " 0 0 0 ";
// 4.0 is the gap spec. we could also derive this from the input
buffer << (int) (numberOfElementsInPath()) << "\n";
print_polyline_coords();
} else // contains at least one curveto
{
buffer << "# spline\n";
// 3 2 means "open interpolated spline"
buffer << "3 4 " << linestyle << " " << (int) (localLineWidth + 0.5f) << " ";
const unsigned int color = registercolor(currentR(), currentG(), currentB());
const int fill_or_nofill = (currentShowType() == drvbase::stroke) ? -1 : 20;
if (objectId)
objectId--; // don't let it get < 0
buffer << color << " " << color << " " << objectId << " 0 " <<
fill_or_nofill << " " << "4.0" << //" 0"
" " << linecap
<< " 0 0 ";
// 4.0 is the gap spec. we could also derive this from the input
// IJMP - change to quintic spline - 5 pnts per spline, not 3
buffer << numberOfElementsInPath() + 5 * curvetos - curvetos << "\n";
print_spline_coords1();
print_spline_coords2();
}
}
// print a path via a sequence of fline(), fcont(), fbezier3() operations,
// terminating with a final endpath()
void drvplot::print_coords()
{
Point lastpoint(0, 0);
const Point & firstpoint = pathElement(0).getPoint(0);
bool currently_at_lastpoint = false;
bool last_was_endpath = false;
// since libplot/libplotter doesn't (yet) support sub-paths,
// all paths that we draw will be of the form
// moveto {lineto,curveto}+ {closepath}
// where {}+ means one or more repetitions, and {} means optional.
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:
{
const Point & p = elem.getPoint(0);
lastpoint = p;
currently_at_lastpoint = false;
last_was_endpath = false;
}
break;
case lineto:
{
const Point & p = elem.getPoint(0);
if (currently_at_lastpoint)
(void)plotter->fcont(p.x_ + x_offset, p.y_ + y_offset);
else
(void)plotter->fline(lastpoint.x_ + x_offset,
lastpoint.y_ + y_offset, p.x_ + x_offset, p.y_ + y_offset);
lastpoint = p;
currently_at_lastpoint = true;
last_was_endpath = false;
}
break;
case curveto:
{
const Point & p1 = lastpoint;
const Point & p2 = elem.getPoint(0);
const Point & p3 = elem.getPoint(1);
const Point & p4 = elem.getPoint(2);
(void)plotter->fbezier3(p1.x_ + x_offset, p1.y_ + y_offset,
p2.x_ + x_offset, p2.y_ + y_offset,
p3.x_ + x_offset, p3.y_ + y_offset,
p4.x_ + x_offset, p4.y_ + y_offset);
lastpoint = p4;
currently_at_lastpoint = true;
last_was_endpath = false;
}
break;
case closepath:
if (currently_at_lastpoint)
/* have drawn at least one segment */
{
(void)plotter->fcont(firstpoint.x_ + x_offset, firstpoint.y_ + y_offset);
(void)plotter->endpath();
currently_at_lastpoint = true;
last_was_endpath = true;
}
break;
default:
errf << "\t\tFatal: unexpected case in drvlplot " << endl;
abort();
break;
}
}
if (last_was_endpath == false)
(void)plotter->endpath();
}
// print control points
void drvFIG::print_spline_coords2()
{
int j = 0;
Point lastp;
int maxj = 8;
unsigned int last = numberOfElementsInPath() - 1;
for (unsigned int n = 0; n <= last; n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:
{
buffer << " 0";
if (n != last)
buffer << " ";
j++;
if (j == maxj) {
j = 0;
buffer << "\n";
if ((n + 1) != numberOfElementsInPath()) {
buffer << "\t";
}
}
lastp = elem.getPoint(0);
}
break;
case lineto:
{
buffer << " 0";
if (n != last)
buffer << " ";
j++;
if (j == maxj) {
j = 0;
buffer << "\n";
if ((n + 1) != numberOfElementsInPath()) {
buffer << "\t";
}
}
}
break;
case closepath:
{
buffer << " 0";
if (n != last)
buffer << " ";
j++;
if (j == maxj) {
j = 0;
buffer << "\n";
if ((n + 1) != numberOfElementsInPath()) {
buffer << "\t";
}
}
}
break;
case curveto:
{
// IJMP - change to quintic spline
// put all points, middle points will have control value -1
float kp = 0.0;
for (unsigned int i = 0; i < 5; i++) {
if (i == 1) {
kp = -1.0; //lint !e736
}
if (i == 4) {
kp = 0.0;
}
buffer << " " << kp;
if (!((n == last) && (i == 4)))
buffer << " ";
j++;
if (j == maxj) {
j = 0;
buffer << "\n";
if (!((i == 4)
&& ((n + 1) == numberOfElementsInPath()))) {
buffer << "\t";
}
}
}
lastp = elem.getPoint(2);
}
break;
default:
errf << "\t\tFatal: unexpected case in drvfig " << endl;
abort();
break;
}
}
if (j != 0) {
buffer << endl;
}
}
// print edge points
void drvFIG::print_spline_coords1()
{
// IJMP - need curr_point
Point P1;
int j = 0;
unsigned int last = numberOfElementsInPath() - 1;
for (unsigned int n = 0; n <= last; n++) {
if (j == 0) {
buffer << "\t";
}
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:
case lineto:
{
const Point & p = elem.getPoint(0);
prpoint(buffer, p, (n != last));
P1 = p;
}
j++;
if (j == 5) {
j = 0;
buffer << "\n";
}
break;
case curveto:
{
// IJMP - change to quintic spline
// put all points, middle points will have control value 1
// IJMP = do bezier fit
const Point & P2 = elem.getPoint(0);
const Point & P3 = elem.getPoint(1);
const Point & P4 = elem.getPoint(2);
for (int cp = 1; cp <= 5; cp++) {
const Point p = PointOnBezier((cp * 0.2f), P1, P2, P3, P4);
// p.x_ = bezpnt((cp * 0.2f), P1.x_, P2.x_, P3.x_, P4.x_);
// p.y_ = bezpnt((cp * 0.2f), P1.y_, P2.y_, P3.y_, P4.y_);
prpoint(buffer, p, !((n == last) && (cp == 5)));
j++;
if (j == 5) {
j = 0;
buffer << "\n";
}
// if ((j == 0) && (cp != 5) && ( n+1 != (numberOfElementsInPath()))) { buffer << "\t"; }
if ((j == 0) && (n != (numberOfElementsInPath()))) {
buffer << "\t";
}
}
P1 = P4;
}
break;
case closepath:
{
const Point & p = pathElement(0).getPoint(0);
P1 = p;
prpoint(buffer, p, (n != last));
}
j++;
if (j == 5) {
j = 0;
buffer << "\n";
}
break;
default:
errf << "\t\tFatal: unexpected case in drvfig " << endl;
abort();
break;
}
}
if (j != 0) {
buffer << "\n";
}
buffer << "\t";
}
void drvCAIRO::show_path()
{
DashPattern dp(dashPattern());
outf << endl;
outf << " /*" << endl;
outf << " * Path # " << currentNr() ;
if (isPolygon())
outf << " (polygon):" << endl;
else
outf << " (polyline):" << endl;
outf << " */" << endl;
outf << endl;
outf << " cairo_save (cr);" << endl;
outf << " cairo_set_line_width (cr, " << currentLineWidth() << ");" << endl;
// CAIRO_LINE_CAP_BUTT - start(stop) the line exactly at the start(end) point
// CAIRO_LINE_CAP_ROUND - use a round ending, the center of the circle is the end point
// CAIRO_LINE_CAP_SQUARE - use squared ending, the center of the square is the end point
outf << " cairo_set_line_cap (cr, ";
switch( currentLineCap() ) {
case 0:
outf << "CAIRO_LINE_CAP_BUTT);" << endl;
break;
case 1:
outf << "CAIRO_LINE_CAP_ROUND);" << endl;
break;
case 2:
outf << "CAIRO_LINE_CAP_SQUARE);" << endl;
break;
default:
errf << "Unexpected currentLineCap() in cairo driver: " << currentLineCap() << endl;
outf << "CAIRO_LINE_CAP_ROUND);" << endl;
break;
}
// cairo_set_dash (cairo_t *cr, const double *dashes, int num_dashes, double offset);
// dashes :
// an array specifying alternate lengths of on and off stroke portions
//
// num_dashes :
// the length of the dashes array
//
// offset :
// an offset into the dash pattern at which the stroke should start
//
// dashPattern: has nrOfEntries, float *numbers, float offset
if (dp.nrOfEntries > 0) {
outf << " {" << endl;
outf << " double pat[" << dp.nrOfEntries << "] = {" << endl;
for (int i = 0; i < dp.nrOfEntries; i++) {
outf << " " << dp.numbers[i] << ", " << endl;
}
outf << " };" << endl;
outf << endl;
outf << " cairo_set_dash (cr, pat, " << dp.nrOfEntries << ", " << dp.offset << ");" << endl;
outf << " }" << endl;
} else {
outf << " cairo_set_dash (cr, NULL, 0, 0.0);" << endl;
}
// cairo_move_to (cr, 0.25, 0.25);
// cairo_line_to (cr, 0.5, 0.375);
outf << " /* Path Elements 0 to " << numberOfElementsInPath() - 1 << " */" << endl;
print_coords();
switch (currentShowType()) {
case drvbase::stroke:
outf << " cairo_set_source_rgb (cr, " << edgeR() << "," << edgeG() << "," << edgeB() << ");" << endl;
outf << " cairo_stroke (cr);" << endl;
break;
case drvbase::eofill:
outf << " cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);" << endl;
evenoddmode = true;
case drvbase::fill:
outf << " cairo_set_source_rgb (cr, " << fillR() << "," << fillG() << "," << fillB() << ");" << endl;
outf << " cairo_fill_preserve (cr);" << endl;
if (evenoddmode) {
outf << " cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING);" << endl;
evenoddmode = false;
}
outf << " cairo_set_source_rgb (cr, " << edgeR() << "," << edgeG() << "," << edgeB() << ");" << endl;
outf << " cairo_stroke (cr);" << endl;
break;
default:
// cannot happen
outf << " // unexpected ShowType " << (int) currentShowType();
break;
}
outf << " cairo_restore (cr);" << endl;
}
void drvIDRAW::print_coords()
{
unsigned int pathelts = numberOfElementsInPath();
bool closed; // True if shape is closed
bool curved; // True if shape is curved
const Point *firstpoint; // First and last points in shape
const Point *lastpoint;
unsigned int totalpoints; // Total number of points in shape
const Point dummypoint(-123.456f, -789.101112f); // Used to help eliminate duplicates
unsigned int i, j;
// First, try to figure out what type of shape we have
closed = false;
curved = false;
for (i = 0; i < pathelts; i++) {
if (pathElement(i).getType() == curveto)
curved = true;
else if (pathElement(i).getType() == closepath)
closed = true;
}
const Point **pointlist = new const Point *[pathelts * 3]; // List of points
// Allocate a conservative amount
assert(pointlist != NIL);
firstpoint = NIL;
lastpoint = &dummypoint;
totalpoints = 0;
for (i = 0; i < pathelts; i++) {
const basedrawingelement & pelt = pathElement(i);
if ((pelt.getType() == moveto || pelt.getType() == lineto) &&
!(pelt.getPoint(0) == *lastpoint))
lastpoint = pointlist[totalpoints++] = &pelt.getPoint(0);
else if (pelt.getType() == curveto)
for (j = 0; j < 3; j++)
lastpoint = pointlist[totalpoints++] = &pelt.getPoint(j);
}
if (totalpoints) {
firstpoint = pointlist[0];
if (firstpoint->x_ == lastpoint->x_ && firstpoint->y_ == lastpoint->y_)
closed = true;
// Find points on the curve for curved lines
if (curved) {
const unsigned int pt_per_cp = 5; // PostScript points per control point
const unsigned int min_innerpoints = 2; // Minimum # of points to add
unsigned int innerpoints; // Number of points to add
unsigned int newtotalpoints = 0; // Number of points in curve
// ASSUMPTION: Curve is moveto+curveto+curveto+curveto+...
// List of points on curve
const Point **newpointlist = new const Point *[pathelts * 3000 / pt_per_cp]; // Allocate a conservative amount
assert(newpointlist != NIL);
for (i = 0; i < totalpoints - 3; i += 3) {
const float x0 = pointlist[i]->x_;
const float y0 = pointlist[i]->y_;
const float x1 = pointlist[i + 1]->x_;
const float y1 = pointlist[i + 1]->y_;
const float x2 = pointlist[i + 2]->x_;
const float y2 = pointlist[i + 2]->y_;
const float x3 = pointlist[i + 3]->x_;
const float y3 = pointlist[i + 3]->y_;
const float cx = (x1 - x0) * 3;
const float cy = (y1 - y0) * 3;
const float bx = (x2 - x1) * 3 - cx;
const float by = (y2 - y1) * 3 - cy;
const float ax = x3 - x0 - cx - bx;
const float ay = y3 - y0 - cy - by;
// Longer lines get more control points
innerpoints =(unsigned int) (
pythagoras((y1 - y0),(x1 - x0) ) +
pythagoras((y2 - y1),(x2 - x1) ) +
pythagoras((y3 - y2),(x3 - x2) ) ) / pt_per_cp;
if (innerpoints < min_innerpoints)
innerpoints = min_innerpoints;
// Add points to the list
ADDPOINT(x0, y0);
for (j = 1; j <= innerpoints; j++) {
const float t = (float) j / (float) innerpoints;
const float newx = (((ax * t) + bx) * t + cx) * t + x0;
const float newy = (((ay * t) + by) * t + cy) * t + y0;
ADDPOINT(newx, newy);
}
ADDPOINT(x3, y3);
}
delete[]pointlist;
pointlist = newpointlist;
totalpoints = newtotalpoints;
}
// Straight lines, not closed
if (!closed && !curved) {
if (totalpoints == 2) { // Special case for single line
print_header("Line");
outf << "%I" << endl;
outf << iscale(firstpoint->x_) << ' ' << iscale(firstpoint->y_) << ' ';
outf << iscale(lastpoint->x_) << ' ' << iscale(lastpoint->y_) << ' ';
outf << "Line" << endl;
outf << "%I 1" << endl;
outf << "End" << endl << endl;
} else { // Otherwise, output a multiline
print_header("MLine"); // (Should have a special case for Rect)
outf << "%I " << totalpoints << endl;
for (i = 0; i < totalpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << totalpoints << " MLine" << endl;
outf << "%I 1" << endl;
outf << "End" << endl << endl;
}
}
// Straight lines, closed */
if (closed && !curved) {
unsigned int numpoints;
numpoints = totalpoints == 1 ? 1 : totalpoints - 1;
print_header("Poly"); // Output a polygon
outf << "%I " << numpoints << endl;
for (i = 0; i < numpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << numpoints << " Poly" << endl;
outf << "End" << endl << endl;
}
// Curved lines, not closed
if (!closed && curved) {
print_header("BSpl"); // Output a B-spline
outf << "%I " << totalpoints << endl;
for (i = 0; i < totalpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << totalpoints << " BSpl" << endl;
outf << "%I 1" << endl;
outf << "End" << endl << endl;
}
// Curved lines, closed
if (closed && curved) {
unsigned int numpoints;
numpoints = totalpoints == 1 ? 1 : totalpoints - 1;
print_header("CBSpl"); // Output a closed B-spline
outf << "%I " << numpoints << endl;
for (i = 0; i < numpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << numpoints << " CBSpl" << endl;
outf << "End" << endl << endl;
}
if (curved) {
//
// in this case we have created the pointlist newly with Points on the heap
//
if (pointlist)
for (unsigned int pindex = 0; pindex < totalpoints; pindex++) {
//cout << "pindex / totalpoints " << pindex << " " << totalpoints << " " << pointlist[pindex]->x_ << " " << pointlist[pindex]->y_ << " " << pointlist[pindex]<< endl;
#if defined (_MSC_VER) && (_MSC_VER < 1100)
// MSVC < 6 needs cast here
delete (Point *) (pointlist[pindex]);
#else
delete (pointlist[pindex]);
#endif
}
}
}
delete[]pointlist;
}
