mirror of
https://github.com/invoiceninja/invoiceninja.git
synced 2025-10-31 19:27:32 -04:00
381 lines
12 KiB
JavaScript
Executable File
381 lines
12 KiB
JavaScript
Executable File
/** ====================================================================
|
|
* jsPDF Cell plugin
|
|
* Copyright (c) 2013 Youssef Beddad, youssef.beddad@gmail.com
|
|
* 2013 Eduardo Menezes de Morais, eduardo.morais@usp.br
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
* ====================================================================
|
|
*/
|
|
|
|
(function (jsPDFAPI) {
|
|
'use strict';
|
|
/*jslint browser:true */
|
|
/*global document: false, jsPDF */
|
|
|
|
var fontName,
|
|
fontSize,
|
|
fontStyle,
|
|
padding = 3,
|
|
margin = 13,
|
|
headerFunction,
|
|
lastCellPos = { x: undefined, y: undefined, w: undefined, h: undefined, ln: undefined },
|
|
pages = 1,
|
|
setLastCellPosition = function (x, y, w, h, ln) {
|
|
lastCellPos = { 'x': x, 'y': y, 'w': w, 'h': h, 'ln': ln };
|
|
},
|
|
getLastCellPosition = function () {
|
|
return lastCellPos;
|
|
};
|
|
|
|
jsPDFAPI.setHeaderFunction = function (func) {
|
|
headerFunction = func;
|
|
};
|
|
|
|
jsPDFAPI.getTextDimensions = function (txt) {
|
|
fontName = this.internal.getFont().fontName;
|
|
fontSize = this.internal.getFontSize();
|
|
fontStyle = this.internal.getFont().fontStyle;
|
|
|
|
// 1 pixel = 0.264583 mm and 1 mm = 72/25.4 point
|
|
var px2pt = 0.264583 * 72 / 25.4,
|
|
dimensions,
|
|
text;
|
|
|
|
text = document.createElement('font');
|
|
text.id = "jsPDFCell";
|
|
text.style.fontStyle = fontStyle;
|
|
text.style.fontName = fontName;
|
|
text.style.fontSize = fontSize + 'pt';
|
|
text.innerText = txt;
|
|
|
|
document.body.appendChild(text);
|
|
|
|
dimensions = { w: (text.offsetWidth + 1) * px2pt, h: (text.offsetHeight + 1) * px2pt};
|
|
|
|
document.body.removeChild(text);
|
|
|
|
return dimensions;
|
|
};
|
|
|
|
jsPDFAPI.cellAddPage = function () {
|
|
this.addPage();
|
|
setLastCellPosition(undefined, undefined, undefined, undefined, undefined);
|
|
pages += 1;
|
|
};
|
|
|
|
jsPDFAPI.cellInitialize = function () {
|
|
lastCellPos = { x: undefined, y: undefined, w: undefined, h: undefined, ln: undefined };
|
|
pages = 1;
|
|
};
|
|
|
|
jsPDFAPI.cell = function (x, y, w, h, txt, ln, align) {
|
|
var curCell = getLastCellPosition();
|
|
|
|
// If this is not the first cell, we must change its position
|
|
if (curCell.ln !== undefined) {
|
|
|
|
if (curCell.ln === ln) {
|
|
//Same line
|
|
x = curCell.x + curCell.w;
|
|
y = curCell.y;
|
|
} else {
|
|
//New line
|
|
if ((curCell.y + curCell.h + h + margin) >= this.internal.pageSize.height) {
|
|
this.cellAddPage();
|
|
|
|
if (this.printHeaders && this.tableHeaderRow) {
|
|
this.printHeaderRow(ln);
|
|
}
|
|
}
|
|
//We ignore the passed y: the lines may have diferent heights
|
|
y = (getLastCellPosition().y + getLastCellPosition().h);
|
|
|
|
}
|
|
}
|
|
|
|
if (txt[0] !== '') {
|
|
if (this.printingHeaderRow) {
|
|
this.rect(x, y, w, h, 'FD');
|
|
} else {
|
|
this.rect(x, y, w, h);
|
|
}
|
|
if (align === 'right') {
|
|
if (txt instanceof Array) {
|
|
for(var i = 0; i<txt.length; i++) {
|
|
var currentLine = txt[i];
|
|
var textSize = this.getStringUnitWidth(currentLine) * this.internal.getFontSize();
|
|
this.text(currentLine, x + w - textSize - padding, y + this.internal.getLineHeight()*(i+1));
|
|
}
|
|
}
|
|
} else {
|
|
this.text(txt, x + padding, y + this.internal.getLineHeight());
|
|
}
|
|
}
|
|
setLastCellPosition(x, y, w, h, ln);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Return an array containing all of the owned keys of an Object
|
|
* @type {Function}
|
|
* @return {String[]} of Object keys
|
|
*/
|
|
jsPDFAPI.getKeys = (typeof Object.keys === 'function')
|
|
? function (object) {
|
|
if (!object) {
|
|
return [];
|
|
}
|
|
return Object.keys(object);
|
|
}
|
|
: function (object) {
|
|
var keys = [],
|
|
property;
|
|
|
|
for (property in object) {
|
|
if (object.hasOwnProperty(property)) {
|
|
keys.push(property);
|
|
}
|
|
}
|
|
|
|
return keys;
|
|
};
|
|
|
|
/**
|
|
* Return the maximum value from an array
|
|
* @param array
|
|
* @param comparisonFn
|
|
* @returns {*}
|
|
*/
|
|
jsPDFAPI.arrayMax = function (array, comparisonFn) {
|
|
var max = array[0],
|
|
i,
|
|
ln,
|
|
item;
|
|
|
|
for (i = 0, ln = array.length; i < ln; i += 1) {
|
|
item = array[i];
|
|
|
|
if (comparisonFn) {
|
|
if (comparisonFn(max, item) === -1) {
|
|
max = item;
|
|
}
|
|
} else {
|
|
if (item > max) {
|
|
max = item;
|
|
}
|
|
}
|
|
}
|
|
|
|
return max;
|
|
};
|
|
|
|
/**
|
|
* Create a table from a set of data.
|
|
* @param {Object[]} data As array of objects containing key-value pairs
|
|
* @param {String[]} [headers] Omit or null to auto-generate headers at a performance cost
|
|
* @param {Object} [config.printHeaders] True to print column headers at the top of every page
|
|
* @param {Object} [config.autoSize] True to dynamically set the column widths to match the widest cell value
|
|
* @param {Object} [config.autoStretch] True to force the table to fit the width of the page
|
|
*/
|
|
jsPDFAPI.table = function (data, headers, config) {
|
|
|
|
var headerNames = [],
|
|
headerPrompts = [],
|
|
header,
|
|
autoSize,
|
|
printHeaders,
|
|
autoStretch,
|
|
i,
|
|
ln,
|
|
columnMatrix = {},
|
|
columnWidths = {},
|
|
columnData,
|
|
column,
|
|
columnMinWidths = [],
|
|
j,
|
|
tableHeaderConfigs = [],
|
|
model,
|
|
jln,
|
|
func;
|
|
|
|
/**
|
|
* @property {Number} lnMod
|
|
* Keep track of the current line number modifier used when creating cells
|
|
*/
|
|
this.lnMod = 0;
|
|
|
|
if (config) {
|
|
autoSize = config.autoSize || false;
|
|
printHeaders = this.printHeaders = config.printHeaders || true;
|
|
autoStretch = config.autoStretch || true;
|
|
}
|
|
|
|
if (!data) {
|
|
throw 'No data for PDF table';
|
|
}
|
|
|
|
// Set headers
|
|
if (headers === undefined || (headers === null)) {
|
|
|
|
// No headers defined so we derive from data
|
|
headerNames = this.getKeys(data[0]);
|
|
|
|
} else if (headers[0] && (typeof headers[0] !== 'string')) {
|
|
|
|
// Split header configs into names and prompts
|
|
for (i = 0, ln = headers.length; i < ln; i += 1) {
|
|
header = headers[i];
|
|
headerNames.push(header.name);
|
|
headerPrompts.push(header.prompt);
|
|
columnWidths[header.name] = header.width;
|
|
}
|
|
|
|
} else {
|
|
headerNames = headers;
|
|
}
|
|
|
|
if (config.autoSize) {
|
|
|
|
// Create Columns Matrix
|
|
|
|
func = function (rec) {
|
|
return rec[header];
|
|
};
|
|
|
|
for (i = 0, ln = headerNames.length; i < ln; i += 1) {
|
|
header = headerNames[i];
|
|
|
|
columnMatrix[header] = data.map(
|
|
func
|
|
);
|
|
|
|
// get header width
|
|
columnMinWidths.push(this.getTextDimensions(headerPrompts[i] || header).w);
|
|
|
|
column = columnMatrix[header];
|
|
|
|
// get cell widths
|
|
for (j = 0, ln = column.length; j < ln; j += 1) {
|
|
columnData = column[j];
|
|
|
|
columnMinWidths.push(this.getTextDimensions(columnData).w);
|
|
}
|
|
|
|
// get final column width
|
|
columnWidths[header] = jsPDFAPI.arrayMax(columnMinWidths);
|
|
}
|
|
}
|
|
|
|
// -- Construct the table
|
|
|
|
if (config.printHeaders) {
|
|
var lineHeight = this.calculateLineHeight(headerNames, columnWidths, headerPrompts.length?headerPrompts:headerNames);
|
|
|
|
// Construct the header row
|
|
for (i = 0, ln = headerNames.length; i < ln; i += 1) {
|
|
header = headerNames[i];
|
|
tableHeaderConfigs.push([margin, margin, columnWidths[header], lineHeight, String(headerPrompts.length ? headerPrompts[i] : header)]);
|
|
}
|
|
|
|
// Store the table header config
|
|
this.setTableHeaderRow(tableHeaderConfigs);
|
|
|
|
// Print the header for the start of the table
|
|
this.printHeaderRow(1);
|
|
}
|
|
|
|
// Construct the data rows
|
|
for (i = 0, ln = data.length; i < ln; i += 1) {
|
|
var lineHeight;
|
|
model = data[i];
|
|
lineHeight = this.calculateLineHeight(headerNames, columnWidths, model);
|
|
|
|
for (j = 0, jln = headerNames.length; j < jln; j += 1) {
|
|
header = headerNames[j];
|
|
this.cell(margin, margin, columnWidths[header], lineHeight, model[header], i + 2, headers[j].align);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Calculate the height for containing the highest column
|
|
* @param {String[]} headerNames is the header, used as keys to the data
|
|
* @param {Integer[]} columnWidths is size of each column
|
|
* @param {Object[]} model is the line of data we want to calculate the height of
|
|
*/
|
|
jsPDFAPI.calculateLineHeight = function (headerNames, columnWidths, model) {
|
|
var header, lineHeight = 0;
|
|
for (var j = 0; j < headerNames.length; j++) {
|
|
header = headerNames[j];
|
|
model[header] = this.splitTextToSize(String(model[header]), columnWidths[header] - padding);
|
|
var h = this.internal.getLineHeight() * model[header].length + padding;
|
|
if (h > lineHeight)
|
|
lineHeight = h;
|
|
}
|
|
return lineHeight;
|
|
};
|
|
|
|
/**
|
|
* Store the config for outputting a table header
|
|
* @param {Object[]} config
|
|
* An array of cell configs that would define a header row: Each config matches the config used by jsPDFAPI.cell
|
|
* except the ln parameter is excluded
|
|
*/
|
|
jsPDFAPI.setTableHeaderRow = function (config) {
|
|
this.tableHeaderRow = config;
|
|
};
|
|
|
|
/**
|
|
* Output the store header row
|
|
* @param lineNumber The line number to output the header at
|
|
*/
|
|
jsPDFAPI.printHeaderRow = function (lineNumber) {
|
|
if (!this.tableHeaderRow) {
|
|
throw 'Property tableHeaderRow does not exist.';
|
|
}
|
|
|
|
var tableHeaderCell,
|
|
tmpArray,
|
|
i,
|
|
ln;
|
|
|
|
this.printingHeaderRow = true;
|
|
if (headerFunction !== undefined) {
|
|
var position = headerFunction(this, pages);
|
|
setLastCellPosition(position[0], position[1], position[2], position[3], -1);
|
|
}
|
|
|
|
this.setFontStyle('bold');
|
|
for (i = 0, ln = this.tableHeaderRow.length; i < ln; i += 1) {
|
|
this.setFillColor(200,200,200);
|
|
|
|
tableHeaderCell = this.tableHeaderRow[i];
|
|
tmpArray = [].concat(tableHeaderCell);
|
|
|
|
this.cell.apply(this, tmpArray.concat(lineNumber));
|
|
}
|
|
this.setFontStyle('normal');
|
|
this.printingHeaderRow = false;
|
|
};
|
|
|
|
})(jsPDF.API);
|