mirror of
https://github.com/qpdf/qpdf.git
synced 2024-06-04 03:10:52 +00:00
f78ea057ca
Instead of directly putting the contents of the annotation appearance streams into the page's content stream, add commands to render the form xobjects directly. This is a more robust way to do it than the original solution as it works properly with patterns and avoids problems with resource name clashes between the pages and the form xobjects.
277 lines
9.7 KiB
C++
277 lines
9.7 KiB
C++
#include <qpdf/QPDFAnnotationObjectHelper.hh>
|
|
#include <qpdf/QTC.hh>
|
|
#include <qpdf/QPDFMatrix.hh>
|
|
#include <qpdf/QUtil.hh>
|
|
#include <qpdf/QPDF.hh>
|
|
#include <qpdf/QPDFNameTreeObjectHelper.hh>
|
|
#include <algorithm>
|
|
|
|
QPDFAnnotationObjectHelper::Members::~Members()
|
|
{
|
|
}
|
|
|
|
QPDFAnnotationObjectHelper::Members::Members()
|
|
{
|
|
}
|
|
|
|
QPDFAnnotationObjectHelper::QPDFAnnotationObjectHelper(QPDFObjectHandle oh) :
|
|
QPDFObjectHelper(oh)
|
|
{
|
|
}
|
|
|
|
std::string
|
|
QPDFAnnotationObjectHelper::getSubtype()
|
|
{
|
|
return this->oh.getKey("/Subtype").getName();
|
|
}
|
|
|
|
QPDFObjectHandle::Rectangle
|
|
QPDFAnnotationObjectHelper::getRect()
|
|
{
|
|
return this->oh.getKey("/Rect").getArrayAsRectangle();
|
|
}
|
|
|
|
QPDFObjectHandle
|
|
QPDFAnnotationObjectHelper::getAppearanceDictionary()
|
|
{
|
|
return this->oh.getKey("/AP");
|
|
}
|
|
|
|
std::string
|
|
QPDFAnnotationObjectHelper::getAppearanceState()
|
|
{
|
|
if (this->oh.getKey("/AS").isName())
|
|
{
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AS present");
|
|
return this->oh.getKey("/AS").getName();
|
|
}
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AS absent");
|
|
return "";
|
|
}
|
|
|
|
QPDFObjectHandle
|
|
QPDFAnnotationObjectHelper::getAppearanceStream(
|
|
std::string const& which,
|
|
std::string const& state)
|
|
{
|
|
QPDFObjectHandle ap = getAppearanceDictionary();
|
|
std::string desired_state = state.empty() ? getAppearanceState() : state;
|
|
if (ap.isDictionary())
|
|
{
|
|
QPDFObjectHandle ap_sub = ap.getKey(which);
|
|
if (ap_sub.isStream() && desired_state.empty())
|
|
{
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AP stream");
|
|
return ap_sub;
|
|
}
|
|
if (ap_sub.isDictionary() && (! desired_state.empty()))
|
|
{
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AP dictionary");
|
|
QPDFObjectHandle ap_sub_val = ap_sub.getKey(desired_state);
|
|
if (ap_sub_val.isStream())
|
|
{
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AN sub stream");
|
|
return ap_sub_val;
|
|
}
|
|
}
|
|
}
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AN null");
|
|
return QPDFObjectHandle::newNull();
|
|
}
|
|
|
|
std::string
|
|
QPDFAnnotationObjectHelper::getPageContentForAppearance(
|
|
std::string const& name, int rotate)
|
|
{
|
|
if (! getAppearanceStream("/N").isStream())
|
|
{
|
|
return "";
|
|
}
|
|
|
|
// The appearance matrix computed by this method is the
|
|
// transformation matrix that needs to be in effect when drawing
|
|
// this annotation's appearance stream on the page. The algorithm
|
|
// for computing the appearance matrix described in section 12.5.5
|
|
// of the ISO-32000 PDF spec is similar but not identical to what
|
|
// we are doing here.
|
|
|
|
// When rendering an appearance stream associated with an
|
|
// annotation, there are four relevant components:
|
|
//
|
|
// * The appearance stream's bounding box (/BBox)
|
|
// * The appearance stream's matrix (/Matrix)
|
|
// * The annotation's rectangle (/Rect)
|
|
// * In the case of form fields with the NoRotate flag, the
|
|
// page's rotation
|
|
|
|
// When rendering a form xobject in isolation, just drawn with a
|
|
// /Do operator, the is no form field, so page rotation is not
|
|
// relevant, and there is no annotation, so /Rect is not relevant,
|
|
// so only /BBox and /Matrix are relevant. The effect of these are
|
|
// as follows:
|
|
|
|
// * /BBox is treated as a clipping region
|
|
// * /Matrix is applied as a transformation prior to rendering the
|
|
// appearance stream.
|
|
|
|
// There is no relationship between /BBox and /Matrix in this
|
|
// case.
|
|
|
|
// When rendering a form xobject in the context of an annotation,
|
|
// things are a little different. In particular, a matrix is
|
|
// established such that /BBox, when transformed by /Matrix, would
|
|
// fit completely inside of /Rect. /BBox is no longer a clipping
|
|
// region. To illustrate the difference, consider a /Matrix of
|
|
// [2 0 0 2 0 0], which is scaling by a factor of two along both
|
|
// axes. If the appearance stream drew a rectangle equal to /BBox,
|
|
// in the case of the form xobject in isolation, this matrix would
|
|
// cause only the lower-left quadrant of the rectangle to be
|
|
// visible since the scaling would cause the rest of it to fall
|
|
// outside of the clipping region. In the case of the form xobject
|
|
// displayed in the context of an annotation, such a matrix would
|
|
// have no effect at all because it would be applied to the
|
|
// bounding box first, and then when the resulting enclosing
|
|
// quadrilateral was transformed to fit into /Rect, the effect of
|
|
// the scaling would be undone.
|
|
|
|
// Our job is to create a transformation matrix that compensates
|
|
// for these differences so that the appearance stream of an
|
|
// annotation can be drawn as a regular form xobject.
|
|
|
|
// To do this, we perform the following steps, which overlap
|
|
// significantly with the algorithm in 12.5.5:
|
|
|
|
// 1. Transform the four corners of /BBox by applying /Matrix to
|
|
// them, creating an arbitrarily transformed quadrilateral.
|
|
|
|
// 2. Find the minimum upright rectangle that encompasses the
|
|
// resulting quadrilateral. This is the "transformed appearance
|
|
// box", T.
|
|
|
|
// 3. Compute matrix A that maps the lower left and upper right
|
|
// corners of T to the annotation's /Rect. This can be done by
|
|
// scaling so that the sizes match and translating so that the
|
|
// scaled T exactly overlaps /Rect.
|
|
|
|
// If the annotation's /F flag has bit 4 set, this means that
|
|
// annotation is to be rotated about its upper left corner to
|
|
// counteract any rotation of the page so it remains upright. To
|
|
// achieve this effect, we do the following extra steps:
|
|
|
|
// 1. Perform the rotation on /BBox box prior to transforming it
|
|
// with /Matrix (by replacing matrix with concatenation of
|
|
// matrix onto the rotation)
|
|
|
|
// 2. Rotate the destination rectangle by the specified amount
|
|
|
|
// 3. Apply the rotation to A as computed above to get the final
|
|
// appearance matrix.
|
|
|
|
QPDFObjectHandle rect_obj = this->oh.getKey("/Rect");
|
|
QPDFObjectHandle flags = this->oh.getKey("/F");
|
|
QPDFObjectHandle as = getAppearanceStream("/N").getDict();
|
|
QPDFObjectHandle bbox_obj = as.getKey("/BBox");
|
|
QPDFObjectHandle matrix_obj = as.getKey("/Matrix");
|
|
|
|
if (! (bbox_obj.isRectangle() && rect_obj.isRectangle()))
|
|
{
|
|
return "";
|
|
}
|
|
QPDFMatrix matrix;
|
|
if (matrix_obj.isMatrix())
|
|
{
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper explicit matrix");
|
|
matrix = QPDFMatrix(matrix_obj.getArrayAsMatrix());
|
|
}
|
|
else
|
|
{
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper default matrix");
|
|
}
|
|
QPDFObjectHandle::Rectangle rect = rect_obj.getArrayAsRectangle();
|
|
bool do_rotate = (rotate && flags.isInteger() &&
|
|
(flags.getIntValue() & 16));
|
|
if (do_rotate)
|
|
{
|
|
// If the the annotation flags include the NoRotate bit and
|
|
// the page is rotated, we have to rotate the annotation about
|
|
// its upper left corner by the same amount in the opposite
|
|
// direction so that it will remain upright in absolute
|
|
// coordinates. Since the semantics of /Rotate for a page are
|
|
// to rotate the page, while the effect of rotating using a
|
|
// transformation matrix is to rotate the coordinate system,
|
|
// the opposite directionality is explicit in the code.
|
|
QPDFMatrix mr;
|
|
mr.rotatex90(rotate);
|
|
mr.concat(matrix);
|
|
matrix = mr;
|
|
double rect_w = rect.urx - rect.llx;
|
|
double rect_h = rect.ury - rect.lly;
|
|
switch (rotate)
|
|
{
|
|
case 90:
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper rotate 90");
|
|
rect = QPDFObjectHandle::Rectangle(
|
|
rect.llx,
|
|
rect.ury,
|
|
rect.llx + rect_h,
|
|
rect.ury + rect_w);
|
|
break;
|
|
case 180:
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper rotate 180");
|
|
rect = QPDFObjectHandle::Rectangle(
|
|
rect.llx - rect_w,
|
|
rect.ury,
|
|
rect.llx,
|
|
rect.ury + rect_h);
|
|
break;
|
|
case 270:
|
|
QTC::TC("qpdf", "QPDFAnnotationObjectHelper rotate 270");
|
|
rect = QPDFObjectHandle::Rectangle(
|
|
rect.llx - rect_h,
|
|
rect.ury - rect_w,
|
|
rect.llx,
|
|
rect.ury);
|
|
break;
|
|
default:
|
|
// ignore
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Transform bounding box by matrix to get T
|
|
QPDFObjectHandle::Rectangle bbox = bbox_obj.getArrayAsRectangle();
|
|
std::vector<double> bx(4);
|
|
std::vector<double> by(4);
|
|
matrix.transform(bbox.llx, bbox.lly, bx.at(0), by.at(0));
|
|
matrix.transform(bbox.llx, bbox.ury, bx.at(1), by.at(1));
|
|
matrix.transform(bbox.urx, bbox.lly, bx.at(2), by.at(2));
|
|
matrix.transform(bbox.urx, bbox.ury, bx.at(3), by.at(3));
|
|
// Find the transformed appearance box
|
|
double t_llx = *std::min_element(bx.begin(), bx.end());
|
|
double t_urx = *std::max_element(bx.begin(), bx.end());
|
|
double t_lly = *std::min_element(by.begin(), by.end());
|
|
double t_ury = *std::max_element(by.begin(), by.end());
|
|
if ((t_urx == t_llx) || (t_ury == t_lly))
|
|
{
|
|
// avoid division by zero
|
|
return "";
|
|
}
|
|
// Compute a matrix to transform the appearance box to the rectangle
|
|
QPDFMatrix AA;
|
|
AA.translate(rect.llx, rect.lly);
|
|
AA.scale((rect.urx - rect.llx) / (t_urx - t_llx),
|
|
(rect.ury - rect.lly) / (t_ury - t_lly));
|
|
AA.translate(-t_llx, -t_lly);
|
|
if (do_rotate)
|
|
{
|
|
AA.rotatex90(rotate);
|
|
}
|
|
|
|
as.replaceKey("/Subtype", QPDFObjectHandle::newName("/Form"));
|
|
return (
|
|
"q\n" +
|
|
AA.unparse() + " cm\n" +
|
|
name + " Do\n" +
|
|
"Q\n");
|
|
}
|