267 lines
8.9 KiB
TypeScript
267 lines
8.9 KiB
TypeScript
import PDFDocument from 'src/api/PDFDocument';
|
|
import PDFPage from 'src/api/PDFPage';
|
|
import PDFFont from 'src/api/PDFFont';
|
|
import PDFImage from 'src/api/PDFImage';
|
|
import { ImageAlignment } from 'src/api/image/alignment';
|
|
import {
|
|
AppearanceProviderFor,
|
|
normalizeAppearance,
|
|
defaultButtonAppearanceProvider,
|
|
} from 'src/api/form/appearances';
|
|
import PDFField, {
|
|
FieldAppearanceOptions,
|
|
assertFieldAppearanceOptions,
|
|
} from 'src/api/form/PDFField';
|
|
import { rgb } from 'src/api/colors';
|
|
import { degrees } from 'src/api/rotations';
|
|
|
|
import {
|
|
PDFRef,
|
|
PDFStream,
|
|
PDFAcroPushButton,
|
|
PDFWidgetAnnotation,
|
|
} from 'src/core';
|
|
import { assertIs, assertOrUndefined, assertPositive } from 'src/utils';
|
|
|
|
/**
|
|
* Represents a button field of a [[PDFForm]].
|
|
*
|
|
* [[PDFButton]] fields are interactive controls that users can click with their
|
|
* mouse. This type of [[PDFField]] is not stateful. The purpose of a button
|
|
* is to perform an action when the user clicks on it, such as opening a print
|
|
* modal or resetting the form. Buttons are typically rectangular in shape and
|
|
* have a text label describing the action that they perform when clicked.
|
|
*/
|
|
export default class PDFButton extends PDFField {
|
|
/**
|
|
* > **NOTE:** You probably don't want to call this method directly. Instead,
|
|
* > consider using the [[PDFForm.getButton]] method, which will create an
|
|
* > instance of [[PDFButton]] for you.
|
|
*
|
|
* Create an instance of [[PDFButton]] from an existing acroPushButton and ref
|
|
*
|
|
* @param acroPushButton The underlying `PDFAcroPushButton` for this button.
|
|
* @param ref The unique reference for this button.
|
|
* @param doc The document to which this button will belong.
|
|
*/
|
|
static of = (
|
|
acroPushButton: PDFAcroPushButton,
|
|
ref: PDFRef,
|
|
doc: PDFDocument,
|
|
) => new PDFButton(acroPushButton, ref, doc);
|
|
|
|
/** The low-level PDFAcroPushButton wrapped by this button. */
|
|
readonly acroField: PDFAcroPushButton;
|
|
|
|
private constructor(
|
|
acroPushButton: PDFAcroPushButton,
|
|
ref: PDFRef,
|
|
doc: PDFDocument,
|
|
) {
|
|
super(acroPushButton, ref, doc);
|
|
|
|
assertIs(acroPushButton, 'acroButton', [
|
|
[PDFAcroPushButton, 'PDFAcroPushButton'],
|
|
]);
|
|
|
|
this.acroField = acroPushButton;
|
|
}
|
|
|
|
/**
|
|
* Display an image inside the bounds of this button's widgets. For example:
|
|
* ```js
|
|
* const pngImage = await pdfDoc.embedPng(...)
|
|
* const button = form.getButton('some.button.field')
|
|
* button.setImage(pngImage, ImageAlignment.Center)
|
|
* ```
|
|
* This will update the appearances streams for each of this button's widgets.
|
|
* @param image The image that should be displayed.
|
|
* @param alignment The alignment of the image.
|
|
*/
|
|
setImage(image: PDFImage, alignment = ImageAlignment.Center) {
|
|
const widgets = this.acroField.getWidgets();
|
|
for (let idx = 0, len = widgets.length; idx < len; idx++) {
|
|
const widget = widgets[idx];
|
|
const streamRef = this.createImageAppearanceStream(
|
|
widget,
|
|
image,
|
|
alignment,
|
|
);
|
|
this.updateWidgetAppearances(widget, { normal: streamRef });
|
|
}
|
|
|
|
this.markAsClean();
|
|
}
|
|
|
|
/**
|
|
* Set the font size for this field. Larger font sizes will result in larger
|
|
* text being displayed when PDF readers render this button. Font sizes may
|
|
* be integer or floating point numbers. Supplying a negative font size will
|
|
* cause this method to throw an error.
|
|
*
|
|
* For example:
|
|
* ```js
|
|
* const button = form.getButton('some.button.field')
|
|
* button.setFontSize(4)
|
|
* button.setFontSize(15.7)
|
|
* ```
|
|
*
|
|
* > This method depends upon the existence of a default appearance
|
|
* > (`/DA`) string. If this field does not have a default appearance string,
|
|
* > or that string does not contain a font size (via the `Tf` operator),
|
|
* > then this method will throw an error.
|
|
*
|
|
* @param fontSize The font size to be used when rendering text in this field.
|
|
*/
|
|
setFontSize(fontSize: number) {
|
|
assertPositive(fontSize, 'fontSize');
|
|
this.acroField.setFontSize(fontSize);
|
|
this.markAsDirty();
|
|
}
|
|
|
|
/**
|
|
* Show this button on the specified page with the given text. For example:
|
|
* ```js
|
|
* const ubuntuFont = await pdfDoc.embedFont(ubuntuFontBytes)
|
|
* const page = pdfDoc.addPage()
|
|
*
|
|
* const form = pdfDoc.getForm()
|
|
* const button = form.createButton('some.button.field')
|
|
*
|
|
* button.addToPage('Do Stuff', page, {
|
|
* x: 50,
|
|
* y: 75,
|
|
* width: 200,
|
|
* height: 100,
|
|
* textColor: rgb(1, 0, 0),
|
|
* backgroundColor: rgb(0, 1, 0),
|
|
* borderColor: rgb(0, 0, 1),
|
|
* borderWidth: 2,
|
|
* rotate: degrees(90),
|
|
* font: ubuntuFont,
|
|
* })
|
|
* ```
|
|
* This will create a new widget for this button field.
|
|
* @param text The text to be displayed for this button widget.
|
|
* @param page The page to which this button widget should be added.
|
|
* @param options The options to be used when adding this button widget.
|
|
*/
|
|
addToPage(
|
|
// TODO: This needs to be optional, e.g. for image buttons
|
|
text: string,
|
|
page: PDFPage,
|
|
options?: FieldAppearanceOptions,
|
|
) {
|
|
assertOrUndefined(text, 'text', ['string']);
|
|
assertOrUndefined(page, 'page', [[PDFPage, 'PDFPage']]);
|
|
assertFieldAppearanceOptions(options);
|
|
|
|
// Create a widget for this button
|
|
const widget = this.createWidget({
|
|
x: (options?.x ?? 0) - (options?.borderWidth ?? 0) / 2,
|
|
y: (options?.y ?? 0) - (options?.borderWidth ?? 0) / 2,
|
|
width: options?.width ?? 100,
|
|
height: options?.height ?? 50,
|
|
textColor: options?.textColor ?? rgb(0, 0, 0),
|
|
backgroundColor: options?.backgroundColor ?? rgb(0.75, 0.75, 0.75),
|
|
borderColor: options?.borderColor,
|
|
borderWidth: options?.borderWidth ?? 0,
|
|
rotate: options?.rotate ?? degrees(0),
|
|
caption: text,
|
|
hidden: options?.hidden,
|
|
page: page.ref,
|
|
});
|
|
const widgetRef = this.doc.context.register(widget.dict);
|
|
|
|
// Add widget to this field
|
|
this.acroField.addWidget(widgetRef);
|
|
|
|
// Set appearance streams for widget
|
|
const font = options?.font ?? this.doc.getForm().getDefaultFont();
|
|
this.updateWidgetAppearance(widget, font);
|
|
|
|
// Add widget to the given page
|
|
page.node.addAnnot(widgetRef);
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if this button has been marked as dirty, or if any of this
|
|
* button's widgets do not have an appearance stream. For example:
|
|
* ```js
|
|
* const button = form.getButton('some.button.field')
|
|
* if (button.needsAppearancesUpdate()) console.log('Needs update')
|
|
* ```
|
|
* @returns Whether or not this button needs an appearance update.
|
|
*/
|
|
needsAppearancesUpdate(): boolean {
|
|
if (this.isDirty()) return true;
|
|
|
|
const widgets = this.acroField.getWidgets();
|
|
for (let idx = 0, len = widgets.length; idx < len; idx++) {
|
|
const widget = widgets[idx];
|
|
const hasAppearances =
|
|
widget.getAppearances()?.normal instanceof PDFStream;
|
|
if (!hasAppearances) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Update the appearance streams for each of this button's widgets using
|
|
* the default appearance provider for buttons. For example:
|
|
* ```js
|
|
* const helvetica = await pdfDoc.embedFont(StandardFonts.Helvetica)
|
|
* const button = form.getButton('some.button.field')
|
|
* button.defaultUpdateAppearances(helvetica)
|
|
* ```
|
|
* @param font The font to be used for creating the appearance streams.
|
|
*/
|
|
defaultUpdateAppearances(font: PDFFont) {
|
|
assertIs(font, 'font', [[PDFFont, 'PDFFont']]);
|
|
this.updateAppearances(font);
|
|
}
|
|
|
|
/**
|
|
* Update the appearance streams for each of this button's widgets using
|
|
* the given appearance provider. If no `provider` is passed, the default
|
|
* appearance provider for buttons will be used. For example:
|
|
* ```js
|
|
* const helvetica = await pdfDoc.embedFont(StandardFonts.Helvetica)
|
|
* const button = form.getButton('some.button.field')
|
|
* button.updateAppearances(helvetica, (field, widget, font) => {
|
|
* ...
|
|
* return {
|
|
* normal: drawButton(...),
|
|
* down: drawButton(...),
|
|
* }
|
|
* })
|
|
* ```
|
|
* @param font The font to be used for creating the appearance streams.
|
|
* @param provider Optionally, the appearance provider to be used for
|
|
* generating the contents of the appearance streams.
|
|
*/
|
|
updateAppearances(
|
|
font: PDFFont,
|
|
provider?: AppearanceProviderFor<PDFButton>,
|
|
) {
|
|
assertIs(font, 'font', [[PDFFont, 'PDFFont']]);
|
|
assertOrUndefined(provider, 'provider', [Function]);
|
|
|
|
const widgets = this.acroField.getWidgets();
|
|
for (let idx = 0, len = widgets.length; idx < len; idx++) {
|
|
const widget = widgets[idx];
|
|
this.updateWidgetAppearance(widget, font, provider);
|
|
}
|
|
}
|
|
|
|
private updateWidgetAppearance(
|
|
widget: PDFWidgetAnnotation,
|
|
font: PDFFont,
|
|
provider?: AppearanceProviderFor<PDFButton>,
|
|
) {
|
|
const apProvider = provider ?? defaultButtonAppearanceProvider;
|
|
const appearances = normalizeAppearance(apProvider(this, widget, font));
|
|
this.updateWidgetAppearanceWithFont(widget, font, appearances);
|
|
}
|
|
}
|