/**************************
* Headers
**************************/
#include <iostream>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <complex>
#include <cmath>
#include "pdf.h"
/**************************
* Using Declarations
**************************/
using std::ostringstream;
using std::ifstream;
using std::complex;
using std::cout;
using std::endl;
using std::ios;
/**************************
* Local Functions
**************************/
// ---------------------------------------------------
// Multiply degrees by (2 * pi / 360.0) to
// obtain radians
// ---------------------------------------------------
static double degreesToRadians(int degrees)
{
return((3.14159 / 180.0) * degrees);
}
// ---------------------------------------------------
// Read 'fileName' and populate 'lines' with its
// contents (on success, return true). On error,
// populate 'errMsg' and return false.
// ---------------------------------------------------
static bool getLines(
const string &fileName,
vector<string> &lines,
string &errMsg
)
{
ifstream in;
in.open(fileName.c_str(), ios::binary);
if(!in)
{
errMsg = "Could not open: [" + fileName + "]";
return(false);
}
string line = "";
for(;;)
{
char c = (char)in.get();
if(in.eof())
{
if(line != "")
lines.push_back(line);
break;
}
line += c;
if(c == '\n')
{
lines.push_back(line);
line = "";
}
}
in.close();
return(true);
}
// ---------------------------------------------------
// Draw 'theText' at: [x, y] (using the specified
// font and font size) with a box around it
// ---------------------------------------------------
static void drawBoundedText(
const string &theText,
int x,
int y,
PDF::Font theFont,
int fontSize,
PDF &p
)
{
p.setFont(theFont, fontSize);
p.showTextXY(theText, x, y);
int width = PDF::stringWidth(
theFont, fontSize, theText
);
int offset = (int)(0.4 * fontSize + 0.5);
p.drawRect(x, y - offset, width, fontSize + offset);
}
// ---------------------------------------------------
// Demonstrate:
//
// - text wrapping
// - drawing and filling of circles and ellipses
// - drawing and filling of rectangles and polygons
// - drawing lines, using different line widths
// - use of images
// ---------------------------------------------------
static void demoOne(PDF &p)
{
p.setFont(PDF::HELVETICA, 12);
string s = " \t\t fee \r\nxxxxxxxxxxxxx\r\n\"fi\"fo fum";
s += " a aa aaa aaaa bbb bb b c cc ccc dddd eeeee ";
s += " foo bar baz foo bar baz ";
s += " mairzy doats and doazy doats and little lambsey divey";
s += " a kiddley divey too, wouldn't you? ";
s += " a b c d e f g h i jj kkk llll mmmmmm nnnnnnn oooooooooooo ";
s += "----------------------- -------------------------- ";
s += "$$$ $$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ ";
s += "******************** ************************ ***** ";
vector<string> sv = p.wrapText(s, 100, true);
for(int i = 0, n = sv.size(); i < n; i ++)
{
// cout << "sv[" << i << "][" << sv[i] << "]\n";
p.showTextXY(sv[i], 80, 745 - 20 * i);
}
p.drawLine(80, 760, 80, 300);
p.drawLine(180, 760, 180, 300);
// cout << endl;
p.drawEllipse(400, 550, 150, 75);
p.setFillColor(255, 255, 0);
p.fillEllipse(400, 550, 40, 65);
p.drawEllipse(400, 550, 40, 65);
for(int i = 0; i < 12; i ++)
{
unsigned char value = (unsigned char)(20 * i);
p.setFillColor(value, value, value);
p.fillCircle(480, 310 + 10 * i, 2 * i);
p.drawCircle(480, 310 + 10 * i, 3 * i);
}
p.setLineColor(255, 0, 0);
p.setFillColor(0, 0, 255);
for(int i = 0; i < PDF::N_FONTS; i ++)
{
PDF::Font theFont = (PDF::Font)(i + 1);
int fontSize = 9;
int x = 10;
int y = 36 + (2 * fontSize) * i;
string s =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
"!@#$%^&*()_-=+[]{};:<>,./?";
drawBoundedText(s, x, y, theFont, fontSize, p);
}
p.fillRect(300, 700, 40, 40);
p.drawRect(400, 700, 40, 40);
p.newPage();
p.setLineColor(255, 0, 0);
for(int i = 0; i < PDF::N_FONTS; i ++)
{
p.setFont((PDF::Font)(i + 1), 20);
p.showTextXY(PDF::FONTS[i], 100, 100 + 40 * i);
}
p.newPage();
p.setLineColor(255, 0, 0);
for(int i = 0; i < 20; i ++)
{
p.drawLine(0, 0, 30 * (1 + i), 500 - 15 * i);
p.setLineWidth(i/2 + 1);
}
vector<XY> points;
points.push_back(XY(300, 500));
points.push_back(XY(325, 550));
points.push_back(XY(350, 480));
points.push_back(XY(375, 570));
points.push_back(XY(400, 460));
points.push_back(XY(425, 590));
points.push_back(XY(450, 450));
p.setLineColor(0, 255, 0);
p.drawLine(points);
points.clear();
points.push_back(XY(100, 540));
points.push_back(XY(150, 700));
points.push_back(XY( 80, 700));
p.setFillColor(200, 200, 200);
p.fillPolygon(points);
p.setLineColor(0, 0, 255);
p.drawPolygon(points);
p.newPage();
// Make an image
ImageRow row1;
ImageRow row2;
row1.push_back(RGB(255, 255, 0));
row1.push_back(RGB(255, 0, 255));
row1.push_back(RGB( 0, 255, 0));
row2.push_back(RGB( 0, 0, 255));
row2.push_back(RGB(255, 0, 0));
row2.push_back(RGB( 0, 0, 255));
Image anImage;
anImage.push_back(row1);
anImage.push_back(row2);
ImageInfo info = p.processImage(anImage);
double scale = 50.0;
for(int i = 0; i < 10; i ++)
{
int xValue = 120 + 30 * i;
int yValue = 220 + 40 * i;
p.showImage(info, xValue, yValue, scale);
p.drawRect(
xValue,
yValue,
(int)(scale * info.mWidth + 0.5),
(int)(scale * info.mHeight + 0.5)
);
}
}
// ---------------------------------------------------
// Demonstrate:
//
// - the use of 'drawLine' and trigonometry
// to create a geometric line drawing
// ---------------------------------------------------
static void demoTwo(PDF &p)
{
int xc = p.getWidth() / 2;
int yc = p.getHeight() / 2;
int smaller = (xc < yc ? xc : yc);
int radius = (int)(.9 * smaller);
int step = 15;
for(int i = 0; i < 360; i += step)
{
double angle = degreesToRadians(i);
int x0 = xc + (int)(radius * cos(angle) + 0.5);
int y0 = yc + (int)(radius * sin(angle) + 0.5);
for(int j = 0; j < 360; j += step)
{
if(j != i)
{
double theAngle = degreesToRadians(j);
int x1 = xc + (int)(radius * cos(theAngle) + 0.5);
int y1 = yc + (int)(radius * sin(theAngle) + 0.5);
p.drawLine(x0, y0, x1, y1);
}
}
}
}
// ---------------------------------------------------
// Demonstrate:
//
// - ability to embed program code (this function,
// 'demoThree' itself) in the pdf
//
// - use of images to create and store a
// generated fractal image
//
// Note: The comments before and after the
// 'demoThree' function that look like this:
//
// // begin: demoThree
// // end: demoThree
//
// are markers in the source so that the
// code for the 'demoThree' function can
// be extracted and written to the pdf file
// file and that process will fail if those
// comments are altered/removed
//
// ---------------------------------------------------
// begin: demoThree
static void demoThree(PDF &p)
{
// Create an image, 500 pixels square
int width = 500;
int height = 500;
Image anImage;
RGB theColor(0, 0, 0);
for(int i = 0; i < height; i ++)
{
ImageRow theRow;
for(int j = 0; j < width; j ++)
theRow.push_back(theColor);
anImage.push_back(theRow);
}
double yStart = -2.0;
double yStop = 2.0;
double yStep = (yStop - yStart) / (height - 1);
double xStart = -2.0;
double xStop = 2.0;
double xStep = (xStop - xStart) / (width - 1);
int maxIterations = 25;
double maxDistance = 1000.0;
typedef complex<double> Complex;
int iValue = 0;
for(double y = yStart; y <= yStop; y += yStep)
{
int jValue = 0;
for(double x = xStart; x <= xStop; x += xStep)
{
Complex z(0.0, 0.0);
Complex c(x, y);
int iterations = 0;
while(
iterations < maxIterations &&
sqrt(z.real() * z.real() + z.imag() * z.imag()) < maxDistance
)
{
z = z * z + c;
iterations ++;
}
double v1 = (double)iterations / maxIterations;
double v2 = sqrt(v1);
double v3 = sqrt(v2);
v1 *= 255.0;
v2 *= 255.0;
v3 *= 255.0;
unsigned char red = (unsigned char)(v1 + 0.5);
unsigned char green = (unsigned char)(v2 + 0.5);
unsigned char blue = (unsigned char)(v3 + 0.5);
RGB theColor(red, green, blue);
anImage[iValue][jValue] = theColor;
jValue++;
}
iValue++;
}
// Place the image, centered
ImageInfo info = p.processImage(anImage);
int xValue = (p.getWidth() / 2) - (width / 2);
int yValue = (p.getHeight() / 2) - (height / 2);
p.showImage(info, xValue, yValue, 1.0);
p.newPage();
string errMsg;
vector<string> lines;
if(!getLines(__FILE__, lines, errMsg))
{
cout << errMsg;
}
else
{
static const int FONTSIZE = 8;
static const int MARGIN = 36;
static const int YSTART = 750;
int y = YSTART;
bool showLine = false;
// Avoid false positive by buidling our
// markerBegin and markerEnd strings up dynamically
string tag = "demoThree";
string markerBegin = "// begin: " + tag;
string markerEnd = "// end: " + tag;
bool needSetFont = true;
for(int i = 0, n = lines.size(); i < n; i ++)
{
if(!showLine)
{
if(lines[i].find(markerBegin) != string::npos)
showLine = true;
}
else
{
if(lines[i].find(markerEnd) != string::npos)
showLine = false;
if(showLine)
{
if(needSetFont)
{
p.setFont(PDF::COURIER, FONTSIZE);
needSetFont = false;
}
p.showTextXY(lines[i], MARGIN, y);
y -= FONTSIZE;
if(y <= MARGIN)
{
p.newPage();
needSetFont = true;
y = YSTART;
}
}
}
}
}
}
// end: demoThree
/**************************
* Main
**************************/
int main()
{
typedef void (*DemoFunction)(PDF &);
DemoFunction functions[] =
{
demoOne, demoTwo, demoThree
};
int n = sizeof(functions) / sizeof(functions[0]);
for(int i = 0; i < n; i ++)
{
ostringstream out;
out << "example-" << i << ".pdf";
string fileName = out.str();
cout << "-----------------------------------------" << "\n";
cout << "Creating File: [" << fileName << "]" << "\n";
cout << "-----------------------------------------" << "\n";
PDF pdf;
functions[i](pdf);
string errMsg;
if(!pdf.writeToFile(fileName, errMsg))
{
cout << errMsg << endl;
}
else
{
cout << "(File Successfully Written)" << endl;
}
cout << endl;
}
return(0);
}
