Implement predefined and custom paper sizes - #87

From the discussion in #86, I went ahead and implemented scaffolding to detect predefined and custom page sizes, especially taking into account #86 (comment). 😄

Now, option -S accepts any of the following options:

• One of the predefined sizes: a4 (default), a5, letter, legal, invoice, and oficio.
• A custom size, described with the format WIDTHxHEIGHT[unit].
  • unit is optional, and defaults to cm if not given.
  • unit accepts one of in, cm, or pt.
  • If a negative size is given, the program forces it to be positive.

Then, when parsing the options, the program basically follows this parsing path:

1. Try to get a predefined size, taking the user input as name.
2. If no match is found, try to parse the input as a custom size. (I use sscanf to aid with this.)
3. If the input cannot be parsed, nothing is done (the help page is shown and EXIT_FAILURE is returned).

Even though implementing predefined and custom page sizes was not a too difficult task, the behavior of PDF rendering when multiple sudokus are requested is another matter. 😬

The previous implementation hardcoded 4 sudokus per page, and used cairo_scale and cairo_translate to reuse the grid drawing function.

Now, it was necessary to get the current transformation matrix and map user units to device units, or points (each sudoku is composed of squares that measure 50 user units, and so each sudoku is 450x450 user units). To determine how many sudokus fit per axis, the following calculations were done.

// First sudoku uses initial margin as padding.
double fsx = SUDOKU_SPACE(double, di_initial_pad.x);
double fsy = SUDOKU_SPACE(double, di_initial_pad.y);

cairo_matrix_transform_distance(&ctm, &fsx, &fsy);

// Other sudokus use uniform intra-spacing.
double sx = SUDOKU_SPACE(double, di_intra_pad.x);
double sy = SUDOKU_SPACE(double, di_intra_pad.y);

cairo_matrix_transform_distance(&ctm, &sx, &sy);

// No. sudokus = ((Page length - first sudoku length) / other sudokus length) + 1
// The +1 accounts for the first sudoku that was subtracted from the page length.

double fx = ((dd_ps.width - fsx) / sx) + 1;
double fy = ((dd_ps.height - fsy) / sy) + 1;

The code above basically means:

• The first sudoku on the row/column has its own left/top margins, which take into account a predefined intraspacing, and the overall document margins.
• For any other sudokus, the top and left margins only take into account the predefined intraspacing.

Then, each sudoku is printed in its right place, by calculating the user unit coordinates where Cairo should start drawing each of them, as seen in the code below:

int no_sudokus_per_page = d_fit.x * d_fit.y;

for (int i=0; i < sudokus_count; i++)
{
	int cur_sudoku_col = (i % no_sudokus_per_page) % d_fit.x;
	int cur_sudoku_row = (i % no_sudokus_per_page) / d_fit.x;

	DUPLE_INT start = {
		di_initial_pad.x + (cur_sudoku_col * SUDOKU_SPACE(int, di_intra_pad.x)),
		di_initial_pad.y + (cur_sudoku_row * SUDOKU_SPACE(int, di_intra_pad.y))
	};

	cairo_translate(cr, start.x, start.y);

	char* stream;
	stream = generate_puzzle(difficulty);

#ifdef DEBUG
	printf("%d: %s\n", i, stream);
#endif // DEBUG

	draw_grid(stream, cr);

	cairo_translate(cr, -start.x, -start.y);

	if ((i + 1) < sudokus_count && (i + 1) % no_sudokus_per_page == 0) {
		// Show current page
		cairo_show_page(cr);
		prepare_new_page(cr, difficulty, false);
	}

	free(stream);
}

Overall, I'm quite satisfied by the results achieved. 😌

However, I know my code can be improved. For example, right now there is no upper-limit capping in either -n or -S, so a user can issue something like:

./src/nudoku -p riddle.pdf -n 8375 -S 1621x897in

Therefore, any comments or suggestions are welcome to make this better. 👍🏻

Thanks! 🚀