remove vclmetafileprocessor2d.{cxx,hxx} from clang-format blacklist
Change-Id: I53f7660a22ed66ab7d50370d871f9d10d1bedc10
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/93825
Tested-by: Jenkins
Reviewed-by: Tomaž Vajngerl <quikee@gmail.com>
diff --git a/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx b/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
index d853820..231bf8b 100644
--- a/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
@@ -76,2216 +76,2242 @@ using namespace com::sun::star;
// To be on the safe side with the old tools polygon, use slightly less than
// the theoretical maximum (bad experiences with tools polygon)
#define MAX_POLYGON_POINT_COUNT_METAFILE (0x0000fff0)
#define MAX_POLYGON_POINT_COUNT_METAFILE (0x0000fff0)
namespace
{
// #112245# helper to split line polygon in half
void splitLinePolygon(
const basegfx::B2DPolygon& rBasePolygon,
basegfx::B2DPolygon& o_aLeft,
basegfx::B2DPolygon& o_aRight)
// #112245# helper to split line polygon in half
void splitLinePolygon(const basegfx::B2DPolygon& rBasePolygon, basegfx::B2DPolygon& o_aLeft,
basegfx::B2DPolygon& o_aRight)
{
const sal_uInt32 nCount(rBasePolygon.count());
if (nCount)
{
const sal_uInt32 nCount(rBasePolygon.count());
const sal_uInt32 nHalfCount((nCount - 1) >> 1);
if(nCount)
o_aLeft = basegfx::B2DPolygon(rBasePolygon, 0, nHalfCount + 1);
o_aLeft.setClosed(false);
o_aRight = basegfx::B2DPolygon(rBasePolygon, nHalfCount, nCount - nHalfCount);
o_aRight.setClosed(false);
if (rBasePolygon.isClosed())
{
const sal_uInt32 nHalfCount((nCount - 1) >> 1);
o_aRight.append(rBasePolygon.getB2DPoint(0));
o_aLeft = basegfx::B2DPolygon(rBasePolygon, 0, nHalfCount + 1);
o_aLeft.setClosed(false);
o_aRight = basegfx::B2DPolygon(rBasePolygon, nHalfCount, nCount - nHalfCount);
o_aRight.setClosed(false);
if(rBasePolygon.isClosed())
if (rBasePolygon.areControlPointsUsed())
{
o_aRight.append(rBasePolygon.getB2DPoint(0));
o_aRight.setControlPoints(o_aRight.count() - 1, rBasePolygon.getPrevControlPoint(0),
rBasePolygon.getNextControlPoint(0));
}
}
}
else
{
o_aLeft.clear();
o_aRight.clear();
}
}
if(rBasePolygon.areControlPointsUsed())
{
o_aRight.setControlPoints(
o_aRight.count() - 1,
rBasePolygon.getPrevControlPoint(0),
rBasePolygon.getNextControlPoint(0));
}
// #112245# helper to evtl. split filled polygons to maximum metafile point count
void fillPolyPolygonNeededToBeSplit(basegfx::B2DPolyPolygon& rPolyPolygon)
{
const sal_uInt32 nPolyCount(rPolyPolygon.count());
if (!nPolyCount)
return;
basegfx::B2DPolyPolygon aSplitted;
for (sal_uInt32 a(0); a < nPolyCount; a++)
{
const basegfx::B2DPolygon& aCandidate(rPolyPolygon.getB2DPolygon(a));
const sal_uInt32 nPointCount(aCandidate.count());
bool bNeedToSplit(false);
if (aCandidate.areControlPointsUsed())
{
// compare with the maximum for bezier curved polygons
bNeedToSplit = nPointCount > ((MAX_POLYGON_POINT_COUNT_METAFILE / 3L) - 1);
}
else
{
// compare with the maximum for simple point polygons
bNeedToSplit = nPointCount > (MAX_POLYGON_POINT_COUNT_METAFILE - 1);
}
if (bNeedToSplit)
{
// need to split the partial polygon
const basegfx::B2DRange aRange(aCandidate.getB2DRange());
const basegfx::B2DPoint aCenter(aRange.getCenter());
if (aRange.getWidth() > aRange.getHeight())
{
// clip in left and right
const basegfx::B2DPolyPolygon aLeft(basegfx::utils::clipPolygonOnParallelAxis(
aCandidate, false, true, aCenter.getX(), false));
const basegfx::B2DPolyPolygon aRight(basegfx::utils::clipPolygonOnParallelAxis(
aCandidate, false, false, aCenter.getX(), false));
aSplitted.append(aLeft);
aSplitted.append(aRight);
}
else
{
// clip in top and bottom
const basegfx::B2DPolyPolygon aTop(basegfx::utils::clipPolygonOnParallelAxis(
aCandidate, true, true, aCenter.getY(), false));
const basegfx::B2DPolyPolygon aBottom(basegfx::utils::clipPolygonOnParallelAxis(
aCandidate, true, false, aCenter.getY(), false));
aSplitted.append(aTop);
aSplitted.append(aBottom);
}
}
else
{
o_aLeft.clear();
o_aRight.clear();
aSplitted.append(aCandidate);
}
}
// #112245# helper to evtl. split filled polygons to maximum metafile point count
void fillPolyPolygonNeededToBeSplit(basegfx::B2DPolyPolygon& rPolyPolygon)
if (aSplitted.count() != nPolyCount)
{
const sal_uInt32 nPolyCount(rPolyPolygon.count());
if(!nPolyCount)
return;
basegfx::B2DPolyPolygon aSplitted;
for(sal_uInt32 a(0); a < nPolyCount; a++)
{
const basegfx::B2DPolygon& aCandidate(rPolyPolygon.getB2DPolygon(a));
const sal_uInt32 nPointCount(aCandidate.count());
bool bNeedToSplit(false);
if(aCandidate.areControlPointsUsed())
{
// compare with the maximum for bezier curved polygons
bNeedToSplit = nPointCount > ((MAX_POLYGON_POINT_COUNT_METAFILE / 3L) - 1);
}
else
{
// compare with the maximum for simple point polygons
bNeedToSplit = nPointCount > (MAX_POLYGON_POINT_COUNT_METAFILE - 1);
}
if(bNeedToSplit)
{
// need to split the partial polygon
const basegfx::B2DRange aRange(aCandidate.getB2DRange());
const basegfx::B2DPoint aCenter(aRange.getCenter());
if(aRange.getWidth() > aRange.getHeight())
{
// clip in left and right
const basegfx::B2DPolyPolygon aLeft(
basegfx::utils::clipPolygonOnParallelAxis(
aCandidate,
false,
true,
aCenter.getX(),
false));
const basegfx::B2DPolyPolygon aRight(
basegfx::utils::clipPolygonOnParallelAxis(
aCandidate,
false,
false,
aCenter.getX(),
false));
aSplitted.append(aLeft);
aSplitted.append(aRight);
}
else
{
// clip in top and bottom
const basegfx::B2DPolyPolygon aTop(
basegfx::utils::clipPolygonOnParallelAxis(
aCandidate,
true,
true,
aCenter.getY(),
false));
const basegfx::B2DPolyPolygon aBottom(
basegfx::utils::clipPolygonOnParallelAxis(
aCandidate,
true,
false,
aCenter.getY(),
false));
aSplitted.append(aTop);
aSplitted.append(aBottom);
}
}
else
{
aSplitted.append(aCandidate);
}
}
if(aSplitted.count() != nPolyCount)
{
rPolyPolygon = aSplitted;
}
rPolyPolygon = aSplitted;
}
}
/** Filter input polypolygon for effectively empty sub-fills
/** Filter input polypolygon for effectively empty sub-fills
Needed to fix fdo#37559
Needed to fix fdo#37559
@param rPoly
tools::PolyPolygon to filter
@param rPoly
tools::PolyPolygon to filter
@return converted tools PolyPolygon, w/o one-point fills
*/
::tools::PolyPolygon getFillPolyPolygon( const ::basegfx::B2DPolyPolygon& rPoly )
@return converted tools PolyPolygon, w/o one-point fills
*/
tools::PolyPolygon getFillPolyPolygon(const ::basegfx::B2DPolyPolygon& rPoly)
{
// filter input rPoly
basegfx::B2DPolyPolygon aPoly;
sal_uInt32 nCount(rPoly.count());
for (sal_uInt32 i = 0; i < nCount; ++i)
{
// filter input rPoly
basegfx::B2DPolyPolygon aPoly;
sal_uInt32 nCount(rPoly.count());
for( sal_uInt32 i=0; i<nCount; ++i )
{
const basegfx::B2DPolygon& aCandidate(rPoly.getB2DPolygon(i));
if( !aCandidate.isClosed() || aCandidate.count() > 1 )
aPoly.append(aCandidate);
}
return ::tools::PolyPolygon(aPoly);
const basegfx::B2DPolygon& aCandidate(rPoly.getB2DPolygon(i));
if (!aCandidate.isClosed() || aCandidate.count() > 1)
aPoly.append(aCandidate);
}
return tools::PolyPolygon(aPoly);
}
} // end of anonymous namespace
namespace drawinglayer::processor2d
{
::tools::Rectangle VclMetafileProcessor2D::impDumpToMetaFile(
const primitive2d::Primitive2DContainer& rContent,
GDIMetaFile& o_rContentMetafile)
tools::Rectangle
VclMetafileProcessor2D::impDumpToMetaFile(const primitive2d::Primitive2DContainer& rContent,
GDIMetaFile& o_rContentMetafile)
{
// Prepare VDev, MetaFile and connections
OutputDevice* pLastOutputDevice = mpOutputDevice;
GDIMetaFile* pLastMetafile = mpMetaFile;
basegfx::B2DRange aPrimitiveRange(rContent.getB2DRange(getViewInformation2D()));
// transform primitive range with current transformation (e.g shadow offset)
aPrimitiveRange.transform(maCurrentTransformation);
const tools::Rectangle aPrimitiveRectangle(
basegfx::fround(aPrimitiveRange.getMinX()), basegfx::fround(aPrimitiveRange.getMinY()),
basegfx::fround(aPrimitiveRange.getMaxX()), basegfx::fround(aPrimitiveRange.getMaxY()));
ScopedVclPtrInstance<VirtualDevice> aContentVDev;
MapMode aNewMapMode(pLastOutputDevice->GetMapMode());
mpOutputDevice = aContentVDev.get();
mpMetaFile = &o_rContentMetafile;
aContentVDev->EnableOutput(false);
aContentVDev->SetMapMode(pLastOutputDevice->GetMapMode());
o_rContentMetafile.Record(aContentVDev.get());
aContentVDev->SetLineColor(pLastOutputDevice->GetLineColor());
aContentVDev->SetFillColor(pLastOutputDevice->GetFillColor());
aContentVDev->SetFont(pLastOutputDevice->GetFont());
aContentVDev->SetDrawMode(pLastOutputDevice->GetDrawMode());
aContentVDev->SetSettings(pLastOutputDevice->GetSettings());
aContentVDev->SetRefPoint(pLastOutputDevice->GetRefPoint());
// dump to MetaFile
process(rContent);
// cleanups
o_rContentMetafile.Stop();
o_rContentMetafile.WindStart();
aNewMapMode.SetOrigin(aPrimitiveRectangle.TopLeft());
o_rContentMetafile.SetPrefMapMode(aNewMapMode);
o_rContentMetafile.SetPrefSize(aPrimitiveRectangle.GetSize());
mpOutputDevice = pLastOutputDevice;
mpMetaFile = pLastMetafile;
return aPrimitiveRectangle;
}
void VclMetafileProcessor2D::impConvertFillGradientAttributeToVCLGradient(
Gradient& o_rVCLGradient, const attribute::FillGradientAttribute& rFiGrAtt,
bool bIsTransparenceGradient) const
{
if (bIsTransparenceGradient)
{
// it's about transparence channel intensities (black/white), do not use color modifier
o_rVCLGradient.SetStartColor(Color(rFiGrAtt.getStartColor()));
o_rVCLGradient.SetEndColor(Color(rFiGrAtt.getEndColor()));
}
else
{
// use color modifier to influence start/end color of gradient
o_rVCLGradient.SetStartColor(
Color(maBColorModifierStack.getModifiedColor(rFiGrAtt.getStartColor())));
o_rVCLGradient.SetEndColor(
Color(maBColorModifierStack.getModifiedColor(rFiGrAtt.getEndColor())));
}
o_rVCLGradient.SetAngle(static_cast<sal_uInt16>(rFiGrAtt.getAngle() * (1.0 / F_PI1800)));
o_rVCLGradient.SetBorder(static_cast<sal_uInt16>(rFiGrAtt.getBorder() * 100.0));
o_rVCLGradient.SetOfsX(static_cast<sal_uInt16>(rFiGrAtt.getOffsetX() * 100.0));
o_rVCLGradient.SetOfsY(static_cast<sal_uInt16>(rFiGrAtt.getOffsetY() * 100.0));
o_rVCLGradient.SetSteps(rFiGrAtt.getSteps());
// defaults for intensity; those were computed into the start/end colors already
o_rVCLGradient.SetStartIntensity(100);
o_rVCLGradient.SetEndIntensity(100);
switch (rFiGrAtt.getStyle())
{
default: // attribute::GradientStyle::Linear :
{
// Prepare VDev, MetaFile and connections
OutputDevice* pLastOutputDevice = mpOutputDevice;
GDIMetaFile* pLastMetafile = mpMetaFile;
basegfx::B2DRange aPrimitiveRange(rContent.getB2DRange(getViewInformation2D()));
o_rVCLGradient.SetStyle(GradientStyle::Linear);
break;
}
case attribute::GradientStyle::Axial:
{
o_rVCLGradient.SetStyle(GradientStyle::Axial);
break;
}
case attribute::GradientStyle::Radial:
{
o_rVCLGradient.SetStyle(GradientStyle::Radial);
break;
}
case attribute::GradientStyle::Elliptical:
{
o_rVCLGradient.SetStyle(GradientStyle::Elliptical);
break;
}
case attribute::GradientStyle::Square:
{
o_rVCLGradient.SetStyle(GradientStyle::Square);
break;
}
case attribute::GradientStyle::Rect:
{
o_rVCLGradient.SetStyle(GradientStyle::Rect);
break;
}
}
}
// transform primitive range with current transformation (e.g shadow offset)
aPrimitiveRange.transform(maCurrentTransformation);
void VclMetafileProcessor2D::impStartSvtGraphicFill(SvtGraphicFill const* pSvtGraphicFill)
{
if (pSvtGraphicFill && !mnSvtGraphicFillCount)
{
SvMemoryStream aMemStm;
const ::tools::Rectangle aPrimitiveRectangle(
basegfx::fround(aPrimitiveRange.getMinX()), basegfx::fround(aPrimitiveRange.getMinY()),
basegfx::fround(aPrimitiveRange.getMaxX()), basegfx::fround(aPrimitiveRange.getMaxY()));
ScopedVclPtrInstance< VirtualDevice > aContentVDev;
MapMode aNewMapMode(pLastOutputDevice->GetMapMode());
WriteSvtGraphicFill(aMemStm, *pSvtGraphicFill);
mpMetaFile->AddAction(new MetaCommentAction(
"XPATHFILL_SEQ_BEGIN", 0, static_cast<const sal_uInt8*>(aMemStm.GetData()),
aMemStm.TellEnd()));
mnSvtGraphicFillCount++;
}
}
mpOutputDevice = aContentVDev.get();
mpMetaFile = &o_rContentMetafile;
aContentVDev->EnableOutput(false);
aContentVDev->SetMapMode(pLastOutputDevice->GetMapMode());
o_rContentMetafile.Record(aContentVDev.get());
aContentVDev->SetLineColor(pLastOutputDevice->GetLineColor());
aContentVDev->SetFillColor(pLastOutputDevice->GetFillColor());
aContentVDev->SetFont(pLastOutputDevice->GetFont());
aContentVDev->SetDrawMode(pLastOutputDevice->GetDrawMode());
aContentVDev->SetSettings(pLastOutputDevice->GetSettings());
aContentVDev->SetRefPoint(pLastOutputDevice->GetRefPoint());
void VclMetafileProcessor2D::impEndSvtGraphicFill(SvtGraphicFill const* pSvtGraphicFill)
{
if (pSvtGraphicFill && mnSvtGraphicFillCount)
{
mnSvtGraphicFillCount--;
mpMetaFile->AddAction(new MetaCommentAction("XPATHFILL_SEQ_END"));
}
}
// dump to MetaFile
process(rContent);
double VclMetafileProcessor2D::getTransformedLineWidth(double fWidth) const
{
// #i113922# the LineWidth is duplicated in the MetaPolylineAction,
// and also inside the SvtGraphicStroke and needs transforming into
// the same space as its coordinates here cf. fdo#61789
// This is a partial fix. When an object transformation is used which
// e.g. contains a scaleX != scaleY, an unproportional scaling will happen.
const basegfx::B2DVector aDiscreteUnit(maCurrentTransformation
* basegfx::B2DVector(fWidth, 0.0));
// cleanups
o_rContentMetafile.Stop();
o_rContentMetafile.WindStart();
aNewMapMode.SetOrigin(aPrimitiveRectangle.TopLeft());
o_rContentMetafile.SetPrefMapMode(aNewMapMode);
o_rContentMetafile.SetPrefSize(aPrimitiveRectangle.GetSize());
mpOutputDevice = pLastOutputDevice;
mpMetaFile = pLastMetafile;
return aDiscreteUnit.getLength();
}
return aPrimitiveRectangle;
std::unique_ptr<SvtGraphicStroke> VclMetafileProcessor2D::impTryToCreateSvtGraphicStroke(
const basegfx::B2DPolygon& rB2DPolygon, const basegfx::BColor* pColor,
const attribute::LineAttribute* pLineAttribute,
const attribute::StrokeAttribute* pStrokeAttribute,
const attribute::LineStartEndAttribute* pStart, const attribute::LineStartEndAttribute* pEnd)
{
std::unique_ptr<SvtGraphicStroke> pRetval;
if (rB2DPolygon.count() && !mnSvtGraphicStrokeCount)
{
basegfx::B2DPolygon aLocalPolygon(rB2DPolygon);
basegfx::BColor aStrokeColor;
basegfx::B2DPolyPolygon aStartArrow;
basegfx::B2DPolyPolygon aEndArrow;
if (pColor)
{
aStrokeColor = *pColor;
}
else if (pLineAttribute)
{
aStrokeColor = maBColorModifierStack.getModifiedColor(pLineAttribute->getColor());
}
void VclMetafileProcessor2D::impConvertFillGradientAttributeToVCLGradient(
Gradient& o_rVCLGradient,
const attribute::FillGradientAttribute& rFiGrAtt,
bool bIsTransparenceGradient) const
// It IS needed to record the stroke color at all in the metafile,
// SvtGraphicStroke has NO entry for stroke color(!)
mpOutputDevice->SetLineColor(Color(aStrokeColor));
if (!aLocalPolygon.isClosed())
{
if(bIsTransparenceGradient)
double fPolyLength(0.0);
double fStart(0.0);
double fEnd(0.0);
if (pStart && pStart->isActive())
{
// it's about transparence channel intensities (black/white), do not use color modifier
o_rVCLGradient.SetStartColor(Color(rFiGrAtt.getStartColor()));
o_rVCLGradient.SetEndColor(Color(rFiGrAtt.getEndColor()));
}
else
{
// use color modifier to influence start/end color of gradient
o_rVCLGradient.SetStartColor(Color(maBColorModifierStack.getModifiedColor(rFiGrAtt.getStartColor())));
o_rVCLGradient.SetEndColor(Color(maBColorModifierStack.getModifiedColor(rFiGrAtt.getEndColor())));
fPolyLength = basegfx::utils::getLength(aLocalPolygon);
aStartArrow = basegfx::utils::createAreaGeometryForLineStartEnd(
aLocalPolygon, pStart->getB2DPolyPolygon(), true, pStart->getWidth(),
fPolyLength, pStart->isCentered() ? 0.5 : 0.0, &fStart);
}
o_rVCLGradient.SetAngle(static_cast< sal_uInt16 >(rFiGrAtt.getAngle() * (1.0 / F_PI1800)));
o_rVCLGradient.SetBorder(static_cast< sal_uInt16 >(rFiGrAtt.getBorder() * 100.0));
o_rVCLGradient.SetOfsX(static_cast< sal_uInt16 >(rFiGrAtt.getOffsetX() * 100.0));
o_rVCLGradient.SetOfsY(static_cast< sal_uInt16 >(rFiGrAtt.getOffsetY() * 100.0));
o_rVCLGradient.SetSteps(rFiGrAtt.getSteps());
// defaults for intensity; those were computed into the start/end colors already
o_rVCLGradient.SetStartIntensity(100);
o_rVCLGradient.SetEndIntensity(100);
switch(rFiGrAtt.getStyle())
if (pEnd && pEnd->isActive())
{
default : // attribute::GradientStyle::Linear :
if (basegfx::fTools::equalZero(fPolyLength))
{
o_rVCLGradient.SetStyle(GradientStyle::Linear);
fPolyLength = basegfx::utils::getLength(aLocalPolygon);
}
aEndArrow = basegfx::utils::createAreaGeometryForLineStartEnd(
aLocalPolygon, pEnd->getB2DPolyPolygon(), false, pEnd->getWidth(), fPolyLength,
pEnd->isCentered() ? 0.5 : 0.0, &fEnd);
}
if (0.0 != fStart || 0.0 != fEnd)
{
// build new poly, consume something from old poly
aLocalPolygon = basegfx::utils::getSnippetAbsolute(aLocalPolygon, fStart,
fPolyLength - fEnd, fPolyLength);
}
}
SvtGraphicStroke::JoinType eJoin(SvtGraphicStroke::joinNone);
SvtGraphicStroke::CapType eCap(SvtGraphicStroke::capButt);
double fLineWidth(0.0);
double fMiterLength(0.0);
SvtGraphicStroke::DashArray aDashArray;
if (pLineAttribute)
{
fLineWidth = fMiterLength = getTransformedLineWidth(pLineAttribute->getWidth());
// get Join
switch (pLineAttribute->getLineJoin())
{
case basegfx::B2DLineJoin::NONE:
{
eJoin = SvtGraphicStroke::joinNone;
break;
}
case attribute::GradientStyle::Axial :
case basegfx::B2DLineJoin::Bevel:
{
o_rVCLGradient.SetStyle(GradientStyle::Axial);
eJoin = SvtGraphicStroke::joinBevel;
break;
}
case attribute::GradientStyle::Radial :
case basegfx::B2DLineJoin::Miter:
{
o_rVCLGradient.SetStyle(GradientStyle::Radial);
eJoin = SvtGraphicStroke::joinMiter;
// ATM 15 degrees is assumed
fMiterLength /= rtl::math::sin(basegfx::deg2rad(15.0));
break;
}
case attribute::GradientStyle::Elliptical :
case basegfx::B2DLineJoin::Round:
{
o_rVCLGradient.SetStyle(GradientStyle::Elliptical);
eJoin = SvtGraphicStroke::joinRound;
break;
}
case attribute::GradientStyle::Square :
}
// get stroke
switch (pLineAttribute->getLineCap())
{
default: /* css::drawing::LineCap_BUTT */
{
o_rVCLGradient.SetStyle(GradientStyle::Square);
eCap = SvtGraphicStroke::capButt;
break;
}
case attribute::GradientStyle::Rect :
case css::drawing::LineCap_ROUND:
{
o_rVCLGradient.SetStyle(GradientStyle::Rect);
eCap = SvtGraphicStroke::capRound;
break;
}
case css::drawing::LineCap_SQUARE:
{
eCap = SvtGraphicStroke::capSquare;
break;
}
}
}
void VclMetafileProcessor2D::impStartSvtGraphicFill(SvtGraphicFill const * pSvtGraphicFill)
if (pStrokeAttribute)
{
if(pSvtGraphicFill && !mnSvtGraphicFillCount)
{
SvMemoryStream aMemStm;
WriteSvtGraphicFill( aMemStm, *pSvtGraphicFill );
mpMetaFile->AddAction(new MetaCommentAction("XPATHFILL_SEQ_BEGIN", 0, static_cast< const sal_uInt8* >(aMemStm.GetData()), aMemStm.TellEnd()));
mnSvtGraphicFillCount++;
}
// copy dash array
aDashArray = pStrokeAttribute->getDotDashArray();
}
void VclMetafileProcessor2D::impEndSvtGraphicFill(SvtGraphicFill const * pSvtGraphicFill)
// #i101734# apply current object transformation to created geometry.
// This is a partial fix. When an object transformation is used which
// e.g. contains a scaleX != scaleY, an unproportional scaling would
// have to be applied to the evtl. existing fat line. The current
// concept of PDF export and SvtGraphicStroke usage does simply not
// allow handling such definitions. The only clean way would be to
// add the transformation to SvtGraphicStroke and to handle it there
aLocalPolygon.transform(maCurrentTransformation);
aStartArrow.transform(maCurrentTransformation);
aEndArrow.transform(maCurrentTransformation);
pRetval.reset(
new SvtGraphicStroke(tools::Polygon(aLocalPolygon), tools::PolyPolygon(aStartArrow),
tools::PolyPolygon(aEndArrow), mfCurrentUnifiedTransparence,
fLineWidth, eCap, eJoin, fMiterLength, aDashArray));
}
return pRetval;
}
void VclMetafileProcessor2D::impStartSvtGraphicStroke(SvtGraphicStroke const* pSvtGraphicStroke)
{
if (pSvtGraphicStroke && !mnSvtGraphicStrokeCount)
{
SvMemoryStream aMemStm;
WriteSvtGraphicStroke(aMemStm, *pSvtGraphicStroke);
mpMetaFile->AddAction(new MetaCommentAction(
"XPATHSTROKE_SEQ_BEGIN", 0, static_cast<const sal_uInt8*>(aMemStm.GetData()),
aMemStm.TellEnd()));
mnSvtGraphicStrokeCount++;
}
}
void VclMetafileProcessor2D::impEndSvtGraphicStroke(SvtGraphicStroke const* pSvtGraphicStroke)
{
if (pSvtGraphicStroke && mnSvtGraphicStrokeCount)
{
mnSvtGraphicStrokeCount--;
mpMetaFile->AddAction(new MetaCommentAction("XPATHSTROKE_SEQ_END"));
}
}
void VclMetafileProcessor2D::popStructureElement(vcl::PDFWriter::StructElement eElem)
{
if (!maListElements.empty() && maListElements.top() == eElem)
{
maListElements.pop();
mpPDFExtOutDevData->EndStructureElement();
}
}
void VclMetafileProcessor2D::popListItem()
{
popStructureElement(vcl::PDFWriter::LIBody);
popStructureElement(vcl::PDFWriter::ListItem);
}
void VclMetafileProcessor2D::popList()
{
popListItem();
popStructureElement(vcl::PDFWriter::List);
}
// init static break iterator
uno::Reference<css::i18n::XBreakIterator> VclMetafileProcessor2D::mxBreakIterator;
VclMetafileProcessor2D::VclMetafileProcessor2D(const geometry::ViewInformation2D& rViewInformation,
OutputDevice& rOutDev)
: VclProcessor2D(rViewInformation, rOutDev)
, mpMetaFile(rOutDev.GetConnectMetaFile())
, mnSvtGraphicFillCount(0)
, mnSvtGraphicStrokeCount(0)
, mfCurrentUnifiedTransparence(0.0)
, mpPDFExtOutDevData(dynamic_cast<vcl::PDFExtOutDevData*>(rOutDev.GetExtOutDevData()))
, mnCurrentOutlineLevel(-1)
, mbInListItem(false)
, mbBulletPresent(false)
{
OSL_ENSURE(rOutDev.GetConnectMetaFile(),
"VclMetafileProcessor2D: Used on OutDev which has no MetaFile Target (!)");
// draw to logic coordinates, do not initialize maCurrentTransformation to viewTransformation
// but only to ObjectTransformation. Do not change MapMode of destination.
maCurrentTransformation = rViewInformation.getObjectTransformation();
}
VclMetafileProcessor2D::~VclMetafileProcessor2D()
{
// MapMode was not changed, no restore necessary
}
/***********************************************************************************************
Support of MetaCommentActions in the VclMetafileProcessor2D
Found MetaCommentActions and how they are supported:
XGRAD_SEQ_BEGIN, XGRAD_SEQ_END:
Used inside OutputDevice::DrawGradient to mark the start and end of a MetaGradientEx action.
It is used in various exporters/importers to have direct access to the gradient before it
is rendered by VCL (and thus fragmented to polygon color actions and others). On that base, e.g.
the Metafile to SdrObject import creates its gradient objects.
Best (and safest) way to support it here is to use PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,
map it back to the corresponding tools tools::PolyPolygon and the Gradient and just call
OutputDevice::DrawGradient which creates the necessary compatible actions.
XPATHFILL_SEQ_BEGIN, XPATHFILL_SEQ_END:
Two producers, one is vcl/source/gdi/gdimtf.cxx, line 1273. There, it is transformed
inside GDIMetaFile::Rotate, nothing to take care of here.
The second producer is in graphics/svx/source/svdraw/impgrfll.cxx, line 374. This is used
with each incarnation of Imp_GraphicFill when a metafile is recorded, fillstyle is not
XFILL_NONE and not completely transparent. It creates a SvtGraphicFill and streams it
to the comment action. A closing end token is created in the destructor.
Usages of Imp_GraphicFill are in Do_Paint_Object-methods of SdrCircObj, SdrPathObj and
SdrRectObj.
The token users pick various actions from SvtGraphicFill, so it may need to be added for all kind
of filled objects, even simple colored polygons. It is added as extra information; the
Metafile actions between the two tokens are interpreted as output generated from those
fills. Thus, users have the choice to use the SvtGraphicFill info or the created output
actions.
Even for XFillTransparenceItem it is used, thus it may need to be supported in
UnifiedTransparencePrimitive2D, too, when interpreted as normally filled PolyPolygon.
Implemented for:
PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D,
PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D,
PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,
PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D,
and for PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D when detected unified transparence
XPATHSTROKE_SEQ_BEGIN, XPATHSTROKE_SEQ_END:
Similar to pathfill, but using SvtGraphicStroke instead. It also has two producers where one
is also the GDIMetaFile::Rotate. Another user is MetaCommentAction::Move which modifies the
contained path accordingly.
The other one is SdrObject::Imp_DrawLineGeometry. It's done when MetaFile is set at OutDev and
only when geometry is a single polygon (!). I see no reason for that; in the PS exporter this
would hinder to make use of tools::PolyPolygon strokes. I will need to add support at:
PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D
PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D
PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D
This can be done hierarchical, too.
Okay, base implementation done based on those three primitives.
FIELD_SEQ_BEGIN, FIELD_SEQ_END
Used from slideshow for URLs, created from diverse SvxField implementations inside
createBeginComment()/createEndComment(). createBeginComment() is used from editeng\impedit3.cxx
inside ImpEditEngine::Paint.
Created TextHierarchyFieldPrimitive2D and added needed infos there; it is a group primitive and wraps
text primitives (but is not limited to that). It contains the field type if special actions for the
support of FIELD_SEQ_BEGIN/END are needed; this is the case for Page and URL fields. If more is
needed, it may be supported there.
FIELD_SEQ_BEGIN;PageField
FIELD_SEQ_END
Okay, these are now completely supported by TextHierarchyFieldPrimitive2D. URL works, too.
XTEXT
XTEXT_EOC(i) end of character
XTEXT_EOW(i) end of word
XTEXT_EOS(i) end of sentence
this three are with index and are created with the help of an i18n::XBreakIterator in
ImplDrawWithComments. Simplifying, moving out text painting, reworking to create some
data structure for holding those TEXT infos.
Supported directly by TextSimplePortionPrimitive2D with adding a Locale to the basic text
primitive. In the MetaFileRenderer, the creation is now done (see below). This has the advantage
that this creations do not need to be done for all paints all the time. This would be
expensive since the BreakIterator and it's usage is expensive and for each paint also the
whole character stops would need to be created.
Created only for TextDecoratedPortionPrimitive2D due to XTEXT_EOL and XTEXT_EOP (see below)
XTEXT_EOL() end of line
XTEXT_EOP() end of paragraph
First try with boolean marks at TextDecoratedPortionPrimitive2D did not work too well,
i decided to solve it with structure. I added the TextHierarchyPrimitives for this,
namely:
- TextHierarchyLinePrimitive2D: Encapsulates single line
- TextHierarchyParagraphPrimitive2D: Encapsulates single paragraph
- TextHierarchyBlockPrimitive2D: encapsulates object texts (only one ATM)
Those are now supported in hierarchy. This means the MetaFile renderer will support them
by using them, recursively using their content and adding MetaFile comments as needed.
This also means that when another text layouter will be used it will be necessary to
create/support the same HierarchyPrimitives to support users.
To transport the information using this hierarchy is best suited to all future needs;
the slideshow will be able to profit from it directly when using primitives; all other
renderers not interested in the text structure will just ignore the encapsulations.
XTEXT_PAINTSHAPE_BEGIN, XTEXT_PAINTSHAPE_END
Supported now by the TextHierarchyBlockPrimitive2D.
EPSReplacementGraphic:
Only used in goodies\source\filter.vcl\ieps\ieps.cxx and svx\source\xml\xmlgrhlp.cxx to
hold the original EPS which was imported in the same MetaFile as first 2 entries. Only
used to export the original again (if exists).
Not necessary to support with MetaFuleRenderer.
XTEXT_SCROLLRECT, XTEXT_PAINTRECT
Currently used to get extra MetaFile infos using GraphicExporter which again uses
SdrTextObj::GetTextScrollMetaFileAndRectangle(). ATM works with primitives since
the rectangle data is added directly by the GraphicsExporter as comment. Does not need
to be adapted at once.
When adapting later, the only user - the diashow - should directly use the provided
Animation infos in the appropriate primitives (e.g. AnimatedSwitchPrimitive2D)
PRNSPOOL_TRANSPARENTBITMAP_BEGIN, PRNSPOOL_TRANSPARENTBITMAP_END
VCL usage when printing PL -> THB. Okay, THB confirms that it is only used as
a fix (hack) while VCL printing. It is needed to not downscale a bitmap which
was explicitly created for the printer already again to some default maximum
bitmap sizes.
Nothing to do here for the primitive renderer.
Support for vcl::PDFExtOutDevData:
PL knows that SJ did that stuff, it's used to hold a pointer to PDFExtOutDevData at
the OutDev. When set, some extra data is written there. Trying simple PDF export and
watching if I get those infos.
Well, a PDF export does not use e.g. ImpEditEngine::Paint since the PdfFilter uses
the SdXImpressDocument::render and thus uses the VclMetafileProcessor2D. I will check
if I get a PDFExtOutDevData at the target output device.
Indeed, I get one. Checking what all may be done when that extra-device-info is there.
All in all I have to talk to SJ. I will need to emulate some of those actions, but
i need to discuss which ones.
In the future, all those infos would be taken from the primitive sequence anyways,
thus these extensions would potentially be temporary, too.
Discussed with SJ, added the necessary support and tested it. Details follow.
- In ImpEditEngine::Paint, paragraph infos and URL stuff is added.
Added in primitive MetaFile renderer.
Checking URL: Indeed, current version exports it, but it is missing in primitive
CWS version. Adding support.
Okay, URLs work. Checked, Done.
- UnoControlPDFExportContact is only created when PDFExtOutDevData is used at the
target and uno control data is created in UnoControlPDFExportContact::do_PaintObject.
This may be added in primitive MetaFile renderer.
Adding support...
OOps, the necessary helper stuff is in svx/source/form/formpdxexport.cxx in namespace
svxform. Have to talk to FS if this has to be like that. Especially since
vcl::PDFWriter::AnyWidget is filled out, which is already part of vcl.
Wrote an eMail to FS, he is on vacation currently. I see no reason why not to move
that stuff to somewhere else, maybe tools or svtools ?!? We will see...
Moved to toolkit, so I have to link against it. I tried VCL first, but it did
not work since VCLUnoHelper::CreateFont is unresolved in VCL (!). Other than the name
may imply, it is defined in toolkit (!). Since toolkit is linked against VCL itself,
the lowest movement plane is toolkit.
Checked form control export, it works well. Done.
- In goodies, in GraphicObject::Draw, when the used Graphic is linked, infos are
generated. I will need to check what happens here with primitives.
To support, use of GraphicPrimitive2D (PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D) may be needed.
Added support, but feature is broken in main version, so i cannot test at all.
Writing a bug to CL (or SJ) and seeing what happens (#i80380#).
SJ took a look and we got it working. Tested VCL MetaFile Renderer based export,
as intended, the original file is exported. Works, Done.
To be done:
- Maybe there are more places to take care of for vcl::PDFExtOutDevData!
****************************************************************************************************/
void VclMetafileProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
{
switch (rCandidate.getPrimitive2DID())
{
case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D:
{
if(pSvtGraphicFill && mnSvtGraphicFillCount)
{
mnSvtGraphicFillCount--;
mpMetaFile->AddAction(new MetaCommentAction("XPATHFILL_SEQ_END"));
}
// directdraw of wrong spell primitive
// Ignore for VclMetafileProcessor2D, this is for printing and MetaFile recording only
break;
}
double VclMetafileProcessor2D::getTransformedLineWidth( double fWidth ) const
case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D:
{
// #i113922# the LineWidth is duplicated in the MetaPolylineAction,
// and also inside the SvtGraphicStroke and needs transforming into
// the same space as its coordinates here cf. fdo#61789
// This is a partial fix. When an object transformation is used which
// e.g. contains a scaleX != scaleY, an unproportional scaling will happen.
const basegfx::B2DVector aDiscreteUnit( maCurrentTransformation * basegfx::B2DVector( fWidth, 0.0 ) );
return aDiscreteUnit.getLength();
processGraphicPrimitive2D(
static_cast<const primitive2d::GraphicPrimitive2D&>(rCandidate));
break;
}
std::unique_ptr<SvtGraphicStroke> VclMetafileProcessor2D::impTryToCreateSvtGraphicStroke(
const basegfx::B2DPolygon& rB2DPolygon,
const basegfx::BColor* pColor,
const attribute::LineAttribute* pLineAttribute,
const attribute::StrokeAttribute* pStrokeAttribute,
const attribute::LineStartEndAttribute* pStart,
const attribute::LineStartEndAttribute* pEnd)
case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D:
{
std::unique_ptr<SvtGraphicStroke> pRetval;
if(rB2DPolygon.count() && !mnSvtGraphicStrokeCount)
{
basegfx::B2DPolygon aLocalPolygon(rB2DPolygon);
basegfx::BColor aStrokeColor;
basegfx::B2DPolyPolygon aStartArrow;
basegfx::B2DPolyPolygon aEndArrow;
if(pColor)
{
aStrokeColor = *pColor;
}
else if(pLineAttribute)
{
aStrokeColor = maBColorModifierStack.getModifiedColor(pLineAttribute->getColor());
}
// It IS needed to record the stroke color at all in the metafile,
// SvtGraphicStroke has NO entry for stroke color(!)
mpOutputDevice->SetLineColor(Color(aStrokeColor));
if(!aLocalPolygon.isClosed())
{
double fPolyLength(0.0);
double fStart(0.0);
double fEnd(0.0);
if(pStart && pStart->isActive())
{
fPolyLength = basegfx::utils::getLength(aLocalPolygon);
aStartArrow = basegfx::utils::createAreaGeometryForLineStartEnd(
aLocalPolygon, pStart->getB2DPolyPolygon(), true, pStart->getWidth(),
fPolyLength, pStart->isCentered() ? 0.5 : 0.0, &fStart);
}
if(pEnd && pEnd->isActive())
{
if(basegfx::fTools::equalZero(fPolyLength))
{
fPolyLength = basegfx::utils::getLength(aLocalPolygon);
}
aEndArrow = basegfx::utils::createAreaGeometryForLineStartEnd(
aLocalPolygon, pEnd->getB2DPolyPolygon(), false, pEnd->getWidth(),
fPolyLength, pEnd->isCentered() ? 0.5 : 0.0, &fEnd);
}
if(0.0 != fStart || 0.0 != fEnd)
{
// build new poly, consume something from old poly
aLocalPolygon = basegfx::utils::getSnippetAbsolute(aLocalPolygon, fStart, fPolyLength - fEnd, fPolyLength);
}
}
SvtGraphicStroke::JoinType eJoin(SvtGraphicStroke::joinNone);
SvtGraphicStroke::CapType eCap(SvtGraphicStroke::capButt);
double fLineWidth(0.0);
double fMiterLength(0.0);
SvtGraphicStroke::DashArray aDashArray;
if(pLineAttribute)
{
fLineWidth = fMiterLength = getTransformedLineWidth( pLineAttribute->getWidth() );
// get Join
switch(pLineAttribute->getLineJoin())
{
case basegfx::B2DLineJoin::NONE :
{
eJoin = SvtGraphicStroke::joinNone;
break;
}
case basegfx::B2DLineJoin::Bevel :
{
eJoin = SvtGraphicStroke::joinBevel;
break;
}
case basegfx::B2DLineJoin::Miter :
{
eJoin = SvtGraphicStroke::joinMiter;
// ATM 15 degrees is assumed
fMiterLength /= rtl::math::sin(basegfx::deg2rad(15.0));
break;
}
case basegfx::B2DLineJoin::Round :
{
eJoin = SvtGraphicStroke::joinRound;
break;
}
}
// get stroke
switch(pLineAttribute->getLineCap())
{
default: /* css::drawing::LineCap_BUTT */
{
eCap = SvtGraphicStroke::capButt;
break;
}
case css::drawing::LineCap_ROUND:
{
eCap = SvtGraphicStroke::capRound;
break;
}
case css::drawing::LineCap_SQUARE:
{
eCap = SvtGraphicStroke::capSquare;
break;
}
}
}
if(pStrokeAttribute)
{
// copy dash array
aDashArray = pStrokeAttribute->getDotDashArray();
}
// #i101734# apply current object transformation to created geometry.
// This is a partial fix. When an object transformation is used which
// e.g. contains a scaleX != scaleY, an unproportional scaling would
// have to be applied to the evtl. existing fat line. The current
// concept of PDF export and SvtGraphicStroke usage does simply not
// allow handling such definitions. The only clean way would be to
// add the transformation to SvtGraphicStroke and to handle it there
aLocalPolygon.transform(maCurrentTransformation);
aStartArrow.transform(maCurrentTransformation);
aEndArrow.transform(maCurrentTransformation);
pRetval.reset(new SvtGraphicStroke(
::tools::Polygon(aLocalPolygon),
::tools::PolyPolygon(aStartArrow),
::tools::PolyPolygon(aEndArrow),
mfCurrentUnifiedTransparence,
fLineWidth,
eCap,
eJoin,
fMiterLength,
aDashArray));
}
return pRetval;
processControlPrimitive2D(
static_cast<const primitive2d::ControlPrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::impStartSvtGraphicStroke(SvtGraphicStroke const * pSvtGraphicStroke)
case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D:
{
if(pSvtGraphicStroke && !mnSvtGraphicStrokeCount)
{
SvMemoryStream aMemStm;
WriteSvtGraphicStroke( aMemStm, *pSvtGraphicStroke );
mpMetaFile->AddAction(new MetaCommentAction("XPATHSTROKE_SEQ_BEGIN", 0, static_cast< const sal_uInt8* >(aMemStm.GetData()), aMemStm.TellEnd()));
mnSvtGraphicStrokeCount++;
}
processTextHierarchyFieldPrimitive2D(
static_cast<const primitive2d::TextHierarchyFieldPrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::impEndSvtGraphicStroke(SvtGraphicStroke const * pSvtGraphicStroke)
case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D:
{
if(pSvtGraphicStroke && mnSvtGraphicStrokeCount)
{
mnSvtGraphicStrokeCount--;
mpMetaFile->AddAction(new MetaCommentAction("XPATHSTROKE_SEQ_END"));
}
processTextHierarchyLinePrimitive2D(
static_cast<const primitive2d::TextHierarchyLinePrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::popStructureElement(vcl::PDFWriter::StructElement eElem)
case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D:
{
if (!maListElements.empty() && maListElements.top() == eElem)
{
maListElements.pop();
mpPDFExtOutDevData->EndStructureElement();
}
processTextHierarchyBulletPrimitive2D(
static_cast<const primitive2d::TextHierarchyBulletPrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::popListItem()
case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D:
{
popStructureElement(vcl::PDFWriter::LIBody);
popStructureElement(vcl::PDFWriter::ListItem);
processTextHierarchyParagraphPrimitive2D(
static_cast<const primitive2d::TextHierarchyParagraphPrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::popList()
case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D:
{
popListItem();
popStructureElement(vcl::PDFWriter::List);
processTextHierarchyBlockPrimitive2D(
static_cast<const primitive2d::TextHierarchyBlockPrimitive2D&>(rCandidate));
break;
}
// init static break iterator
uno::Reference< css::i18n::XBreakIterator > VclMetafileProcessor2D::mxBreakIterator;
VclMetafileProcessor2D::VclMetafileProcessor2D(const geometry::ViewInformation2D& rViewInformation, OutputDevice& rOutDev)
: VclProcessor2D(rViewInformation, rOutDev),
mpMetaFile(rOutDev.GetConnectMetaFile()),
mnSvtGraphicFillCount(0),
mnSvtGraphicStrokeCount(0),
mfCurrentUnifiedTransparence(0.0),
mpPDFExtOutDevData(dynamic_cast< vcl::PDFExtOutDevData* >(rOutDev.GetExtOutDevData())),
mnCurrentOutlineLevel(-1),
mbInListItem(false),
mbBulletPresent(false)
case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D:
case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D:
{
OSL_ENSURE(rOutDev.GetConnectMetaFile(), "VclMetafileProcessor2D: Used on OutDev which has no MetaFile Target (!)");
// draw to logic coordinates, do not initialize maCurrentTransformation to viewTransformation
// but only to ObjectTransformation. Do not change MapMode of destination.
maCurrentTransformation = rViewInformation.getObjectTransformation();
// for supporting TEXT_ MetaFile actions there is more to do here; get the candidate
processTextSimplePortionPrimitive2D(
static_cast<const primitive2d::TextSimplePortionPrimitive2D&>(rCandidate));
break;
}
VclMetafileProcessor2D::~VclMetafileProcessor2D()
case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D:
{
// MapMode was not changed, no restore necessary
processPolygonHairlinePrimitive2D(
static_cast<const primitive2d::PolygonHairlinePrimitive2D&>(rCandidate));
break;
}
/***********************************************************************************************
Support of MetaCommentActions in the VclMetafileProcessor2D
Found MetaCommentActions and how they are supported:
XGRAD_SEQ_BEGIN, XGRAD_SEQ_END:
Used inside OutputDevice::DrawGradient to mark the start and end of a MetaGradientEx action.
It is used in various exporters/importers to have direct access to the gradient before it
is rendered by VCL (and thus fragmented to polygon color actions and others). On that base, e.g.
the Metafile to SdrObject import creates its gradient objects.
Best (and safest) way to support it here is to use PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,
map it back to the corresponding tools tools::PolyPolygon and the Gradient and just call
OutputDevice::DrawGradient which creates the necessary compatible actions.
XPATHFILL_SEQ_BEGIN, XPATHFILL_SEQ_END:
Two producers, one is vcl/source/gdi/gdimtf.cxx, line 1273. There, it is transformed
inside GDIMetaFile::Rotate, nothing to take care of here.
The second producer is in graphics/svx/source/svdraw/impgrfll.cxx, line 374. This is used
with each incarnation of Imp_GraphicFill when a metafile is recorded, fillstyle is not
XFILL_NONE and not completely transparent. It creates a SvtGraphicFill and streams it
to the comment action. A closing end token is created in the destructor.
Usages of Imp_GraphicFill are in Do_Paint_Object-methods of SdrCircObj, SdrPathObj and
SdrRectObj.
The token users pick various actions from SvtGraphicFill, so it may need to be added for all kind
of filled objects, even simple colored polygons. It is added as extra information; the
Metafile actions between the two tokens are interpreted as output generated from those
fills. Thus, users have the choice to use the SvtGraphicFill info or the created output
actions.
Even for XFillTransparenceItem it is used, thus it may need to be supported in
UnifiedTransparencePrimitive2D, too, when interpreted as normally filled PolyPolygon.
Implemented for:
PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D,
PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D,
PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,
PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D,
and for PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D when detected unified transparence
XPATHSTROKE_SEQ_BEGIN, XPATHSTROKE_SEQ_END:
Similar to pathfill, but using SvtGraphicStroke instead. It also has two producers where one
is also the GDIMetaFile::Rotate. Another user is MetaCommentAction::Move which modifies the
contained path accordingly.
The other one is SdrObject::Imp_DrawLineGeometry. It's done when MetaFile is set at OutDev and
only when geometry is a single polygon (!). I see no reason for that; in the PS exporter this
would hinder to make use of tools::PolyPolygon strokes. I will need to add support at:
PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D
PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D
PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D
This can be done hierarchical, too.
Okay, base implementation done based on those three primitives.
FIELD_SEQ_BEGIN, FIELD_SEQ_END
Used from slideshow for URLs, created from diverse SvxField implementations inside
createBeginComment()/createEndComment(). createBeginComment() is used from editeng\impedit3.cxx
inside ImpEditEngine::Paint.
Created TextHierarchyFieldPrimitive2D and added needed infos there; it is a group primitive and wraps
text primitives (but is not limited to that). It contains the field type if special actions for the
support of FIELD_SEQ_BEGIN/END are needed; this is the case for Page and URL fields. If more is
needed, it may be supported there.
FIELD_SEQ_BEGIN;PageField
FIELD_SEQ_END
Okay, these are now completely supported by TextHierarchyFieldPrimitive2D. URL works, too.
XTEXT
XTEXT_EOC(i) end of character
XTEXT_EOW(i) end of word
XTEXT_EOS(i) end of sentence
this three are with index and are created with the help of an i18n::XBreakIterator in
ImplDrawWithComments. Simplifying, moving out text painting, reworking to create some
data structure for holding those TEXT infos.
Supported directly by TextSimplePortionPrimitive2D with adding a Locale to the basic text
primitive. In the MetaFileRenderer, the creation is now done (see below). This has the advantage
that this creations do not need to be done for all paints all the time. This would be
expensive since the BreakIterator and it's usage is expensive and for each paint also the
whole character stops would need to be created.
Created only for TextDecoratedPortionPrimitive2D due to XTEXT_EOL and XTEXT_EOP (see below)
XTEXT_EOL() end of line
XTEXT_EOP() end of paragraph
First try with boolean marks at TextDecoratedPortionPrimitive2D did not work too well,
i decided to solve it with structure. I added the TextHierarchyPrimitives for this,
namely:
- TextHierarchyLinePrimitive2D: Encapsulates single line
- TextHierarchyParagraphPrimitive2D: Encapsulates single paragraph
- TextHierarchyBlockPrimitive2D: encapsulates object texts (only one ATM)
Those are now supported in hierarchy. This means the MetaFile renderer will support them
by using them, recursively using their content and adding MetaFile comments as needed.
This also means that when another text layouter will be used it will be necessary to
create/support the same HierarchyPrimitives to support users.
To transport the information using this hierarchy is best suited to all future needs;
the slideshow will be able to profit from it directly when using primitives; all other
renderers not interested in the text structure will just ignore the encapsulations.
XTEXT_PAINTSHAPE_BEGIN, XTEXT_PAINTSHAPE_END
Supported now by the TextHierarchyBlockPrimitive2D.
EPSReplacementGraphic:
Only used in goodies\source\filter.vcl\ieps\ieps.cxx and svx\source\xml\xmlgrhlp.cxx to
hold the original EPS which was imported in the same MetaFile as first 2 entries. Only
used to export the original again (if exists).
Not necessary to support with MetaFuleRenderer.
XTEXT_SCROLLRECT, XTEXT_PAINTRECT
Currently used to get extra MetaFile infos using GraphicExporter which again uses
SdrTextObj::GetTextScrollMetaFileAndRectangle(). ATM works with primitives since
the rectangle data is added directly by the GraphicsExporter as comment. Does not need
to be adapted at once.
When adapting later, the only user - the diashow - should directly use the provided
Animation infos in the appropriate primitives (e.g. AnimatedSwitchPrimitive2D)
PRNSPOOL_TRANSPARENTBITMAP_BEGIN, PRNSPOOL_TRANSPARENTBITMAP_END
VCL usage when printing PL -> THB. Okay, THB confirms that it is only used as
a fix (hack) while VCL printing. It is needed to not downscale a bitmap which
was explicitly created for the printer already again to some default maximum
bitmap sizes.
Nothing to do here for the primitive renderer.
Support for vcl::PDFExtOutDevData:
PL knows that SJ did that stuff, it's used to hold a pointer to PDFExtOutDevData at
the OutDev. When set, some extra data is written there. Trying simple PDF export and
watching if I get those infos.
Well, a PDF export does not use e.g. ImpEditEngine::Paint since the PdfFilter uses
the SdXImpressDocument::render and thus uses the VclMetafileProcessor2D. I will check
if I get a PDFExtOutDevData at the target output device.
Indeed, I get one. Checking what all may be done when that extra-device-info is there.
All in all I have to talk to SJ. I will need to emulate some of those actions, but
i need to discuss which ones.
In the future, all those infos would be taken from the primitive sequence anyways,
thus these extensions would potentially be temporary, too.
Discussed with SJ, added the necessary support and tested it. Details follow.
- In ImpEditEngine::Paint, paragraph infos and URL stuff is added.
Added in primitive MetaFile renderer.
Checking URL: Indeed, current version exports it, but it is missing in primitive
CWS version. Adding support.
Okay, URLs work. Checked, Done.
- UnoControlPDFExportContact is only created when PDFExtOutDevData is used at the
target and uno control data is created in UnoControlPDFExportContact::do_PaintObject.
This may be added in primitive MetaFile renderer.
Adding support...
OOps, the necessary helper stuff is in svx/source/form/formpdxexport.cxx in namespace
svxform. Have to talk to FS if this has to be like that. Especially since
vcl::PDFWriter::AnyWidget is filled out, which is already part of vcl.
Wrote an eMail to FS, he is on vacation currently. I see no reason why not to move
that stuff to somewhere else, maybe tools or svtools ?!? We will see...
Moved to toolkit, so I have to link against it. I tried VCL first, but it did
not work since VCLUnoHelper::CreateFont is unresolved in VCL (!). Other than the name
may imply, it is defined in toolkit (!). Since toolkit is linked against VCL itself,
the lowest movement plane is toolkit.
Checked form control export, it works well. Done.
- In goodies, in GraphicObject::Draw, when the used Graphic is linked, infos are
generated. I will need to check what happens here with primitives.
To support, use of GraphicPrimitive2D (PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D) may be needed.
Added support, but feature is broken in main version, so i cannot test at all.
Writing a bug to CL (or SJ) and seeing what happens (#i80380#).
SJ took a look and we got it working. Tested VCL MetaFile Renderer based export,
as intended, the original file is exported. Works, Done.
To be done:
- Maybe there are more places to take care of for vcl::PDFExtOutDevData!
****************************************************************************************************/
void VclMetafileProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
{
switch(rCandidate.getPrimitive2DID())
{
case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D :
{
// directdraw of wrong spell primitive
// Ignore for VclMetafileProcessor2D, this is for printing and MetaFile recording only
break;
}
case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D :
{
processGraphicPrimitive2D(static_cast<const primitive2d::GraphicPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D :
{
processControlPrimitive2D(static_cast<const primitive2d::ControlPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D :
{
processTextHierarchyFieldPrimitive2D(static_cast<const primitive2d::TextHierarchyFieldPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D :
{
processTextHierarchyLinePrimitive2D(static_cast<const primitive2d::TextHierarchyLinePrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D :
{
processTextHierarchyBulletPrimitive2D(static_cast<const primitive2d::TextHierarchyBulletPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D :
{
processTextHierarchyParagraphPrimitive2D(static_cast<const primitive2d::TextHierarchyParagraphPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D :
{
processTextHierarchyBlockPrimitive2D(static_cast<const primitive2d::TextHierarchyBlockPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D :
case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D :
{
// for supporting TEXT_ MetaFile actions there is more to do here; get the candidate
processTextSimplePortionPrimitive2D(static_cast<const primitive2d::TextSimplePortionPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D :
{
processPolygonHairlinePrimitive2D(static_cast<const primitive2d::PolygonHairlinePrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D :
{
processPolygonStrokePrimitive2D(static_cast<const primitive2d::PolygonStrokePrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D :
{
processPolygonStrokeArrowPrimitive2D(static_cast<const primitive2d::PolygonStrokeArrowPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D :
{
// direct draw of transformed BitmapEx primitive; use default processing, but without
// former testing if graphic content is inside discrete local viewport; this is not
// setup for metafile targets (metafile renderer tries to render in logic coordinates,
// the mapping is kept to the OutputDevice for better Metafile recording)
RenderBitmapPrimitive2D(static_cast< const primitive2d::BitmapPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D :
{
processPolyPolygonGraphicPrimitive2D(static_cast<const primitive2d::PolyPolygonGraphicPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D :
{
processPolyPolygonHatchPrimitive2D(static_cast<const primitive2d::PolyPolygonHatchPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D :
{
processPolyPolygonGradientPrimitive2D(static_cast<const primitive2d::PolyPolygonGradientPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
{
processPolyPolygonColorPrimitive2D(static_cast<const primitive2d::PolyPolygonColorPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_MASKPRIMITIVE2D :
{
processMaskPrimitive2D(static_cast<const primitive2d::MaskPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D :
{
// modified color group. Force output to unified color. Use default pocessing.
RenderModifiedColorPrimitive2D(static_cast< const primitive2d::ModifiedColorPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D :
{
processUnifiedTransparencePrimitive2D(static_cast<const primitive2d::UnifiedTransparencePrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D :
{
processTransparencePrimitive2D(static_cast<const primitive2d::TransparencePrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D :
{
// use default transform group pocessing
RenderTransformPrimitive2D(static_cast< const primitive2d::TransformPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D :
{
// new XDrawPage for ViewInformation2D
RenderPagePreviewPrimitive2D(static_cast< const primitive2d::PagePreviewPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D :
{
// use default marker array pocessing
RenderMarkerArrayPrimitive2D(static_cast< const primitive2d::MarkerArrayPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D :
{
// use default point array pocessing
RenderPointArrayPrimitive2D(static_cast< const primitive2d::PointArrayPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D :
{
processStructureTagPrimitive2D(static_cast<const primitive2d::StructureTagPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_EPSPRIMITIVE2D :
{
RenderEpsPrimitive2D(static_cast< const primitive2d::EpsPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D :
{
RenderObjectInfoPrimitive2D(static_cast< const primitive2d::ObjectInfoPrimitive2D& >(rCandidate));
break;
}
default :
{
// process recursively
process(rCandidate);
break;
}
}
processPolygonStrokePrimitive2D(
static_cast<const primitive2d::PolygonStrokePrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::processGraphicPrimitive2D(const primitive2d::GraphicPrimitive2D& rGraphicPrimitive)
case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D:
{
bool bUsingPDFExtOutDevData(false);
basegfx::B2DVector aTranslate, aScale;
static bool bSuppressPDFExtOutDevDataSupport(false); // loplugin:constvars:ignore
if(mpPDFExtOutDevData && !bSuppressPDFExtOutDevDataSupport)
{
// emulate data handling from UnoControlPDFExportContact, original see
// svtools/source/graphic/grfmgr.cxx
const Graphic& rGraphic = rGraphicPrimitive.getGraphicObject().GetGraphic();
if(rGraphic.IsGfxLink())
{
const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr();
if(!rAttr.IsSpecialDrawMode() && !rAttr.IsAdjusted())
{
const basegfx::B2DHomMatrix& rTransform = rGraphicPrimitive.getTransform();
double fRotate, fShearX;
rTransform.decompose(aScale, aTranslate, fRotate, fShearX);
if( basegfx::fTools::equalZero( fRotate ) && ( aScale.getX() > 0.0 ) && ( aScale.getY() > 0.0 ) )
{
bUsingPDFExtOutDevData = true;
mpPDFExtOutDevData->BeginGroup();
}
}
}
}
// process recursively and add MetaFile comment
process(rGraphicPrimitive);
if(!bUsingPDFExtOutDevData)
return;
// emulate data handling from UnoControlPDFExportContact, original see
// svtools/source/graphic/grfmgr.cxx
const basegfx::B2DRange aCurrentRange(
aTranslate.getX(), aTranslate.getY(),
aTranslate.getX() + aScale.getX(), aTranslate.getY() + aScale.getY());
const ::tools::Rectangle aCurrentRect(
sal_Int32(floor(aCurrentRange.getMinX())), sal_Int32(floor(aCurrentRange.getMinY())),
sal_Int32(ceil(aCurrentRange.getMaxX())), sal_Int32(ceil(aCurrentRange.getMaxY())));
const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr();
// fdo#72530 don't pass empty Rectangle to EndGroup
::tools::Rectangle aCropRect(aCurrentRect);
if(rAttr.IsCropped())
{
// calculate scalings between real image size and logic object size. This
// is necessary since the crop values are relative to original bitmap size
double fFactorX(1.0);
double fFactorY(1.0);
{
const MapMode aMapMode100thmm(MapUnit::Map100thMM);
const Size aBitmapSize(OutputDevice::LogicToLogic(
rGraphicPrimitive.getGraphicObject().GetPrefSize(),
rGraphicPrimitive.getGraphicObject().GetPrefMapMode(), aMapMode100thmm));
const double fDivX(aBitmapSize.Width() - rAttr.GetLeftCrop() - rAttr.GetRightCrop());
const double fDivY(aBitmapSize.Height() - rAttr.GetTopCrop() - rAttr.GetBottomCrop());
if(!basegfx::fTools::equalZero(fDivX))
{
fFactorX = aScale.getX() / fDivX;
}
if(!basegfx::fTools::equalZero(fDivY))
{
fFactorY = aScale.getY() / fDivY;
}
}
// calculate crop range and rect
basegfx::B2DRange aCropRange;
aCropRange.expand(aCurrentRange.getMinimum() - basegfx::B2DPoint(rAttr.GetLeftCrop() * fFactorX, rAttr.GetTopCrop() * fFactorY));
aCropRange.expand(aCurrentRange.getMaximum() + basegfx::B2DPoint(rAttr.GetRightCrop() * fFactorX, rAttr.GetBottomCrop() * fFactorY));
aCropRect = ::tools::Rectangle(
sal_Int32(floor(aCropRange.getMinX())), sal_Int32(floor(aCropRange.getMinY())),
sal_Int32(ceil(aCropRange.getMaxX())), sal_Int32(ceil(aCropRange.getMaxY())));
}
// Create image alternative description from ObjectInfoPrimitive2D info
// for PDF export
if(mpPDFExtOutDevData->GetIsExportTaggedPDF() && nullptr != getObjectInfoPrimitive2D())
{
OUString aAlternateDescription;
if(!getObjectInfoPrimitive2D()->getTitle().isEmpty())
{
aAlternateDescription += getObjectInfoPrimitive2D()->getTitle();
}
if(!getObjectInfoPrimitive2D()->getDesc().isEmpty())
{
if(!aAlternateDescription.isEmpty())
{
aAlternateDescription += " - ";
}
aAlternateDescription += getObjectInfoPrimitive2D()->getDesc();
}
// Use SetAlternateText to set it. This will work as long as some
// structure is used (see PDFWriterImpl::setAlternateText and
// m_nCurrentStructElement - tagged PDF export works with this in
// Draw/Impress/Writer, but not in Calc due to too less structure...)
//Z maybe add structure to Calc PDF export, may need some BeginGroup/EndGroup stuff ..?
if(!aAlternateDescription.isEmpty())
{
mpPDFExtOutDevData->SetAlternateText(aAlternateDescription);
}
}
// #i123295# 3rd param is uncropped rect, 4th is cropped. The primitive has the cropped
// object transformation, thus aCurrentRect *is* the clip region while aCropRect is the expanded,
// uncropped region. Thus, correct order is aCropRect, aCurrentRect
mpPDFExtOutDevData->EndGroup(
rGraphicPrimitive.getGraphicObject().GetGraphic(),
rAttr.GetTransparency(),
aCropRect,
aCurrentRect);
processPolygonStrokeArrowPrimitive2D(
static_cast<const primitive2d::PolygonStrokeArrowPrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::processControlPrimitive2D(const primitive2d::ControlPrimitive2D& rControlPrimitive)
case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D:
{
const uno::Reference< awt::XControl >& rXControl(rControlPrimitive.getXControl());
bool bIsPrintableControl(false);
// find out if control is printable
if(rXControl.is())
{
try
{
uno::Reference< beans::XPropertySet > xModelProperties(rXControl->getModel(), uno::UNO_QUERY);
uno::Reference< beans::XPropertySetInfo > xPropertyInfo(xModelProperties.is()
? xModelProperties->getPropertySetInfo()
: uno::Reference< beans::XPropertySetInfo >());
const OUString sPrintablePropertyName("Printable");
if(xPropertyInfo.is() && xPropertyInfo->hasPropertyByName(sPrintablePropertyName))
{
OSL_VERIFY(xModelProperties->getPropertyValue(sPrintablePropertyName) >>= bIsPrintableControl);
}
}
catch(const uno::Exception&)
{
TOOLS_WARN_EXCEPTION("drawinglayer", "VclMetafileProcessor2D: No access to printable flag of Control");
}
}
// PDF export and printing only for printable controls
if(!bIsPrintableControl)
return;
const bool bPDFExport(mpPDFExtOutDevData && mpPDFExtOutDevData->GetIsExportFormFields());
bool bDoProcessRecursively(true);
if(bPDFExport)
{
// PDF export. Emulate data handling from UnoControlPDFExportContact
// I have now moved describePDFControl to toolkit, thus i can implement the PDF
// form control support now as follows
std::unique_ptr< vcl::PDFWriter::AnyWidget > pPDFControl(
::toolkitform::describePDFControl( rXControl, *mpPDFExtOutDevData ) );
if (pPDFControl)
{
// still need to fill in the location (is a class Rectangle)
const basegfx::B2DRange aRangeLogic(rControlPrimitive.getB2DRange(getViewInformation2D()));
const ::tools::Rectangle aRectLogic(
static_cast<sal_Int32>(floor(aRangeLogic.getMinX())), static_cast<sal_Int32>(floor(aRangeLogic.getMinY())),
static_cast<sal_Int32>(ceil(aRangeLogic.getMaxX())), static_cast<sal_Int32>(ceil(aRangeLogic.getMaxY())));
pPDFControl->Location = aRectLogic;
Size aFontSize(pPDFControl->TextFont.GetFontSize());
aFontSize = OutputDevice::LogicToLogic(aFontSize, MapMode(MapUnit::MapPoint), mpOutputDevice->GetMapMode());
pPDFControl->TextFont.SetFontSize(aFontSize);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::Form);
mpPDFExtOutDevData->CreateControl(*pPDFControl);
mpPDFExtOutDevData->EndStructureElement();
// no normal paint needed (see original UnoControlPDFExportContact::do_PaintObject);
// do not process recursively
bDoProcessRecursively = false;
}
else
{
// PDF export did not work, try simple output.
// Fallback to printer output by not setting bDoProcessRecursively
// to false.
}
}
// #i93169# used flag the wrong way; true means that nothing was done yet
if(bDoProcessRecursively)
{
// printer output
try
{
// remember old graphics and create new
uno::Reference< awt::XView > xControlView(rXControl, uno::UNO_QUERY_THROW);
const uno::Reference< awt::XGraphics > xOriginalGraphics(xControlView->getGraphics());
const uno::Reference< awt::XGraphics > xNewGraphics(mpOutputDevice->CreateUnoGraphics());
if(xNewGraphics.is())
{
// link graphics and view
xControlView->setGraphics(xNewGraphics);
// get position
const basegfx::B2DHomMatrix aObjectToDiscrete(getViewInformation2D().getObjectToViewTransformation() * rControlPrimitive.getTransform());
const basegfx::B2DPoint aTopLeftDiscrete(aObjectToDiscrete * basegfx::B2DPoint(0.0, 0.0));
// draw it
xControlView->draw(basegfx::fround(aTopLeftDiscrete.getX()), basegfx::fround(aTopLeftDiscrete.getY()));
bDoProcessRecursively = false;
// restore original graphics
xControlView->setGraphics(xOriginalGraphics);
}
}
catch( const uno::Exception& )
{
TOOLS_WARN_EXCEPTION("drawinglayer", "VclMetafileProcessor2D: Printing of Control failed");
}
}
// process recursively if not done yet to export as decomposition (bitmap)
if(bDoProcessRecursively)
{
process(rControlPrimitive);
}
// direct draw of transformed BitmapEx primitive; use default processing, but without
// former testing if graphic content is inside discrete local viewport; this is not
// setup for metafile targets (metafile renderer tries to render in logic coordinates,
// the mapping is kept to the OutputDevice for better Metafile recording)
RenderBitmapPrimitive2D(static_cast<const primitive2d::BitmapPrimitive2D&>(rCandidate));
break;
}
void VclMetafileProcessor2D::processTextHierarchyFieldPrimitive2D(const primitive2d::TextHierarchyFieldPrimitive2D& rFieldPrimitive)
case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D:
{
// support for FIELD_SEQ_BEGIN, FIELD_SEQ_END and URL. It wraps text primitives (but is not limited to)
// thus do the MetafileAction embedding stuff but just handle recursively.
const OString aCommentStringCommon("FIELD_SEQ_BEGIN");
const OString aCommentStringPage("FIELD_SEQ_BEGIN;PageField");
const OString aCommentStringEnd("FIELD_SEQ_END");
OUString aURL;
switch(rFieldPrimitive.getType())
{
default : // case drawinglayer::primitive2d::FIELD_TYPE_COMMON :
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringCommon));
break;
}
case drawinglayer::primitive2d::FIELD_TYPE_PAGE :
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringPage));
break;
}
case drawinglayer::primitive2d::FIELD_TYPE_URL :
{
aURL = rFieldPrimitive.getValue("URL");
if (!aURL.isEmpty())
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringCommon, 0, reinterpret_cast<const sal_uInt8*>(aURL.getStr()), 2 * aURL.getLength()));
}
break;
}
}
processPolyPolygonGraphicPrimitive2D(
static_cast<const primitive2d::PolyPolygonGraphicPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D:
{
processPolyPolygonHatchPrimitive2D(
static_cast<const primitive2d::PolyPolygonHatchPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D:
{
processPolyPolygonGradientPrimitive2D(
static_cast<const primitive2d::PolyPolygonGradientPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D:
{
processPolyPolygonColorPrimitive2D(
static_cast<const primitive2d::PolyPolygonColorPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_MASKPRIMITIVE2D:
{
processMaskPrimitive2D(static_cast<const primitive2d::MaskPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D:
{
// modified color group. Force output to unified color. Use default pocessing.
RenderModifiedColorPrimitive2D(
static_cast<const primitive2d::ModifiedColorPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D:
{
processUnifiedTransparencePrimitive2D(
static_cast<const primitive2d::UnifiedTransparencePrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D:
{
processTransparencePrimitive2D(
static_cast<const primitive2d::TransparencePrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D:
{
// use default transform group pocessing
RenderTransformPrimitive2D(
static_cast<const primitive2d::TransformPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D:
{
// new XDrawPage for ViewInformation2D
RenderPagePreviewPrimitive2D(
static_cast<const primitive2d::PagePreviewPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D:
{
// use default marker array pocessing
RenderMarkerArrayPrimitive2D(
static_cast<const primitive2d::MarkerArrayPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D:
{
// use default point array pocessing
RenderPointArrayPrimitive2D(
static_cast<const primitive2d::PointArrayPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D:
{
processStructureTagPrimitive2D(
static_cast<const primitive2d::StructureTagPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_EPSPRIMITIVE2D:
{
RenderEpsPrimitive2D(static_cast<const primitive2d::EpsPrimitive2D&>(rCandidate));
break;
}
case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D:
{
RenderObjectInfoPrimitive2D(
static_cast<const primitive2d::ObjectInfoPrimitive2D&>(rCandidate));
break;
}
default:
{
// process recursively
primitive2d::Primitive2DContainer rContent;
rFieldPrimitive.get2DDecomposition(rContent, getViewInformation2D());
process(rContent);
// for the end comment the type is not relevant yet, they are all the same. Just add.
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringEnd));
if(!(mpPDFExtOutDevData && drawinglayer::primitive2d::FIELD_TYPE_URL == rFieldPrimitive.getType()))
return;
// emulate data handling from ImpEditEngine::Paint
const basegfx::B2DRange aViewRange(rContent.getB2DRange(getViewInformation2D()));
const ::tools::Rectangle aRectLogic(
static_cast<sal_Int32>(floor(aViewRange.getMinX())), static_cast<sal_Int32>(floor(aViewRange.getMinY())),
static_cast<sal_Int32>(ceil(aViewRange.getMaxX())), static_cast<sal_Int32>(ceil(aViewRange.getMaxY())));
vcl::PDFExtOutDevBookmarkEntry aBookmark;
aBookmark.nLinkId = mpPDFExtOutDevData->CreateLink(aRectLogic);
aBookmark.aBookmark = aURL;
std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = mpPDFExtOutDevData->GetBookmarks();
rBookmarks.push_back( aBookmark );
process(rCandidate);
break;
}
}
}
void VclMetafileProcessor2D::processTextHierarchyLinePrimitive2D(const primitive2d::TextHierarchyLinePrimitive2D& rLinePrimitive)
void VclMetafileProcessor2D::processGraphicPrimitive2D(
const primitive2d::GraphicPrimitive2D& rGraphicPrimitive)
{
bool bUsingPDFExtOutDevData(false);
basegfx::B2DVector aTranslate, aScale;
static bool bSuppressPDFExtOutDevDataSupport(false); // loplugin:constvars:ignore
if (mpPDFExtOutDevData && !bSuppressPDFExtOutDevDataSupport)
{
// emulate data handling from UnoControlPDFExportContact, original see
// svtools/source/graphic/grfmgr.cxx
const Graphic& rGraphic = rGraphicPrimitive.getGraphicObject().GetGraphic();
if (rGraphic.IsGfxLink())
{
const OString aCommentString("XTEXT_EOL");
const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr();
// process recursively and add MetaFile comment
process(rLinePrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
}
void VclMetafileProcessor2D::processTextHierarchyBulletPrimitive2D(const primitive2d::TextHierarchyBulletPrimitive2D& rBulletPrimitive)
{
// in Outliner::PaintBullet(), a MetafileComment for bullets is added, too. The
// "XTEXT_EOC" is used, use here, too.
const OString aCommentString("XTEXT_EOC");
// this is a part of list item, start LILabel ( = bullet)
if(mbInListItem)
if (!rAttr.IsSpecialDrawMode() && !rAttr.IsAdjusted())
{
maListElements.push(vcl::PDFWriter::LILabel);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::LILabel);
}
const basegfx::B2DHomMatrix& rTransform = rGraphicPrimitive.getTransform();
double fRotate, fShearX;
rTransform.decompose(aScale, aTranslate, fRotate, fShearX);
// process recursively and add MetaFile comment
process(rBulletPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
if(mbInListItem)
{
if (maListElements.top() == vcl::PDFWriter::LILabel)
if (basegfx::fTools::equalZero(fRotate) && (aScale.getX() > 0.0)
&& (aScale.getY() > 0.0))
{
maListElements.pop();
mpPDFExtOutDevData->EndStructureElement(); // end LILabel
mbBulletPresent = true;
bUsingPDFExtOutDevData = true;
mpPDFExtOutDevData->BeginGroup();
}
}
}
}
void VclMetafileProcessor2D::processTextHierarchyParagraphPrimitive2D(const primitive2d::TextHierarchyParagraphPrimitive2D& rParagraphPrimitive)
// process recursively and add MetaFile comment
process(rGraphicPrimitive);
if (!bUsingPDFExtOutDevData)
return;
// emulate data handling from UnoControlPDFExportContact, original see
// svtools/source/graphic/grfmgr.cxx
const basegfx::B2DRange aCurrentRange(aTranslate.getX(), aTranslate.getY(),
aTranslate.getX() + aScale.getX(),
aTranslate.getY() + aScale.getY());
const tools::Rectangle aCurrentRect(
sal_Int32(floor(aCurrentRange.getMinX())), sal_Int32(floor(aCurrentRange.getMinY())),
sal_Int32(ceil(aCurrentRange.getMaxX())), sal_Int32(ceil(aCurrentRange.getMaxY())));
const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr();
// fdo#72530 don't pass empty Rectangle to EndGroup
tools::Rectangle aCropRect(aCurrentRect);
if (rAttr.IsCropped())
{
// calculate scalings between real image size and logic object size. This
// is necessary since the crop values are relative to original bitmap size
double fFactorX(1.0);
double fFactorY(1.0);
{
const OString aCommentString("XTEXT_EOP");
static bool bSuppressPDFExtOutDevDataSupport(false); // loplugin:constvars:ignore
const MapMode aMapMode100thmm(MapUnit::Map100thMM);
const Size aBitmapSize(OutputDevice::LogicToLogic(
rGraphicPrimitive.getGraphicObject().GetPrefSize(),
rGraphicPrimitive.getGraphicObject().GetPrefMapMode(), aMapMode100thmm));
const double fDivX(aBitmapSize.Width() - rAttr.GetLeftCrop() - rAttr.GetRightCrop());
const double fDivY(aBitmapSize.Height() - rAttr.GetTopCrop() - rAttr.GetBottomCrop());
if(nullptr == mpPDFExtOutDevData || bSuppressPDFExtOutDevDataSupport)
if (!basegfx::fTools::equalZero(fDivX))
{
// Non-PDF export behaviour (metafile only).
// Process recursively and add MetaFile comment.
process(rParagraphPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
return;
fFactorX = aScale.getX() / fDivX;
}
if(!mpPDFExtOutDevData->GetIsExportTaggedPDF())
if (!basegfx::fTools::equalZero(fDivY))
{
// No Tagged PDF -> Dump as Paragraph
// Emulate data handling from old ImpEditEngine::Paint
mpPDFExtOutDevData->BeginStructureElement( vcl::PDFWriter::Paragraph );
fFactorY = aScale.getY() / fDivY;
}
}
// Process recursively and add MetaFile comment
process(rParagraphPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
// calculate crop range and rect
basegfx::B2DRange aCropRange;
aCropRange.expand(
aCurrentRange.getMinimum()
- basegfx::B2DPoint(rAttr.GetLeftCrop() * fFactorX, rAttr.GetTopCrop() * fFactorY));
aCropRange.expand(
aCurrentRange.getMaximum()
+ basegfx::B2DPoint(rAttr.GetRightCrop() * fFactorX, rAttr.GetBottomCrop() * fFactorY));
// Emulate data handling from ImpEditEngine::Paint
mpPDFExtOutDevData->EndStructureElement();
return;
aCropRect = tools::Rectangle(
sal_Int32(floor(aCropRange.getMinX())), sal_Int32(floor(aCropRange.getMinY())),
sal_Int32(ceil(aCropRange.getMaxX())), sal_Int32(ceil(aCropRange.getMaxY())));
}
// Create image alternative description from ObjectInfoPrimitive2D info
// for PDF export
if (mpPDFExtOutDevData->GetIsExportTaggedPDF() && nullptr != getObjectInfoPrimitive2D())
{
OUString aAlternateDescription;
if (!getObjectInfoPrimitive2D()->getTitle().isEmpty())
{
aAlternateDescription += getObjectInfoPrimitive2D()->getTitle();
}
if (!getObjectInfoPrimitive2D()->getDesc().isEmpty())
{
if (!aAlternateDescription.isEmpty())
{
aAlternateDescription += " - ";
}
// Create Tagged PDF -> deeper tagged data using StructureElements.
// Use OutlineLevel from ParagraphPrimitive, ensure not below -1 what
// means 'not active'
const sal_Int16 nNewOutlineLevel(std::max(static_cast<sal_Int16>(-1), rParagraphPrimitive.getOutlineLevel()));
aAlternateDescription += getObjectInfoPrimitive2D()->getDesc();
}
// Do we have a change in OutlineLevel compared to the current one?
if(nNewOutlineLevel != mnCurrentOutlineLevel)
// Use SetAlternateText to set it. This will work as long as some
// structure is used (see PDFWriterImpl::setAlternateText and
// m_nCurrentStructElement - tagged PDF export works with this in
// Draw/Impress/Writer, but not in Calc due to too less structure...)
//Z maybe add structure to Calc PDF export, may need some BeginGroup/EndGroup stuff ..?
if (!aAlternateDescription.isEmpty())
{
mpPDFExtOutDevData->SetAlternateText(aAlternateDescription);
}
}
// #i123295# 3rd param is uncropped rect, 4th is cropped. The primitive has the cropped
// object transformation, thus aCurrentRect *is* the clip region while aCropRect is the expanded,
// uncropped region. Thus, correct order is aCropRect, aCurrentRect
mpPDFExtOutDevData->EndGroup(rGraphicPrimitive.getGraphicObject().GetGraphic(),
rAttr.GetTransparency(), aCropRect, aCurrentRect);
}
void VclMetafileProcessor2D::processControlPrimitive2D(
const primitive2d::ControlPrimitive2D& rControlPrimitive)
{
const uno::Reference<awt::XControl>& rXControl(rControlPrimitive.getXControl());
bool bIsPrintableControl(false);
// find out if control is printable
if (rXControl.is())
{
try
{
uno::Reference<beans::XPropertySet> xModelProperties(rXControl->getModel(),
uno::UNO_QUERY);
uno::Reference<beans::XPropertySetInfo> xPropertyInfo(
xModelProperties.is() ? xModelProperties->getPropertySetInfo()
: uno::Reference<beans::XPropertySetInfo>());
const OUString sPrintablePropertyName("Printable");
if (xPropertyInfo.is() && xPropertyInfo->hasPropertyByName(sPrintablePropertyName))
{
if(nNewOutlineLevel > mnCurrentOutlineLevel)
OSL_VERIFY(xModelProperties->getPropertyValue(sPrintablePropertyName)
>>= bIsPrintableControl);
}
}
catch (const uno::Exception&)
{
TOOLS_WARN_EXCEPTION("drawinglayer",
"VclMetafileProcessor2D: No access to printable flag of Control");
}
}
// PDF export and printing only for printable controls
if (!bIsPrintableControl)
return;
const bool bPDFExport(mpPDFExtOutDevData && mpPDFExtOutDevData->GetIsExportFormFields());
bool bDoProcessRecursively(true);
if (bPDFExport)
{
// PDF export. Emulate data handling from UnoControlPDFExportContact
// I have now moved describePDFControl to toolkit, thus i can implement the PDF
// form control support now as follows
std::unique_ptr<vcl::PDFWriter::AnyWidget> pPDFControl(
::toolkitform::describePDFControl(rXControl, *mpPDFExtOutDevData));
if (pPDFControl)
{
// still need to fill in the location (is a class Rectangle)
const basegfx::B2DRange aRangeLogic(
rControlPrimitive.getB2DRange(getViewInformation2D()));
const tools::Rectangle aRectLogic(static_cast<sal_Int32>(floor(aRangeLogic.getMinX())),
static_cast<sal_Int32>(floor(aRangeLogic.getMinY())),
static_cast<sal_Int32>(ceil(aRangeLogic.getMaxX())),
static_cast<sal_Int32>(ceil(aRangeLogic.getMaxY())));
pPDFControl->Location = aRectLogic;
Size aFontSize(pPDFControl->TextFont.GetFontSize());
aFontSize = OutputDevice::LogicToLogic(aFontSize, MapMode(MapUnit::MapPoint),
mpOutputDevice->GetMapMode());
pPDFControl->TextFont.SetFontSize(aFontSize);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::Form);
mpPDFExtOutDevData->CreateControl(*pPDFControl);
mpPDFExtOutDevData->EndStructureElement();
// no normal paint needed (see original UnoControlPDFExportContact::do_PaintObject);
// do not process recursively
bDoProcessRecursively = false;
}
else
{
// PDF export did not work, try simple output.
// Fallback to printer output by not setting bDoProcessRecursively
// to false.
}
}
// #i93169# used flag the wrong way; true means that nothing was done yet
if (bDoProcessRecursively)
{
// printer output
try
{
// remember old graphics and create new
uno::Reference<awt::XView> xControlView(rXControl, uno::UNO_QUERY_THROW);
const uno::Reference<awt::XGraphics> xOriginalGraphics(xControlView->getGraphics());
const uno::Reference<awt::XGraphics> xNewGraphics(mpOutputDevice->CreateUnoGraphics());
if (xNewGraphics.is())
{
// link graphics and view
xControlView->setGraphics(xNewGraphics);
// get position
const basegfx::B2DHomMatrix aObjectToDiscrete(
getViewInformation2D().getObjectToViewTransformation()
* rControlPrimitive.getTransform());
const basegfx::B2DPoint aTopLeftDiscrete(aObjectToDiscrete
* basegfx::B2DPoint(0.0, 0.0));
// draw it
xControlView->draw(basegfx::fround(aTopLeftDiscrete.getX()),
basegfx::fround(aTopLeftDiscrete.getY()));
bDoProcessRecursively = false;
// restore original graphics
xControlView->setGraphics(xOriginalGraphics);
}
}
catch (const uno::Exception&)
{
TOOLS_WARN_EXCEPTION("drawinglayer",
"VclMetafileProcessor2D: Printing of Control failed");
}
}
// process recursively if not done yet to export as decomposition (bitmap)
if (bDoProcessRecursively)
{
process(rControlPrimitive);
}
}
void VclMetafileProcessor2D::processTextHierarchyFieldPrimitive2D(
const primitive2d::TextHierarchyFieldPrimitive2D& rFieldPrimitive)
{
// support for FIELD_SEQ_BEGIN, FIELD_SEQ_END and URL. It wraps text primitives (but is not limited to)
// thus do the MetafileAction embedding stuff but just handle recursively.
const OString aCommentStringCommon("FIELD_SEQ_BEGIN");
const OString aCommentStringPage("FIELD_SEQ_BEGIN;PageField");
const OString aCommentStringEnd("FIELD_SEQ_END");
OUString aURL;
switch (rFieldPrimitive.getType())
{
default: // case drawinglayer::primitive2d::FIELD_TYPE_COMMON :
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringCommon));
break;
}
case drawinglayer::primitive2d::FIELD_TYPE_PAGE:
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringPage));
break;
}
case drawinglayer::primitive2d::FIELD_TYPE_URL:
{
aURL = rFieldPrimitive.getValue("URL");
if (!aURL.isEmpty())
{
mpMetaFile->AddAction(new MetaCommentAction(
aCommentStringCommon, 0, reinterpret_cast<const sal_uInt8*>(aURL.getStr()),
2 * aURL.getLength()));
}
break;
}
}
// process recursively
primitive2d::Primitive2DContainer rContent;
rFieldPrimitive.get2DDecomposition(rContent, getViewInformation2D());
process(rContent);
// for the end comment the type is not relevant yet, they are all the same. Just add.
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringEnd));
if (!(mpPDFExtOutDevData
&& drawinglayer::primitive2d::FIELD_TYPE_URL == rFieldPrimitive.getType()))
return;
// emulate data handling from ImpEditEngine::Paint
const basegfx::B2DRange aViewRange(rContent.getB2DRange(getViewInformation2D()));
const tools::Rectangle aRectLogic(static_cast<sal_Int32>(floor(aViewRange.getMinX())),
static_cast<sal_Int32>(floor(aViewRange.getMinY())),
static_cast<sal_Int32>(ceil(aViewRange.getMaxX())),
static_cast<sal_Int32>(ceil(aViewRange.getMaxY())));
vcl::PDFExtOutDevBookmarkEntry aBookmark;
aBookmark.nLinkId = mpPDFExtOutDevData->CreateLink(aRectLogic);
aBookmark.aBookmark = aURL;
std::vector<vcl::PDFExtOutDevBookmarkEntry>& rBookmarks = mpPDFExtOutDevData->GetBookmarks();
rBookmarks.push_back(aBookmark);
}
void VclMetafileProcessor2D::processTextHierarchyLinePrimitive2D(
const primitive2d::TextHierarchyLinePrimitive2D& rLinePrimitive)
{
const OString aCommentString("XTEXT_EOL");
// process recursively and add MetaFile comment
process(rLinePrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
}
void VclMetafileProcessor2D::processTextHierarchyBulletPrimitive2D(
const primitive2d::TextHierarchyBulletPrimitive2D& rBulletPrimitive)
{
// in Outliner::PaintBullet(), a MetafileComment for bullets is added, too. The
// "XTEXT_EOC" is used, use here, too.
const OString aCommentString("XTEXT_EOC");
// this is a part of list item, start LILabel ( = bullet)
if (mbInListItem)
{
maListElements.push(vcl::PDFWriter::LILabel);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::LILabel);
}
// process recursively and add MetaFile comment
process(rBulletPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
if (mbInListItem)
{
if (maListElements.top() == vcl::PDFWriter::LILabel)
{
maListElements.pop();
mpPDFExtOutDevData->EndStructureElement(); // end LILabel
mbBulletPresent = true;
}
}
}
void VclMetafileProcessor2D::processTextHierarchyParagraphPrimitive2D(
const primitive2d::TextHierarchyParagraphPrimitive2D& rParagraphPrimitive)
{
const OString aCommentString("XTEXT_EOP");
static bool bSuppressPDFExtOutDevDataSupport(false); // loplugin:constvars:ignore
if (nullptr == mpPDFExtOutDevData || bSuppressPDFExtOutDevDataSupport)
{
// Non-PDF export behaviour (metafile only).
// Process recursively and add MetaFile comment.
process(rParagraphPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
return;
}
if (!mpPDFExtOutDevData->GetIsExportTaggedPDF())
{
// No Tagged PDF -> Dump as Paragraph
// Emulate data handling from old ImpEditEngine::Paint
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::Paragraph);
// Process recursively and add MetaFile comment
process(rParagraphPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
// Emulate data handling from ImpEditEngine::Paint
mpPDFExtOutDevData->EndStructureElement();
return;
}
// Create Tagged PDF -> deeper tagged data using StructureElements.
// Use OutlineLevel from ParagraphPrimitive, ensure not below -1 what
// means 'not active'
const sal_Int16 nNewOutlineLevel(
std::max(static_cast<sal_Int16>(-1), rParagraphPrimitive.getOutlineLevel()));
// Do we have a change in OutlineLevel compared to the current one?
if (nNewOutlineLevel != mnCurrentOutlineLevel)
{
if (nNewOutlineLevel > mnCurrentOutlineLevel)
{
// increase List level
for (sal_Int16 a(mnCurrentOutlineLevel); a != nNewOutlineLevel; ++a)
{
maListElements.push(vcl::PDFWriter::List);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::List);
}
}
else // if(nNewOutlineLevel < mnCurrentOutlineLevel)
{
// close list levels below nNewOutlineLevel completely by removing
// list items as well as list tag itself
for (sal_Int16 a(nNewOutlineLevel); a < mnCurrentOutlineLevel; ++a)
{
popList(); // end LBody LI and L
}
// on nNewOutlineLevel close the previous list item (LBody and LI)
popListItem();
}
// Remember new current OutlineLevel
mnCurrentOutlineLevel = nNewOutlineLevel;
}
else // the same list level
{
// close the previous list item (LBody and LI)
popListItem();
}
const bool bDumpAsListItem(-1 != mnCurrentOutlineLevel);
if (bDumpAsListItem)
{
// Dump as ListItem
maListElements.push(vcl::PDFWriter::ListItem);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::ListItem);
mbInListItem = true;
}
else
{
// Dump as Paragraph
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::Paragraph);
}
// Process recursively and add MetaFile comment
process(rParagraphPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
if (bDumpAsListItem)
mbInListItem = false;
else
mpPDFExtOutDevData->EndStructureElement(); // end Paragraph
}
void VclMetafileProcessor2D::processTextHierarchyBlockPrimitive2D(
const primitive2d::TextHierarchyBlockPrimitive2D& rBlockPrimitive)
{
const OString aCommentStringA("XTEXT_PAINTSHAPE_BEGIN");
const OString aCommentStringB("XTEXT_PAINTSHAPE_END");
// add MetaFile comment, process recursively and add MetaFile comment
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringA));
process(rBlockPrimitive);
if (mnCurrentOutlineLevel >= 0)
{
// end any opened List structure elements (LBody, LI, L)
for (sal_Int16 a(0); a <= mnCurrentOutlineLevel; ++a)
{
popList();
}
}
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringB));
}
void VclMetafileProcessor2D::processTextSimplePortionPrimitive2D(
const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate)
{
// Adapt evtl. used special DrawMode
const DrawModeFlags nOriginalDrawMode(mpOutputDevice->GetDrawMode());
adaptTextToFillDrawMode();
// this is a 2nd portion of list item
// bullet has been already processed, start LIBody
if (mbInListItem && mbBulletPresent)
{
maListElements.push(vcl::PDFWriter::LIBody);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::LIBody);
}
// directdraw of text simple portion; use default processing
RenderTextSimpleOrDecoratedPortionPrimitive2D(rTextCandidate);
if (mbInListItem && mbBulletPresent)
mbBulletPresent = false;
// restore DrawMode
mpOutputDevice->SetDrawMode(nOriginalDrawMode);
// #i101169# if(pTextDecoratedCandidate)
{
// support for TEXT_ MetaFile actions only for decorated texts
if (!mxBreakIterator.is())
{
uno::Reference<uno::XComponentContext> xContext(
::comphelper::getProcessComponentContext());
mxBreakIterator = i18n::BreakIterator::create(xContext);
}
const OUString& rTxt = rTextCandidate.getText();
const sal_Int32 nTextLength(rTextCandidate.getTextLength()); // rTxt.getLength());
if (nTextLength)
{
const css::lang::Locale& rLocale = rTextCandidate.getLocale();
const sal_Int32 nTextPosition(rTextCandidate.getTextPosition());
sal_Int32 nDone;
sal_Int32 nNextCellBreak(mxBreakIterator->nextCharacters(
rTxt, nTextPosition, rLocale, css::i18n::CharacterIteratorMode::SKIPCELL, 0,
nDone));
css::i18n::Boundary nNextWordBoundary(mxBreakIterator->getWordBoundary(
rTxt, nTextPosition, rLocale, css::i18n::WordType::ANY_WORD, true));
sal_Int32 nNextSentenceBreak(
mxBreakIterator->endOfSentence(rTxt, nTextPosition, rLocale));
const OString aCommentStringA("XTEXT_EOC");
const OString aCommentStringB("XTEXT_EOW");
const OString aCommentStringC("XTEXT_EOS");
for (sal_Int32 i(nTextPosition); i < nTextPosition + nTextLength; i++)
{
// create the entries for the respective break positions
if (i == nNextCellBreak)
{
// increase List level
for(sal_Int16 a(mnCurrentOutlineLevel); a != nNewOutlineLevel; ++a)
{
maListElements.push(vcl::PDFWriter::List);
mpPDFExtOutDevData->BeginStructureElement( vcl::PDFWriter::List );
}
mpMetaFile->AddAction(
new MetaCommentAction(aCommentStringA, i - nTextPosition));
nNextCellBreak = mxBreakIterator->nextCharacters(
rTxt, i, rLocale, css::i18n::CharacterIteratorMode::SKIPCELL, 1, nDone);
}
else // if(nNewOutlineLevel < mnCurrentOutlineLevel)
if (i == nNextWordBoundary.endPos)
{
// close list levels below nNewOutlineLevel completely by removing
// list items as well as list tag itself
for(sal_Int16 a(nNewOutlineLevel); a < mnCurrentOutlineLevel; ++a)
{
popList(); // end LBody LI and L
}
// on nNewOutlineLevel close the previous list item (LBody and LI)
popListItem();
}
// Remember new current OutlineLevel
mnCurrentOutlineLevel = nNewOutlineLevel;
mpMetaFile->AddAction(
new MetaCommentAction(aCommentStringB, i - nTextPosition));
nNextWordBoundary = mxBreakIterator->getWordBoundary(
rTxt, i + 1, rLocale, css::i18n::WordType::ANY_WORD, true);
}
if (i == nNextSentenceBreak)
{
mpMetaFile->AddAction(
new MetaCommentAction(aCommentStringC, i - nTextPosition));
nNextSentenceBreak = mxBreakIterator->endOfSentence(rTxt, i + 1, rLocale);
}
}
else // the same list level
{
// close the previous list item (LBody and LI)
popListItem();
}
}
}
}
const bool bDumpAsListItem(-1 != mnCurrentOutlineLevel);
void VclMetafileProcessor2D::processPolygonHairlinePrimitive2D(
const primitive2d::PolygonHairlinePrimitive2D& rHairlinePrimitive)
{
const basegfx::B2DPolygon& rBasePolygon = rHairlinePrimitive.getB2DPolygon();
if(bDumpAsListItem)
if (rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
{
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. If there are more, split the polygon in half and call recursively
basegfx::B2DPolygon aLeft, aRight;
splitLinePolygon(rBasePolygon, aLeft, aRight);
rtl::Reference<primitive2d::PolygonHairlinePrimitive2D> xPLeft(
new primitive2d::PolygonHairlinePrimitive2D(aLeft, rHairlinePrimitive.getBColor()));
rtl::Reference<primitive2d::PolygonHairlinePrimitive2D> xPRight(
new primitive2d::PolygonHairlinePrimitive2D(aRight, rHairlinePrimitive.getBColor()));
processBasePrimitive2D(*xPLeft);
processBasePrimitive2D(*xPRight);
}
else
{
// direct draw of hairline; use default processing
// support SvtGraphicStroke MetaCommentAction
const basegfx::BColor aLineColor(
maBColorModifierStack.getModifiedColor(rHairlinePrimitive.getBColor()));
std::unique_ptr<SvtGraphicStroke> pSvtGraphicStroke;
// #i121267# Not needed, does not give better quality compared with
// the MetaActionType::POLYPOLYGON written by RenderPolygonHairlinePrimitive2D
// below
const bool bSupportSvtGraphicStroke(false);
if (bSupportSvtGraphicStroke)
{
pSvtGraphicStroke
= impTryToCreateSvtGraphicStroke(rHairlinePrimitive.getB2DPolygon(), &aLineColor,
nullptr, nullptr, nullptr, nullptr);
impStartSvtGraphicStroke(pSvtGraphicStroke.get());
}
RenderPolygonHairlinePrimitive2D(rHairlinePrimitive, false);
if (bSupportSvtGraphicStroke)
{
impEndSvtGraphicStroke(pSvtGraphicStroke.get());
}
}
}
void VclMetafileProcessor2D::processPolygonStrokePrimitive2D(
const primitive2d::PolygonStrokePrimitive2D& rStrokePrimitive)
{
const basegfx::B2DPolygon& rBasePolygon = rStrokePrimitive.getB2DPolygon();
if (rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
{
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. If there are more, split the polygon in half and call recursively
basegfx::B2DPolygon aLeft, aRight;
splitLinePolygon(rBasePolygon, aLeft, aRight);
rtl::Reference<primitive2d::PolygonStrokePrimitive2D> xPLeft(
new primitive2d::PolygonStrokePrimitive2D(aLeft, rStrokePrimitive.getLineAttribute(),
rStrokePrimitive.getStrokeAttribute()));
rtl::Reference<primitive2d::PolygonStrokePrimitive2D> xPRight(
new primitive2d::PolygonStrokePrimitive2D(aRight, rStrokePrimitive.getLineAttribute(),
rStrokePrimitive.getStrokeAttribute()));
processBasePrimitive2D(*xPLeft);
processBasePrimitive2D(*xPRight);
}
else
{
mpOutputDevice->Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
// support SvtGraphicStroke MetaCommentAction
std::unique_ptr<SvtGraphicStroke> pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
rBasePolygon, nullptr, &rStrokePrimitive.getLineAttribute(),
&rStrokePrimitive.getStrokeAttribute(), nullptr, nullptr);
impStartSvtGraphicStroke(pSvtGraphicStroke.get());
const attribute::LineAttribute& rLine = rStrokePrimitive.getLineAttribute();
// create MetaPolyLineActions, but without LineStyle::Dash
if (basegfx::fTools::more(rLine.getWidth(), 0.0))
{
const attribute::StrokeAttribute& rStroke = rStrokePrimitive.getStrokeAttribute();
basegfx::B2DPolyPolygon aHairLinePolyPolygon;
if (0.0 == rStroke.getFullDotDashLen())
{
// Dump as ListItem
maListElements.push(vcl::PDFWriter::ListItem);
mpPDFExtOutDevData->BeginStructureElement( vcl::PDFWriter::ListItem );
mbInListItem = true;
aHairLinePolyPolygon.append(rBasePolygon);
}
else
{
// Dump as Paragraph
mpPDFExtOutDevData->BeginStructureElement( vcl::PDFWriter::Paragraph );
basegfx::utils::applyLineDashing(rBasePolygon, rStroke.getDotDashArray(),
&aHairLinePolyPolygon, nullptr,
rStroke.getFullDotDashLen());
}
// Process recursively and add MetaFile comment
process(rParagraphPrimitive);
mpMetaFile->AddAction(new MetaCommentAction(aCommentString));
const basegfx::BColor aHairlineColor(
maBColorModifierStack.getModifiedColor(rLine.getColor()));
mpOutputDevice->SetLineColor(Color(aHairlineColor));
mpOutputDevice->SetFillColor();
aHairLinePolyPolygon.transform(maCurrentTransformation);
if(bDumpAsListItem)
mbInListItem = false;
else
mpPDFExtOutDevData->EndStructureElement(); // end Paragraph
}
// use the transformed line width
LineInfo aLineInfo(LineStyle::Solid,
basegfx::fround(getTransformedLineWidth(rLine.getWidth())));
aLineInfo.SetLineJoin(rLine.getLineJoin());
aLineInfo.SetLineCap(rLine.getLineCap());
void VclMetafileProcessor2D::processTextHierarchyBlockPrimitive2D(const primitive2d::TextHierarchyBlockPrimitive2D& rBlockPrimitive)
{
const OString aCommentStringA("XTEXT_PAINTSHAPE_BEGIN");
const OString aCommentStringB("XTEXT_PAINTSHAPE_END");
// add MetaFile comment, process recursively and add MetaFile comment
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringA));
process(rBlockPrimitive);
if (mnCurrentOutlineLevel >= 0 )
for (sal_uInt32 a(0); a < aHairLinePolyPolygon.count(); a++)
{
// end any opened List structure elements (LBody, LI, L)
for(sal_Int16 a(0); a <= mnCurrentOutlineLevel; ++a)
const basegfx::B2DPolygon& aCandidate(aHairLinePolyPolygon.getB2DPolygon(a));
if (aCandidate.count() > 1)
{
popList();
}
}
const tools::Polygon aToolsPolygon(aCandidate);
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringB));
}
void VclMetafileProcessor2D::processTextSimplePortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate)
{
// Adapt evtl. used special DrawMode
const DrawModeFlags nOriginalDrawMode(mpOutputDevice->GetDrawMode());
adaptTextToFillDrawMode();
// this is a 2nd portion of list item
// bullet has been already processed, start LIBody
if (mbInListItem && mbBulletPresent)
{
maListElements.push(vcl::PDFWriter::LIBody);
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::LIBody);
}
// directdraw of text simple portion; use default processing
RenderTextSimpleOrDecoratedPortionPrimitive2D(rTextCandidate);
if (mbInListItem && mbBulletPresent)
mbBulletPresent = false;
// restore DrawMode
mpOutputDevice->SetDrawMode(nOriginalDrawMode);
// #i101169# if(pTextDecoratedCandidate)
{
// support for TEXT_ MetaFile actions only for decorated texts
if(!mxBreakIterator.is())
{
uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
mxBreakIterator = i18n::BreakIterator::create(xContext);
}
const OUString& rTxt = rTextCandidate.getText();
const sal_Int32 nTextLength(rTextCandidate.getTextLength()); // rTxt.getLength());
if(nTextLength)
{
const css::lang::Locale& rLocale = rTextCandidate.getLocale();
const sal_Int32 nTextPosition(rTextCandidate.getTextPosition());
sal_Int32 nDone;
sal_Int32 nNextCellBreak(mxBreakIterator->nextCharacters(rTxt, nTextPosition, rLocale, css::i18n::CharacterIteratorMode::SKIPCELL, 0, nDone));
css::i18n::Boundary nNextWordBoundary(mxBreakIterator->getWordBoundary(rTxt, nTextPosition, rLocale, css::i18n::WordType::ANY_WORD, true));
sal_Int32 nNextSentenceBreak(mxBreakIterator->endOfSentence(rTxt, nTextPosition, rLocale));
const OString aCommentStringA("XTEXT_EOC");
const OString aCommentStringB("XTEXT_EOW");
const OString aCommentStringC("XTEXT_EOS");
for(sal_Int32 i(nTextPosition); i < nTextPosition + nTextLength; i++)
{
// create the entries for the respective break positions
if(i == nNextCellBreak)
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringA, i - nTextPosition));
nNextCellBreak = mxBreakIterator->nextCharacters(rTxt, i, rLocale, css::i18n::CharacterIteratorMode::SKIPCELL, 1, nDone);
}
if(i == nNextWordBoundary.endPos)
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringB, i - nTextPosition));
nNextWordBoundary = mxBreakIterator->getWordBoundary(rTxt, i + 1, rLocale, css::i18n::WordType::ANY_WORD, true);
}
if(i == nNextSentenceBreak)
{
mpMetaFile->AddAction(new MetaCommentAction(aCommentStringC, i - nTextPosition));
nNextSentenceBreak = mxBreakIterator->endOfSentence(rTxt, i + 1, rLocale);
}
}
mpMetaFile->AddAction(new MetaPolyLineAction(aToolsPolygon, aLineInfo));
}
}
}
void VclMetafileProcessor2D::processPolygonHairlinePrimitive2D(const primitive2d::PolygonHairlinePrimitive2D& rHairlinePrimitive)
else
{
const basegfx::B2DPolygon& rBasePolygon = rHairlinePrimitive.getB2DPolygon();
process(rStrokePrimitive);
}
if(rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
impEndSvtGraphicStroke(pSvtGraphicStroke.get());
mpOutputDevice->Pop();
}
}
void VclMetafileProcessor2D::processPolygonStrokeArrowPrimitive2D(
const primitive2d::PolygonStrokeArrowPrimitive2D& rStrokeArrowPrimitive)
{
const basegfx::B2DPolygon& rBasePolygon = rStrokeArrowPrimitive.getB2DPolygon();
if (rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
{
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. If there are more, split the polygon in half and call recursively
basegfx::B2DPolygon aLeft, aRight;
splitLinePolygon(rBasePolygon, aLeft, aRight);
const attribute::LineStartEndAttribute aEmpty;
rtl::Reference<primitive2d::PolygonStrokeArrowPrimitive2D> xPLeft(
new primitive2d::PolygonStrokeArrowPrimitive2D(
aLeft, rStrokeArrowPrimitive.getLineAttribute(),
rStrokeArrowPrimitive.getStrokeAttribute(), rStrokeArrowPrimitive.getStart(),
aEmpty));
rtl::Reference<primitive2d::PolygonStrokeArrowPrimitive2D> xPRight(
new primitive2d::PolygonStrokeArrowPrimitive2D(
aRight, rStrokeArrowPrimitive.getLineAttribute(),
rStrokeArrowPrimitive.getStrokeAttribute(), aEmpty,
rStrokeArrowPrimitive.getEnd()));
processBasePrimitive2D(*xPLeft);
processBasePrimitive2D(*xPRight);
}
else
{
// support SvtGraphicStroke MetaCommentAction
std::unique_ptr<SvtGraphicStroke> pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
rBasePolygon, nullptr, &rStrokeArrowPrimitive.getLineAttribute(),
&rStrokeArrowPrimitive.getStrokeAttribute(), &rStrokeArrowPrimitive.getStart(),
&rStrokeArrowPrimitive.getEnd());
// write LineGeometry start marker
impStartSvtGraphicStroke(pSvtGraphicStroke.get());
// #i116162# When B&W is set as DrawMode, DrawModeFlags::WhiteFill is used
// to let all fills be just white; for lines DrawModeFlags::BlackLine is used
// so all line geometry is supposed to get black. Since in the in-between
// stages of line geometry drawing filled polygons are used (e.g. line
// start/ends) it is necessary to change these drawmodes to preserve
// that lines shall be black; thus change DrawModeFlags::WhiteFill to
// DrawModeFlags::BlackFill during line geometry processing to have line geometry
// parts filled black.
const DrawModeFlags nOldDrawMode(mpOutputDevice->GetDrawMode());
const bool bDrawmodeChange(nOldDrawMode & DrawModeFlags::WhiteFill
&& mnSvtGraphicStrokeCount);
if (bDrawmodeChange)
{
mpOutputDevice->SetDrawMode((nOldDrawMode & ~DrawModeFlags::WhiteFill)
| DrawModeFlags::BlackFill);
}
// process sub-line geometry (evtl. filled PolyPolygons)
process(rStrokeArrowPrimitive);
if (bDrawmodeChange)
{
mpOutputDevice->SetDrawMode(nOldDrawMode);
}
// write LineGeometry end marker
impEndSvtGraphicStroke(pSvtGraphicStroke.get());
}
}
void VclMetafileProcessor2D::processPolyPolygonGraphicPrimitive2D(
const primitive2d::PolyPolygonGraphicPrimitive2D& rBitmapCandidate)
{
// need to handle PolyPolygonGraphicPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END
basegfx::B2DPolyPolygon aLocalPolyPolygon(rBitmapCandidate.getB2DPolyPolygon());
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
std::unique_ptr<SvtGraphicFill> pSvtGraphicFill;
if (!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
{
// #121194# Changed implementation and checked usages of convert to metafile,
// presentation start (uses SvtGraphicFill) and printing.
// calculate transformation. Get real object size, all values in FillGraphicAttribute
// are relative to the unified object
aLocalPolyPolygon.transform(maCurrentTransformation);
const basegfx::B2DVector aOutlineSize(aLocalPolyPolygon.getB2DRange().getRange());
// the scaling needs scale from pixel to logic coordinate system
const attribute::FillGraphicAttribute& rFillGraphicAttribute
= rBitmapCandidate.getFillGraphic();
const Size aBmpSizePixel(rFillGraphicAttribute.getGraphic().GetSizePixel());
// setup transformation like in impgrfll. Multiply with aOutlineSize
// to get from unit coordinates in rFillGraphicAttribute.getGraphicRange()
// to object coordinates with object's top left being at (0,0). Divide
// by pixel size so that scale from pixel to logic will work in SvtGraphicFill.
const basegfx::B2DVector aTransformScale(
rFillGraphicAttribute.getGraphicRange().getRange()
/ basegfx::B2DVector(std::max(1.0, double(aBmpSizePixel.Width())),
std::max(1.0, double(aBmpSizePixel.Height())))
* aOutlineSize);
const basegfx::B2DPoint aTransformPosition(
rFillGraphicAttribute.getGraphicRange().getMinimum() * aOutlineSize);
// setup transformation like in impgrfll
SvtGraphicFill::Transform aTransform;
// scale values are divided by bitmap pixel sizes
aTransform.matrix[0] = aTransformScale.getX();
aTransform.matrix[4] = aTransformScale.getY();
// translates are absolute
aTransform.matrix[2] = aTransformPosition.getX();
aTransform.matrix[5] = aTransformPosition.getY();
pSvtGraphicFill.reset(new SvtGraphicFill(
getFillPolyPolygon(aLocalPolyPolygon), Color(), 0.0, SvtGraphicFill::fillEvenOdd,
SvtGraphicFill::fillTexture, aTransform, rFillGraphicAttribute.getTiling(),
SvtGraphicFill::hatchSingle, Color(), SvtGraphicFill::GradientType::Linear, Color(),
Color(), 0, rFillGraphicAttribute.getGraphic()));
}
// Do use decomposition; encapsulate with SvtGraphicFill
impStartSvtGraphicFill(pSvtGraphicFill.get());
process(rBitmapCandidate);
impEndSvtGraphicFill(pSvtGraphicFill.get());
}
void VclMetafileProcessor2D::processPolyPolygonHatchPrimitive2D(
const primitive2d::PolyPolygonHatchPrimitive2D& rHatchCandidate)
{
// need to handle PolyPolygonHatchPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END
const attribute::FillHatchAttribute& rFillHatchAttribute = rHatchCandidate.getFillHatch();
basegfx::B2DPolyPolygon aLocalPolyPolygon(rHatchCandidate.getB2DPolyPolygon());
if (aLocalPolyPolygon.getB2DRange() != rHatchCandidate.getDefinitionRange())
{
// the range which defines the hatch is different from the range of the
// geometry (used for writer frames). This cannot be done calling vcl, thus use
// decomposition here
process(rHatchCandidate);
return;
}
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
if (rFillHatchAttribute.isFillBackground())
{
// with fixing #i111954# (see below) the possible background
// fill of a hatched object was lost.Generate a background fill
// primitive and render it
const primitive2d::Primitive2DReference xBackground(
new primitive2d::PolyPolygonColorPrimitive2D(aLocalPolyPolygon,
rHatchCandidate.getBackgroundColor()));
process(primitive2d::Primitive2DContainer{ xBackground });
}
std::unique_ptr<SvtGraphicFill> pSvtGraphicFill;
aLocalPolyPolygon.transform(maCurrentTransformation);
if (!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
{
// re-create a VCL hatch as base data
SvtGraphicFill::HatchType eHatch(SvtGraphicFill::hatchSingle);
switch (rFillHatchAttribute.getStyle())
{
default: // attribute::HatchStyle::Single :
{
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. If there are more, split the polygon in half and call recursively
basegfx::B2DPolygon aLeft, aRight;
splitLinePolygon(rBasePolygon, aLeft, aRight);
rtl::Reference< primitive2d::PolygonHairlinePrimitive2D > xPLeft(new primitive2d::PolygonHairlinePrimitive2D(aLeft, rHairlinePrimitive.getBColor()));
rtl::Reference< primitive2d::PolygonHairlinePrimitive2D > xPRight(new primitive2d::PolygonHairlinePrimitive2D(aRight, rHairlinePrimitive.getBColor()));
processBasePrimitive2D(*xPLeft);
processBasePrimitive2D(*xPRight);
eHatch = SvtGraphicFill::hatchSingle;
break;
}
else
case attribute::HatchStyle::Double:
{
// direct draw of hairline; use default processing
// support SvtGraphicStroke MetaCommentAction
const basegfx::BColor aLineColor(maBColorModifierStack.getModifiedColor(rHairlinePrimitive.getBColor()));
std::unique_ptr<SvtGraphicStroke> pSvtGraphicStroke;
// #i121267# Not needed, does not give better quality compared with
// the MetaActionType::POLYPOLYGON written by RenderPolygonHairlinePrimitive2D
// below
const bool bSupportSvtGraphicStroke(false);
if(bSupportSvtGraphicStroke)
{
pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
rHairlinePrimitive.getB2DPolygon(),
&aLineColor,
nullptr, nullptr, nullptr, nullptr);
impStartSvtGraphicStroke(pSvtGraphicStroke.get());
}
RenderPolygonHairlinePrimitive2D(rHairlinePrimitive, false);
if(bSupportSvtGraphicStroke)
{
impEndSvtGraphicStroke(pSvtGraphicStroke.get());
}
eHatch = SvtGraphicFill::hatchDouble;
break;
}
case attribute::HatchStyle::Triple:
{
eHatch = SvtGraphicFill::hatchTriple;
break;
}
}
void VclMetafileProcessor2D::processPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D& rStrokePrimitive)
SvtGraphicFill::Transform aTransform;
// scale
aTransform.matrix[0] *= rFillHatchAttribute.getDistance();
aTransform.matrix[4] *= rFillHatchAttribute.getDistance();
// rotate (was never correct in impgrfll anyways, use correct angle now)
aTransform.matrix[0] *= cos(rFillHatchAttribute.getAngle());
aTransform.matrix[1] *= -sin(rFillHatchAttribute.getAngle());
aTransform.matrix[3] *= sin(rFillHatchAttribute.getAngle());
aTransform.matrix[4] *= cos(rFillHatchAttribute.getAngle());
pSvtGraphicFill.reset(new SvtGraphicFill(
getFillPolyPolygon(aLocalPolyPolygon), Color(), 0.0, SvtGraphicFill::fillEvenOdd,
SvtGraphicFill::fillHatch, aTransform, false, eHatch,
Color(maBColorModifierStack.getModifiedColor(rFillHatchAttribute.getColor())),
SvtGraphicFill::GradientType::Linear, Color(), Color(), 0, Graphic()));
}
// Do use decomposition; encapsulate with SvtGraphicFill
impStartSvtGraphicFill(pSvtGraphicFill.get());
// #i111954# do NOT use decomposition, but use direct VCL-command
// process(rCandidate.get2DDecomposition(getViewInformation2D()));
const tools::PolyPolygon aToolsPolyPolygon(
basegfx::utils::adaptiveSubdivideByAngle(aLocalPolyPolygon));
const HatchStyle aHatchStyle(
attribute::HatchStyle::Single == rFillHatchAttribute.getStyle()
? HatchStyle::Single
: attribute::HatchStyle::Double == rFillHatchAttribute.getStyle() ? HatchStyle::Double
: HatchStyle::Triple);
mpOutputDevice->DrawHatch(
aToolsPolyPolygon,
Hatch(aHatchStyle,
Color(maBColorModifierStack.getModifiedColor(rFillHatchAttribute.getColor())),
basegfx::fround(rFillHatchAttribute.getDistance()),
basegfx::fround(rFillHatchAttribute.getAngle() / F_PI1800)));
impEndSvtGraphicFill(pSvtGraphicFill.get());
}
void VclMetafileProcessor2D::processPolyPolygonGradientPrimitive2D(
const primitive2d::PolyPolygonGradientPrimitive2D& rGradientCandidate)
{
basegfx::B2DVector aScale, aTranslate;
double fRotate, fShearX;
maCurrentTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
if (!basegfx::fTools::equalZero(fRotate) || !basegfx::fTools::equalZero(fShearX))
{
// #i121185# When rotation or shear is used, a VCL Gradient cannot be used directly.
// This is because VCL Gradient mechanism does *not* support to rotate the gradient
// with objects and this case is not expressible in a Metafile (and cannot be added
// since the FileFormats used, e.g. *.wmf, do not support it either).
// Such cases happen when a graphic object uses a Metafile as graphic information or
// a fill style definition uses a Metafile. In this cases the graphic content is
// rotated with the graphic or filled object; this is not supported by the target
// format of this conversion renderer - Metafiles.
// To solve this, not a Gradient is written, but the decomposition of this object
// is written to the Metafile. This is the PolyPolygons building the gradient fill.
// These will need more space and time, but the result will be as if the Gradient
// was rotated with the object.
// This mechanism is used by all exporters still not using Primitives (e.g. Print,
// Slideshow, Export rto PDF, export to Picture, ...) but relying on Metafile
// transfers. One more reason to *change* these to primitives.
// BTW: One more example how useful the principles of primitives are; the decomposition
// is by definition a simpler, maybe more expensive representation of the same content.
process(rGradientCandidate);
return;
}
basegfx::B2DPolyPolygon aLocalPolyPolygon(rGradientCandidate.getB2DPolyPolygon());
if (aLocalPolyPolygon.getB2DRange() != rGradientCandidate.getDefinitionRange())
{
// the range which defines the gradient is different from the range of the
// geometry (used for writer frames). This cannot be done calling vcl, thus use
// decomposition here
process(rGradientCandidate);
return;
}
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
// for support of MetaCommentActions of the form XGRAD_SEQ_BEGIN, XGRAD_SEQ_END
// it is safest to use the VCL OutputDevice::DrawGradient method which creates those.
// re-create a VCL-gradient from FillGradientPrimitive2D and the needed tools PolyPolygon
Gradient aVCLGradient;
impConvertFillGradientAttributeToVCLGradient(aVCLGradient, rGradientCandidate.getFillGradient(),
false);
aLocalPolyPolygon.transform(maCurrentTransformation);
// #i82145# ATM VCL printing of gradients using curved shapes does not work,
// i submitted the bug with the given ID to THB. When that task is fixed it is
// necessary to again remove this subdivision since it decreases possible
// printing quality (not even resolution-dependent for now). THB will tell
// me when that task is fixed in the master
const tools::PolyPolygon aToolsPolyPolygon(
getFillPolyPolygon(basegfx::utils::adaptiveSubdivideByAngle(aLocalPolyPolygon)));
// XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END support
std::unique_ptr<SvtGraphicFill> pSvtGraphicFill;
if (!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
{
// setup gradient stuff like in impgrfll
SvtGraphicFill::GradientType eGrad(SvtGraphicFill::GradientType::Linear);
switch (aVCLGradient.GetStyle())
{
const basegfx::B2DPolygon& rBasePolygon = rStrokePrimitive.getB2DPolygon();
if(rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
{
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. If there are more, split the polygon in half and call recursively
basegfx::B2DPolygon aLeft, aRight;
splitLinePolygon(rBasePolygon, aLeft, aRight);
rtl::Reference< primitive2d::PolygonStrokePrimitive2D > xPLeft(new primitive2d::PolygonStrokePrimitive2D(
aLeft, rStrokePrimitive.getLineAttribute(), rStrokePrimitive.getStrokeAttribute()));
rtl::Reference< primitive2d::PolygonStrokePrimitive2D > xPRight(new primitive2d::PolygonStrokePrimitive2D(
aRight, rStrokePrimitive.getLineAttribute(), rStrokePrimitive.getStrokeAttribute()));
processBasePrimitive2D(*xPLeft);
processBasePrimitive2D(*xPRight);
}
else
{
mpOutputDevice->Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
// support SvtGraphicStroke MetaCommentAction
std::unique_ptr<SvtGraphicStroke> pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
rBasePolygon, nullptr,
&rStrokePrimitive.getLineAttribute(),
&rStrokePrimitive.getStrokeAttribute(),
nullptr, nullptr);
impStartSvtGraphicStroke(pSvtGraphicStroke.get());
const attribute::LineAttribute& rLine = rStrokePrimitive.getLineAttribute();
// create MetaPolyLineActions, but without LineStyle::Dash
if(basegfx::fTools::more(rLine.getWidth(), 0.0))
{
const attribute::StrokeAttribute& rStroke = rStrokePrimitive.getStrokeAttribute();
basegfx::B2DPolyPolygon aHairLinePolyPolygon;
if(0.0 == rStroke.getFullDotDashLen())
{
aHairLinePolyPolygon.append(rBasePolygon);
}
else
{
basegfx::utils::applyLineDashing(
rBasePolygon, rStroke.getDotDashArray(),
&aHairLinePolyPolygon, nullptr, rStroke.getFullDotDashLen());
}
const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rLine.getColor()));
mpOutputDevice->SetLineColor(Color(aHairlineColor));
mpOutputDevice->SetFillColor();
aHairLinePolyPolygon.transform(maCurrentTransformation);
// use the transformed line width
LineInfo aLineInfo(LineStyle::Solid, basegfx::fround(getTransformedLineWidth(rLine.getWidth())));
aLineInfo.SetLineJoin(rLine.getLineJoin());
aLineInfo.SetLineCap(rLine.getLineCap());
for(sal_uInt32 a(0); a < aHairLinePolyPolygon.count(); a++)
{
const basegfx::B2DPolygon& aCandidate(aHairLinePolyPolygon.getB2DPolygon(a));
if(aCandidate.count() > 1)
{
const ::tools::Polygon aToolsPolygon(aCandidate);
mpMetaFile->AddAction(new MetaPolyLineAction(aToolsPolygon, aLineInfo));
}
}
}
else
{
process(rStrokePrimitive);
}
impEndSvtGraphicStroke(pSvtGraphicStroke.get());
mpOutputDevice->Pop();
}
default: // GradientStyle::Linear:
case GradientStyle::Axial:
eGrad = SvtGraphicFill::GradientType::Linear;
break;
case GradientStyle::Radial:
case GradientStyle::Elliptical:
eGrad = SvtGraphicFill::GradientType::Radial;
break;
case GradientStyle::Square:
case GradientStyle::Rect:
eGrad = SvtGraphicFill::GradientType::Rectangular;
break;
}
void VclMetafileProcessor2D::processPolygonStrokeArrowPrimitive2D(const primitive2d::PolygonStrokeArrowPrimitive2D& rStrokeArrowPrimitive)
pSvtGraphicFill.reset(new SvtGraphicFill(
aToolsPolyPolygon, Color(), 0.0, SvtGraphicFill::fillEvenOdd,
SvtGraphicFill::fillGradient, SvtGraphicFill::Transform(), false,
SvtGraphicFill::hatchSingle, Color(), eGrad, aVCLGradient.GetStartColor(),
aVCLGradient.GetEndColor(), aVCLGradient.GetSteps(), Graphic()));
}
// call VCL directly; encapsulate with SvtGraphicFill
impStartSvtGraphicFill(pSvtGraphicFill.get());
mpOutputDevice->DrawGradient(aToolsPolyPolygon, aVCLGradient);
impEndSvtGraphicFill(pSvtGraphicFill.get());
}
void VclMetafileProcessor2D::processPolyPolygonColorPrimitive2D(
const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate)
{
mpOutputDevice->Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolygonCandidate.getB2DPolyPolygon());
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
const basegfx::BColor aPolygonColor(
maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));
aLocalPolyPolygon.transform(maCurrentTransformation);
// set line and fill color
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
mpOutputDevice->Pop();
}
void VclMetafileProcessor2D::processMaskPrimitive2D(
const primitive2d::MaskPrimitive2D& rMaskCandidate)
{
// mask group. Special handling for MetaFiles.
if (rMaskCandidate.getChildren().empty())
return;
basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
if (aMask.count())
{
// prepare new mask polygon and rescue current one
aMask.transform(maCurrentTransformation);
const basegfx::B2DPolyPolygon aLastClipPolyPolygon(maClipPolyPolygon);
if (maClipPolyPolygon.count())
{
const basegfx::B2DPolygon& rBasePolygon = rStrokeArrowPrimitive.getB2DPolygon();
if(rBasePolygon.count() > (MAX_POLYGON_POINT_COUNT_METAFILE - 1))
{
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. If there are more, split the polygon in half and call recursively
basegfx::B2DPolygon aLeft, aRight;
splitLinePolygon(rBasePolygon, aLeft, aRight);
const attribute::LineStartEndAttribute aEmpty;
rtl::Reference< primitive2d::PolygonStrokeArrowPrimitive2D > xPLeft(new primitive2d::PolygonStrokeArrowPrimitive2D(
aLeft,
rStrokeArrowPrimitive.getLineAttribute(),
rStrokeArrowPrimitive.getStrokeAttribute(),
rStrokeArrowPrimitive.getStart(),
aEmpty));
rtl::Reference< primitive2d::PolygonStrokeArrowPrimitive2D > xPRight(new primitive2d::PolygonStrokeArrowPrimitive2D(
aRight,
rStrokeArrowPrimitive.getLineAttribute(),
rStrokeArrowPrimitive.getStrokeAttribute(),
aEmpty,
rStrokeArrowPrimitive.getEnd()));
processBasePrimitive2D(*xPLeft);
processBasePrimitive2D(*xPRight);
}
else
{
// support SvtGraphicStroke MetaCommentAction
std::unique_ptr<SvtGraphicStroke> pSvtGraphicStroke = impTryToCreateSvtGraphicStroke(
rBasePolygon, nullptr,
&rStrokeArrowPrimitive.getLineAttribute(),
&rStrokeArrowPrimitive.getStrokeAttribute(),
&rStrokeArrowPrimitive.getStart(),
&rStrokeArrowPrimitive.getEnd());
// write LineGeometry start marker
impStartSvtGraphicStroke(pSvtGraphicStroke.get());
// #i116162# When B&W is set as DrawMode, DrawModeFlags::WhiteFill is used
// to let all fills be just white; for lines DrawModeFlags::BlackLine is used
// so all line geometry is supposed to get black. Since in the in-between
// stages of line geometry drawing filled polygons are used (e.g. line
// start/ends) it is necessary to change these drawmodes to preserve
// that lines shall be black; thus change DrawModeFlags::WhiteFill to
// DrawModeFlags::BlackFill during line geometry processing to have line geometry
// parts filled black.
const DrawModeFlags nOldDrawMode(mpOutputDevice->GetDrawMode());
const bool bDrawmodeChange(nOldDrawMode & DrawModeFlags::WhiteFill && mnSvtGraphicStrokeCount);
if(bDrawmodeChange)
{
mpOutputDevice->SetDrawMode((nOldDrawMode & ~DrawModeFlags::WhiteFill) | DrawModeFlags::BlackFill);
}
// process sub-line geometry (evtl. filled PolyPolygons)
process(rStrokeArrowPrimitive);
if(bDrawmodeChange)
{
mpOutputDevice->SetDrawMode(nOldDrawMode);
}
// write LineGeometry end marker
impEndSvtGraphicStroke(pSvtGraphicStroke.get());
}
// there is already a clip polygon set; build clipped union of
// current mask polygon and new one
maClipPolyPolygon = basegfx::utils::clipPolyPolygonOnPolyPolygon(
aMask, maClipPolyPolygon,
true, // #i106516# we want the inside of aMask, not the outside
false);
}
else
{
// use mask directly
maClipPolyPolygon = aMask;
}
void VclMetafileProcessor2D::processPolyPolygonGraphicPrimitive2D(const primitive2d::PolyPolygonGraphicPrimitive2D& rBitmapCandidate)
if (maClipPolyPolygon.count())
{
// need to handle PolyPolygonGraphicPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END
basegfx::B2DPolyPolygon aLocalPolyPolygon(rBitmapCandidate.getB2DPolyPolygon());
// set VCL clip region; subdivide before conversion to tools polygon. Subdivision necessary (!)
// Removed subdivision and fixed in vcl::Region::ImplPolyPolyRegionToBandRegionFunc() in VCL where
// the ClipRegion is built from the Polygon. An AdaptiveSubdivide on the source polygon was missing there
mpOutputDevice->Push(PushFlags::CLIPREGION);
mpOutputDevice->SetClipRegion(vcl::Region(maClipPolyPolygon));
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
// recursively paint content
// #i121267# Only need to process sub-content when clip polygon is *not* empty.
// If it is empty, the clip is empty and there can be nothing inside.
process(rMaskCandidate.getChildren());
std::unique_ptr<SvtGraphicFill> pSvtGraphicFill;
if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
{
// #121194# Changed implementation and checked usages of convert to metafile,
// presentation start (uses SvtGraphicFill) and printing.
// calculate transformation. Get real object size, all values in FillGraphicAttribute
// are relative to the unified object
aLocalPolyPolygon.transform(maCurrentTransformation);
const basegfx::B2DVector aOutlineSize(aLocalPolyPolygon.getB2DRange().getRange());
// the scaling needs scale from pixel to logic coordinate system
const attribute::FillGraphicAttribute& rFillGraphicAttribute = rBitmapCandidate.getFillGraphic();
const Size aBmpSizePixel(rFillGraphicAttribute.getGraphic().GetSizePixel());
// setup transformation like in impgrfll. Multiply with aOutlineSize
// to get from unit coordinates in rFillGraphicAttribute.getGraphicRange()
// to object coordinates with object's top left being at (0,0). Divide
// by pixel size so that scale from pixel to logic will work in SvtGraphicFill.
const basegfx::B2DVector aTransformScale(
rFillGraphicAttribute.getGraphicRange().getRange() /
basegfx::B2DVector(
std::max(1.0, double(aBmpSizePixel.Width())),
std::max(1.0, double(aBmpSizePixel.Height()))) *
aOutlineSize);
const basegfx::B2DPoint aTransformPosition(
rFillGraphicAttribute.getGraphicRange().getMinimum() * aOutlineSize);
// setup transformation like in impgrfll
SvtGraphicFill::Transform aTransform;
// scale values are divided by bitmap pixel sizes
aTransform.matrix[0] = aTransformScale.getX();
aTransform.matrix[4] = aTransformScale.getY();
// translates are absolute
aTransform.matrix[2] = aTransformPosition.getX();
aTransform.matrix[5] = aTransformPosition.getY();
pSvtGraphicFill.reset( new SvtGraphicFill(
getFillPolyPolygon(aLocalPolyPolygon),
Color(),
0.0,
SvtGraphicFill::fillEvenOdd,
SvtGraphicFill::fillTexture,
aTransform,
rFillGraphicAttribute.getTiling(),
SvtGraphicFill::hatchSingle,
Color(),
SvtGraphicFill::GradientType::Linear,
Color(),
Color(),
0,
rFillGraphicAttribute.getGraphic()) );
}
// Do use decomposition; encapsulate with SvtGraphicFill
impStartSvtGraphicFill(pSvtGraphicFill.get());
process(rBitmapCandidate);
impEndSvtGraphicFill(pSvtGraphicFill.get());
}
void VclMetafileProcessor2D::processPolyPolygonHatchPrimitive2D(const primitive2d::PolyPolygonHatchPrimitive2D& rHatchCandidate)
{
// need to handle PolyPolygonHatchPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END
const attribute::FillHatchAttribute& rFillHatchAttribute = rHatchCandidate.getFillHatch();
basegfx::B2DPolyPolygon aLocalPolyPolygon(rHatchCandidate.getB2DPolyPolygon());
if(aLocalPolyPolygon.getB2DRange() != rHatchCandidate.getDefinitionRange())
{
// the range which defines the hatch is different from the range of the
// geometry (used for writer frames). This cannot be done calling vcl, thus use
// decomposition here
process(rHatchCandidate);
return;
}
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
if(rFillHatchAttribute.isFillBackground())
{
// with fixing #i111954# (see below) the possible background
// fill of a hatched object was lost.Generate a background fill
// primitive and render it
const primitive2d::Primitive2DReference xBackground(
new primitive2d::PolyPolygonColorPrimitive2D(
aLocalPolyPolygon,
rHatchCandidate.getBackgroundColor()));
process(primitive2d::Primitive2DContainer { xBackground });
}
std::unique_ptr<SvtGraphicFill> pSvtGraphicFill;
aLocalPolyPolygon.transform(maCurrentTransformation);
if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
{
// re-create a VCL hatch as base data
SvtGraphicFill::HatchType eHatch(SvtGraphicFill::hatchSingle);
switch(rFillHatchAttribute.getStyle())
{
default: // attribute::HatchStyle::Single :
{
eHatch = SvtGraphicFill::hatchSingle;
break;
}
case attribute::HatchStyle::Double :
{
eHatch = SvtGraphicFill::hatchDouble;
break;
}
case attribute::HatchStyle::Triple :
{
eHatch = SvtGraphicFill::hatchTriple;
break;
}
}
SvtGraphicFill::Transform aTransform;
// scale
aTransform.matrix[0] *= rFillHatchAttribute.getDistance();
aTransform.matrix[4] *= rFillHatchAttribute.getDistance();
// rotate (was never correct in impgrfll anyways, use correct angle now)
aTransform.matrix[0] *= cos(rFillHatchAttribute.getAngle());
aTransform.matrix[1] *= -sin(rFillHatchAttribute.getAngle());
aTransform.matrix[3] *= sin(rFillHatchAttribute.getAngle());
aTransform.matrix[4] *= cos(rFillHatchAttribute.getAngle());
pSvtGraphicFill.reset( new SvtGraphicFill(
getFillPolyPolygon(aLocalPolyPolygon),
Color(),
0.0,
SvtGraphicFill::fillEvenOdd,
SvtGraphicFill::fillHatch,
aTransform,
false,
eHatch,
Color(maBColorModifierStack.getModifiedColor(rFillHatchAttribute.getColor())),
SvtGraphicFill::GradientType::Linear,
Color(),
Color(),
0,
Graphic()) );
}
// Do use decomposition; encapsulate with SvtGraphicFill
impStartSvtGraphicFill(pSvtGraphicFill.get());
// #i111954# do NOT use decomposition, but use direct VCL-command
// process(rCandidate.get2DDecomposition(getViewInformation2D()));
const ::tools::PolyPolygon aToolsPolyPolygon(basegfx::utils::adaptiveSubdivideByAngle(aLocalPolyPolygon));
const HatchStyle aHatchStyle(
attribute::HatchStyle::Single == rFillHatchAttribute.getStyle() ? HatchStyle::Single :
attribute::HatchStyle::Double == rFillHatchAttribute.getStyle() ? HatchStyle::Double :
HatchStyle::Triple);
mpOutputDevice->DrawHatch(aToolsPolyPolygon,
Hatch(aHatchStyle,
Color(maBColorModifierStack.getModifiedColor(rFillHatchAttribute.getColor())),
basegfx::fround(rFillHatchAttribute.getDistance()),
basegfx::fround(rFillHatchAttribute.getAngle() / F_PI1800)));
impEndSvtGraphicFill(pSvtGraphicFill.get());
}
void VclMetafileProcessor2D::processPolyPolygonGradientPrimitive2D(const primitive2d::PolyPolygonGradientPrimitive2D& rGradientCandidate)
{
basegfx::B2DVector aScale, aTranslate;
double fRotate, fShearX;
maCurrentTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
if(!basegfx::fTools::equalZero(fRotate) || !basegfx::fTools::equalZero(fShearX))
{
// #i121185# When rotation or shear is used, a VCL Gradient cannot be used directly.
// This is because VCL Gradient mechanism does *not* support to rotate the gradient
// with objects and this case is not expressible in a Metafile (and cannot be added
// since the FileFormats used, e.g. *.wmf, do not support it either).
// Such cases happen when a graphic object uses a Metafile as graphic information or
// a fill style definition uses a Metafile. In this cases the graphic content is
// rotated with the graphic or filled object; this is not supported by the target
// format of this conversion renderer - Metafiles.
// To solve this, not a Gradient is written, but the decomposition of this object
// is written to the Metafile. This is the PolyPolygons building the gradient fill.
// These will need more space and time, but the result will be as if the Gradient
// was rotated with the object.
// This mechanism is used by all exporters still not using Primitives (e.g. Print,
// Slideshow, Export rto PDF, export to Picture, ...) but relying on Metafile
// transfers. One more reason to *change* these to primitives.
// BTW: One more example how useful the principles of primitives are; the decomposition
// is by definition a simpler, maybe more expensive representation of the same content.
process(rGradientCandidate);
return;
}
basegfx::B2DPolyPolygon aLocalPolyPolygon(rGradientCandidate.getB2DPolyPolygon());
if(aLocalPolyPolygon.getB2DRange() != rGradientCandidate.getDefinitionRange())
{
// the range which defines the gradient is different from the range of the
// geometry (used for writer frames). This cannot be done calling vcl, thus use
// decomposition here
process(rGradientCandidate);
return;
}
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
// for support of MetaCommentActions of the form XGRAD_SEQ_BEGIN, XGRAD_SEQ_END
// it is safest to use the VCL OutputDevice::DrawGradient method which creates those.
// re-create a VCL-gradient from FillGradientPrimitive2D and the needed tools PolyPolygon
Gradient aVCLGradient;
impConvertFillGradientAttributeToVCLGradient(aVCLGradient, rGradientCandidate.getFillGradient(), false);
aLocalPolyPolygon.transform(maCurrentTransformation);
// #i82145# ATM VCL printing of gradients using curved shapes does not work,
// i submitted the bug with the given ID to THB. When that task is fixed it is
// necessary to again remove this subdivision since it decreases possible
// printing quality (not even resolution-dependent for now). THB will tell
// me when that task is fixed in the master
const ::tools::PolyPolygon aToolsPolyPolygon(
getFillPolyPolygon(
basegfx::utils::adaptiveSubdivideByAngle(aLocalPolyPolygon)));
// XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END support
std::unique_ptr<SvtGraphicFill> pSvtGraphicFill;
if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count())
{
// setup gradient stuff like in impgrfll
SvtGraphicFill::GradientType eGrad(SvtGraphicFill::GradientType::Linear);
switch(aVCLGradient.GetStyle())
{
default : // GradientStyle::Linear:
case GradientStyle::Axial:
eGrad = SvtGraphicFill::GradientType::Linear;
break;
case GradientStyle::Radial:
case GradientStyle::Elliptical:
eGrad = SvtGraphicFill::GradientType::Radial;
break;
case GradientStyle::Square:
case GradientStyle::Rect:
eGrad = SvtGraphicFill::GradientType::Rectangular;
break;
}
pSvtGraphicFill.reset( new SvtGraphicFill(
aToolsPolyPolygon,
Color(),
0.0,
SvtGraphicFill::fillEvenOdd,
SvtGraphicFill::fillGradient,
SvtGraphicFill::Transform(),
false,
SvtGraphicFill::hatchSingle,
Color(),
eGrad,
aVCLGradient.GetStartColor(),
aVCLGradient.GetEndColor(),
aVCLGradient.GetSteps(),
Graphic()) );
}
// call VCL directly; encapsulate with SvtGraphicFill
impStartSvtGraphicFill(pSvtGraphicFill.get());
mpOutputDevice->DrawGradient(aToolsPolyPolygon, aVCLGradient);
impEndSvtGraphicFill(pSvtGraphicFill.get());
}
void VclMetafileProcessor2D::processPolyPolygonColorPrimitive2D(const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate)
{
mpOutputDevice->Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolygonCandidate.getB2DPolyPolygon());
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));
aLocalPolyPolygon.transform(maCurrentTransformation);
// set line and fill color
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
// restore VCL clip region
mpOutputDevice->Pop();
}
void VclMetafileProcessor2D::processMaskPrimitive2D(const primitive2d::MaskPrimitive2D& rMaskCandidate)
// restore to rescued clip polygon
maClipPolyPolygon = aLastClipPolyPolygon;
}
else
{
// no mask, no clipping. recursively paint content
process(rMaskCandidate.getChildren());
}
}
void VclMetafileProcessor2D::processUnifiedTransparencePrimitive2D(
const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate)
{
mpOutputDevice->Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
// for metafile: Need to examine what the pure vcl version is doing here actually
// - uses DrawTransparent with metafile for content and a gradient
// - uses DrawTransparent for single PolyPolygons directly. Can be detected by
// checking the content for single PolyPolygonColorPrimitive2D
const primitive2d::Primitive2DContainer& rContent = rUniTransparenceCandidate.getChildren();
if (!rContent.empty())
{
if (0.0 == rUniTransparenceCandidate.getTransparence())
{
// mask group. Special handling for MetaFiles.
if(rMaskCandidate.getChildren().empty())
return;
basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
if(aMask.count())
{
// prepare new mask polygon and rescue current one
aMask.transform(maCurrentTransformation);
const basegfx::B2DPolyPolygon aLastClipPolyPolygon(maClipPolyPolygon);
if(maClipPolyPolygon.count())
{
// there is already a clip polygon set; build clipped union of
// current mask polygon and new one
maClipPolyPolygon = basegfx::utils::clipPolyPolygonOnPolyPolygon(
aMask,
maClipPolyPolygon,
true, // #i106516# we want the inside of aMask, not the outside
false);
}
else
{
// use mask directly
maClipPolyPolygon = aMask;
}
if(maClipPolyPolygon.count())
{
// set VCL clip region; subdivide before conversion to tools polygon. Subdivision necessary (!)
// Removed subdivision and fixed in vcl::Region::ImplPolyPolyRegionToBandRegionFunc() in VCL where
// the ClipRegion is built from the Polygon. An AdaptiveSubdivide on the source polygon was missing there
mpOutputDevice->Push(PushFlags::CLIPREGION);
mpOutputDevice->SetClipRegion(vcl::Region(maClipPolyPolygon));
// recursively paint content
// #i121267# Only need to process sub-content when clip polygon is *not* empty.
// If it is empty, the clip is empty and there can be nothing inside.
process(rMaskCandidate.getChildren());
// restore VCL clip region
mpOutputDevice->Pop();
}
// restore to rescued clip polygon
maClipPolyPolygon = aLastClipPolyPolygon;
}
else
{
// no mask, no clipping. recursively paint content
process(rMaskCandidate.getChildren());
}
// not transparent at all, use content
process(rUniTransparenceCandidate.getChildren());
}
void VclMetafileProcessor2D::processUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate)
else if (rUniTransparenceCandidate.getTransparence() > 0.0
&& rUniTransparenceCandidate.getTransparence() < 1.0)
{
mpOutputDevice->Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
// for metafile: Need to examine what the pure vcl version is doing here actually
// - uses DrawTransparent with metafile for content and a gradient
// - uses DrawTransparent for single PolyPolygons directly. Can be detected by
// checking the content for single PolyPolygonColorPrimitive2D
const primitive2d::Primitive2DContainer& rContent = rUniTransparenceCandidate.getChildren();
// try to identify a single PolyPolygonColorPrimitive2D in the
// content part of the transparence primitive
const primitive2d::PolyPolygonColorPrimitive2D* pPoPoColor = nullptr;
static bool bForceToMetafile(false); // loplugin:constvars:ignore
if(!rContent.empty())
if (!bForceToMetafile && 1 == rContent.size())
{
if(0.0 == rUniTransparenceCandidate.getTransparence())
{
// not transparent at all, use content
process(rUniTransparenceCandidate.getChildren());
}
else if(rUniTransparenceCandidate.getTransparence() > 0.0 && rUniTransparenceCandidate.getTransparence() < 1.0)
{
// try to identify a single PolyPolygonColorPrimitive2D in the
// content part of the transparence primitive
const primitive2d::PolyPolygonColorPrimitive2D* pPoPoColor = nullptr;
static bool bForceToMetafile(false); // loplugin:constvars:ignore
if(!bForceToMetafile && 1 == rContent.size())
{
const primitive2d::Primitive2DReference xReference(rContent[0]);
pPoPoColor = dynamic_cast< const primitive2d::PolyPolygonColorPrimitive2D* >(xReference.get());
}
// PolyPolygonGradientPrimitive2D, PolyPolygonHatchPrimitive2D and
// PolyPolygonGraphicPrimitive2D are derived from PolyPolygonColorPrimitive2D.
// Check also for correct ID to exclude derived implementations
if(pPoPoColor && PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D == pPoPoColor->getPrimitive2DID())
{
// single transparent tools::PolyPolygon identified, use directly
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(pPoPoColor->getBColor()));
basegfx::B2DPolyPolygon aLocalPolyPolygon(pPoPoColor->getB2DPolyPolygon());
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
// now transform
aLocalPolyPolygon.transform(maCurrentTransformation);
// set line and fill color
const sal_uInt16 nTransPercentVcl(static_cast<sal_uInt16>(basegfx::fround(rUniTransparenceCandidate.getTransparence() * 100.0)));
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
mpOutputDevice->DrawTransparent(
::tools::PolyPolygon(aLocalPolyPolygon),
nTransPercentVcl);
}
else
{
// save old mfCurrentUnifiedTransparence and set new one
// so that contained SvtGraphicStroke may use the current one
const double fLastCurrentUnifiedTransparence(mfCurrentUnifiedTransparence);
// #i105377# paint the content metafile opaque as the transparency gets
// split of into the gradient below
// mfCurrentUnifiedTransparence = rUniTransparenceCandidate.getTransparence();
mfCurrentUnifiedTransparence = 0;
// various content, create content-metafile
GDIMetaFile aContentMetafile;
const ::tools::Rectangle aPrimitiveRectangle(impDumpToMetaFile(rContent, aContentMetafile));
// restore mfCurrentUnifiedTransparence; it may have been used
// while processing the sub-content in impDumpToMetaFile
mfCurrentUnifiedTransparence = fLastCurrentUnifiedTransparence;
// create uniform VCL gradient for uniform transparency
Gradient aVCLGradient;
const sal_uInt8 nTransPercentVcl(static_cast<sal_uInt8>(basegfx::fround(rUniTransparenceCandidate.getTransparence() * 255.0)));
const Color aTransColor(nTransPercentVcl, nTransPercentVcl, nTransPercentVcl);
aVCLGradient.SetStyle(GradientStyle::Linear);
aVCLGradient.SetStartColor(aTransColor);
aVCLGradient.SetEndColor(aTransColor);
aVCLGradient.SetAngle(0);
aVCLGradient.SetBorder(0);
aVCLGradient.SetOfsX(0);
aVCLGradient.SetOfsY(0);
aVCLGradient.SetStartIntensity(100);
aVCLGradient.SetEndIntensity(100);
aVCLGradient.SetSteps(2);
// render it to VCL
mpOutputDevice->DrawTransparent(
aContentMetafile, aPrimitiveRectangle.TopLeft(),
aPrimitiveRectangle.GetSize(), aVCLGradient);
}
}
const primitive2d::Primitive2DReference xReference(rContent[0]);
pPoPoColor = dynamic_cast<const primitive2d::PolyPolygonColorPrimitive2D*>(
xReference.get());
}
mpOutputDevice->Pop();
}
void VclMetafileProcessor2D::processTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D& rTransparenceCandidate)
{
// for metafile: Need to examine what the pure vcl version is doing here actually
// - uses DrawTransparent with metafile for content and a gradient
// i can detect this here with checking the gradient part for a single
// FillGradientPrimitive2D and reconstruct the gradient.
// If that detection goes wrong, I have to create a transparence-blended bitmap. Eventually
// do that in stripes, else RenderTransparencePrimitive2D may just be used
const primitive2d::Primitive2DContainer& rContent = rTransparenceCandidate.getChildren();
const primitive2d::Primitive2DContainer& rTransparence = rTransparenceCandidate.getTransparence();
if(rContent.empty() || rTransparence.empty())
return;
// try to identify a single FillGradientPrimitive2D in the
// transparence part of the primitive
const primitive2d::FillGradientPrimitive2D* pFiGradient = nullptr;
static bool bForceToBigTransparentVDev(false); // loplugin:constvars:ignore
if(!bForceToBigTransparentVDev && 1 == rTransparence.size())
{
const primitive2d::Primitive2DReference xReference(rTransparence[0]);
pFiGradient = dynamic_cast< const primitive2d::FillGradientPrimitive2D* >(xReference.get());
}
// PolyPolygonGradientPrimitive2D, PolyPolygonHatchPrimitive2D and
// PolyPolygonGraphicPrimitive2D are derived from PolyPolygonColorPrimitive2D.
// Check also for correct ID to exclude derived implementations
if(pFiGradient && PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D == pFiGradient->getPrimitive2DID())
if (pPoPoColor
&& PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D == pPoPoColor->getPrimitive2DID())
{
// single transparent tools::PolyPolygon identified, use directly
const basegfx::BColor aPolygonColor(
maBColorModifierStack.getModifiedColor(pPoPoColor->getBColor()));
basegfx::B2DPolyPolygon aLocalPolyPolygon(pPoPoColor->getB2DPolyPolygon());
// #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points
// per polygon. Split polygon until there are less than that
fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon);
// now transform
aLocalPolyPolygon.transform(maCurrentTransformation);
// set line and fill color
const sal_uInt16 nTransPercentVcl(static_cast<sal_uInt16>(
basegfx::fround(rUniTransparenceCandidate.getTransparence() * 100.0)));
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
mpOutputDevice->DrawTransparent(tools::PolyPolygon(aLocalPolyPolygon),
nTransPercentVcl);
}
else
{
// save old mfCurrentUnifiedTransparence and set new one
// so that contained SvtGraphicStroke may use the current one
const double fLastCurrentUnifiedTransparence(mfCurrentUnifiedTransparence);
// #i105377# paint the content metafile opaque as the transparency gets
// split of into the gradient below
// mfCurrentUnifiedTransparence = rUniTransparenceCandidate.getTransparence();
mfCurrentUnifiedTransparence = 0;
// various content, create content-metafile
GDIMetaFile aContentMetafile;
const ::tools::Rectangle aPrimitiveRectangle(impDumpToMetaFile(rContent, aContentMetafile));
const tools::Rectangle aPrimitiveRectangle(
impDumpToMetaFile(rContent, aContentMetafile));
// re-create a VCL-gradient from FillGradientPrimitive2D
// restore mfCurrentUnifiedTransparence; it may have been used
// while processing the sub-content in impDumpToMetaFile
mfCurrentUnifiedTransparence = fLastCurrentUnifiedTransparence;
// create uniform VCL gradient for uniform transparency
Gradient aVCLGradient;
impConvertFillGradientAttributeToVCLGradient(aVCLGradient, pFiGradient->getFillGradient(), true);
const sal_uInt8 nTransPercentVcl(static_cast<sal_uInt8>(
basegfx::fround(rUniTransparenceCandidate.getTransparence() * 255.0)));
const Color aTransColor(nTransPercentVcl, nTransPercentVcl, nTransPercentVcl);
aVCLGradient.SetStyle(GradientStyle::Linear);
aVCLGradient.SetStartColor(aTransColor);
aVCLGradient.SetEndColor(aTransColor);
aVCLGradient.SetAngle(0);
aVCLGradient.SetBorder(0);
aVCLGradient.SetOfsX(0);
aVCLGradient.SetOfsY(0);
aVCLGradient.SetStartIntensity(100);
aVCLGradient.SetEndIntensity(100);
aVCLGradient.SetSteps(2);
// render it to VCL
mpOutputDevice->DrawTransparent(
aContentMetafile, aPrimitiveRectangle.TopLeft(),
aPrimitiveRectangle.GetSize(), aVCLGradient);
}
else
{
// sub-transparence group. Draw to VDev first.
// this may get refined to tiling when resolution is too big here
// need to avoid switching off MapMode stuff here; maybe need another
// tooling class, cannot just do the same as with the pixel renderer.
// Need to experiment...
// Okay, basic implementation finished and tested. The DPI stuff was hard
// and not easy to find out that it's needed.
// Since this will not yet happen normally (as long as no one constructs
// transparence primitives with non-trivial transparence content) i will for now not
// refine to tiling here.
basegfx::B2DRange aViewRange(rContent.getB2DRange(getViewInformation2D()));
aViewRange.transform(maCurrentTransformation);
const ::tools::Rectangle aRectLogic(
static_cast<sal_Int32>(floor(aViewRange.getMinX())), static_cast<sal_Int32>(floor(aViewRange.getMinY())),
static_cast<sal_Int32>(ceil(aViewRange.getMaxX())), static_cast<sal_Int32>(ceil(aViewRange.getMaxY())));
const ::tools::Rectangle aRectPixel(mpOutputDevice->LogicToPixel(aRectLogic));
Size aSizePixel(aRectPixel.GetSize());
const Point aEmptyPoint;
ScopedVclPtrInstance< VirtualDevice > aBufferDevice;
const sal_uInt32 nMaxQuadratPixels(500000);
const sal_uInt32 nViewVisibleArea(aSizePixel.getWidth() * aSizePixel.getHeight());
double fReduceFactor(1.0);
if(nViewVisibleArea > nMaxQuadratPixels)
{
// reduce render size
fReduceFactor = sqrt(double(nMaxQuadratPixels) / static_cast<double>(nViewVisibleArea));
aSizePixel = Size(basegfx::fround(static_cast<double>(aSizePixel.getWidth()) * fReduceFactor),
basegfx::fround(static_cast<double>(aSizePixel.getHeight()) * fReduceFactor));
}
if(aBufferDevice->SetOutputSizePixel(aSizePixel))
{
// create and set MapModes for target devices
MapMode aNewMapMode(mpOutputDevice->GetMapMode());
aNewMapMode.SetOrigin(Point(-aRectLogic.Left(), -aRectLogic.Top()));
aBufferDevice->SetMapMode(aNewMapMode);
// prepare view transformation for target renderers
// ATTENTION! Need to apply another scaling because of the potential DPI differences
// between Printer and VDev (mpOutputDevice and aBufferDevice here).
// To get the DPI, LogicToPixel from (1,1) from MapUnit::MapInch needs to be used.
basegfx::B2DHomMatrix aViewTransform(aBufferDevice->GetViewTransformation());
const Size aDPIOld(mpOutputDevice->LogicToPixel(Size(1, 1), MapMode(MapUnit::MapInch)));
const Size aDPINew(aBufferDevice->LogicToPixel(Size(1, 1), MapMode(MapUnit::MapInch)));
const double fDPIXChange(static_cast<double>(aDPIOld.getWidth()) / static_cast<double>(aDPINew.getWidth()));
const double fDPIYChange(static_cast<double>(aDPIOld.getHeight()) / static_cast<double>(aDPINew.getHeight()));
if(!basegfx::fTools::equal(fDPIXChange, 1.0) || !basegfx::fTools::equal(fDPIYChange, 1.0))
{
aViewTransform.scale(fDPIXChange, fDPIYChange);
}
// also take scaling from Size reduction into account
if(!basegfx::fTools::equal(fReduceFactor, 1.0))
{
aViewTransform.scale(fReduceFactor, fReduceFactor);
}
// create view information and pixel renderer. Reuse known ViewInformation
// except new transformation and range
const geometry::ViewInformation2D aViewInfo(
getViewInformation2D().getObjectTransformation(),
aViewTransform,
aViewRange,
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime(),
getViewInformation2D().getExtendedInformationSequence());
VclPixelProcessor2D aBufferProcessor(aViewInfo, *aBufferDevice);
// draw content using pixel renderer
aBufferProcessor.process(rContent);
const Bitmap aBmContent(aBufferDevice->GetBitmap(aEmptyPoint, aSizePixel));
// draw transparence using pixel renderer
aBufferDevice->Erase();
aBufferProcessor.process(rTransparence);
const AlphaMask aBmAlpha(aBufferDevice->GetBitmap(aEmptyPoint, aSizePixel));
// paint
mpOutputDevice->DrawBitmapEx(
aRectLogic.TopLeft(),
aRectLogic.GetSize(),
BitmapEx(aBmContent, aBmAlpha));
}
mpOutputDevice->DrawTransparent(aContentMetafile, aPrimitiveRectangle.TopLeft(),
aPrimitiveRectangle.GetSize(), aVCLGradient);
}
}
}
void VclMetafileProcessor2D::processStructureTagPrimitive2D(const primitive2d::StructureTagPrimitive2D& rStructureTagCandidate)
mpOutputDevice->Pop();
}
void VclMetafileProcessor2D::processTransparencePrimitive2D(
const primitive2d::TransparencePrimitive2D& rTransparenceCandidate)
{
// for metafile: Need to examine what the pure vcl version is doing here actually
// - uses DrawTransparent with metafile for content and a gradient
// i can detect this here with checking the gradient part for a single
// FillGradientPrimitive2D and reconstruct the gradient.
// If that detection goes wrong, I have to create a transparence-blended bitmap. Eventually
// do that in stripes, else RenderTransparencePrimitive2D may just be used
const primitive2d::Primitive2DContainer& rContent = rTransparenceCandidate.getChildren();
const primitive2d::Primitive2DContainer& rTransparence
= rTransparenceCandidate.getTransparence();
if (rContent.empty() || rTransparence.empty())
return;
// try to identify a single FillGradientPrimitive2D in the
// transparence part of the primitive
const primitive2d::FillGradientPrimitive2D* pFiGradient = nullptr;
static bool bForceToBigTransparentVDev(false); // loplugin:constvars:ignore
if (!bForceToBigTransparentVDev && 1 == rTransparence.size())
{
const primitive2d::Primitive2DReference xReference(rTransparence[0]);
pFiGradient = dynamic_cast<const primitive2d::FillGradientPrimitive2D*>(xReference.get());
}
// Check also for correct ID to exclude derived implementations
if (pFiGradient && PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D == pFiGradient->getPrimitive2DID())
{
// various content, create content-metafile
GDIMetaFile aContentMetafile;
const tools::Rectangle aPrimitiveRectangle(impDumpToMetaFile(rContent, aContentMetafile));
// re-create a VCL-gradient from FillGradientPrimitive2D
Gradient aVCLGradient;
impConvertFillGradientAttributeToVCLGradient(aVCLGradient, pFiGradient->getFillGradient(),
true);
// render it to VCL
mpOutputDevice->DrawTransparent(aContentMetafile, aPrimitiveRectangle.TopLeft(),
aPrimitiveRectangle.GetSize(), aVCLGradient);
}
else
{
// sub-transparence group. Draw to VDev first.
// this may get refined to tiling when resolution is too big here
// need to avoid switching off MapMode stuff here; maybe need another
// tooling class, cannot just do the same as with the pixel renderer.
// Need to experiment...
// Okay, basic implementation finished and tested. The DPI stuff was hard
// and not easy to find out that it's needed.
// Since this will not yet happen normally (as long as no one constructs
// transparence primitives with non-trivial transparence content) i will for now not
// refine to tiling here.
basegfx::B2DRange aViewRange(rContent.getB2DRange(getViewInformation2D()));
aViewRange.transform(maCurrentTransformation);
const tools::Rectangle aRectLogic(static_cast<sal_Int32>(floor(aViewRange.getMinX())),
static_cast<sal_Int32>(floor(aViewRange.getMinY())),
static_cast<sal_Int32>(ceil(aViewRange.getMaxX())),
static_cast<sal_Int32>(ceil(aViewRange.getMaxY())));
const tools::Rectangle aRectPixel(mpOutputDevice->LogicToPixel(aRectLogic));
Size aSizePixel(aRectPixel.GetSize());
const Point aEmptyPoint;
ScopedVclPtrInstance<VirtualDevice> aBufferDevice;
const sal_uInt32 nMaxQuadratPixels(500000);
const sal_uInt32 nViewVisibleArea(aSizePixel.getWidth() * aSizePixel.getHeight());
double fReduceFactor(1.0);
if (nViewVisibleArea > nMaxQuadratPixels)
{
// structured tag primitive
const vcl::PDFWriter::StructElement& rTagElement(rStructureTagCandidate.getStructureElement());
bool bTagUsed((vcl::PDFWriter::NonStructElement != rTagElement));
if(mpPDFExtOutDevData && bTagUsed)
{
// foreground object: tag as regular structure element
if (!rStructureTagCandidate.isBackground())
{
mpPDFExtOutDevData->BeginStructureElement(rTagElement);
}
// background object
else
{
// background image: tag as artifact
if (rStructureTagCandidate.isImage())
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::NonStructElement);
// any other background object: do not tag
else
bTagUsed = false;
}
}
// process children normally
process(rStructureTagCandidate.getChildren());
if(mpPDFExtOutDevData && bTagUsed)
{
// write end tag
mpPDFExtOutDevData->EndStructureElement();
}
// reduce render size
fReduceFactor = sqrt(double(nMaxQuadratPixels) / static_cast<double>(nViewVisibleArea));
aSizePixel = Size(
basegfx::fround(static_cast<double>(aSizePixel.getWidth()) * fReduceFactor),
basegfx::fround(static_cast<double>(aSizePixel.getHeight()) * fReduceFactor));
}
if (aBufferDevice->SetOutputSizePixel(aSizePixel))
{
// create and set MapModes for target devices
MapMode aNewMapMode(mpOutputDevice->GetMapMode());
aNewMapMode.SetOrigin(Point(-aRectLogic.Left(), -aRectLogic.Top()));
aBufferDevice->SetMapMode(aNewMapMode);
// prepare view transformation for target renderers
// ATTENTION! Need to apply another scaling because of the potential DPI differences
// between Printer and VDev (mpOutputDevice and aBufferDevice here).
// To get the DPI, LogicToPixel from (1,1) from MapUnit::MapInch needs to be used.
basegfx::B2DHomMatrix aViewTransform(aBufferDevice->GetViewTransformation());
const Size aDPIOld(mpOutputDevice->LogicToPixel(Size(1, 1), MapMode(MapUnit::MapInch)));
const Size aDPINew(aBufferDevice->LogicToPixel(Size(1, 1), MapMode(MapUnit::MapInch)));
const double fDPIXChange(static_cast<double>(aDPIOld.getWidth())
/ static_cast<double>(aDPINew.getWidth()));
const double fDPIYChange(static_cast<double>(aDPIOld.getHeight())
/ static_cast<double>(aDPINew.getHeight()));
if (!basegfx::fTools::equal(fDPIXChange, 1.0)
|| !basegfx::fTools::equal(fDPIYChange, 1.0))
{
aViewTransform.scale(fDPIXChange, fDPIYChange);
}
// also take scaling from Size reduction into account
if (!basegfx::fTools::equal(fReduceFactor, 1.0))
{
aViewTransform.scale(fReduceFactor, fReduceFactor);
}
// create view information and pixel renderer. Reuse known ViewInformation
// except new transformation and range
const geometry::ViewInformation2D aViewInfo(
getViewInformation2D().getObjectTransformation(), aViewTransform, aViewRange,
getViewInformation2D().getVisualizedPage(), getViewInformation2D().getViewTime(),
getViewInformation2D().getExtendedInformationSequence());
VclPixelProcessor2D aBufferProcessor(aViewInfo, *aBufferDevice);
// draw content using pixel renderer
aBufferProcessor.process(rContent);
const Bitmap aBmContent(aBufferDevice->GetBitmap(aEmptyPoint, aSizePixel));
// draw transparence using pixel renderer
aBufferDevice->Erase();
aBufferProcessor.process(rTransparence);
const AlphaMask aBmAlpha(aBufferDevice->GetBitmap(aEmptyPoint, aSizePixel));
// paint
mpOutputDevice->DrawBitmapEx(aRectLogic.TopLeft(), aRectLogic.GetSize(),
BitmapEx(aBmContent, aBmAlpha));
}
}
}
void VclMetafileProcessor2D::processStructureTagPrimitive2D(
const primitive2d::StructureTagPrimitive2D& rStructureTagCandidate)
{
// structured tag primitive
const vcl::PDFWriter::StructElement& rTagElement(rStructureTagCandidate.getStructureElement());
bool bTagUsed((vcl::PDFWriter::NonStructElement != rTagElement));
if (mpPDFExtOutDevData && bTagUsed)
{
// foreground object: tag as regular structure element
if (!rStructureTagCandidate.isBackground())
{
mpPDFExtOutDevData->BeginStructureElement(rTagElement);
}
// background object
else
{
// background image: tag as artifact
if (rStructureTagCandidate.isImage())
mpPDFExtOutDevData->BeginStructureElement(vcl::PDFWriter::NonStructElement);
// any other background object: do not tag
else
bTagUsed = false;
}
}
// process children normally
process(rStructureTagCandidate.getChildren());
if (mpPDFExtOutDevData && bTagUsed)
{
// write end tag
mpPDFExtOutDevData->EndStructureElement();
}
}
} // end of namespace
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/processor2d/vclmetafileprocessor2d.hxx b/drawinglayer/source/processor2d/vclmetafileprocessor2d.hxx
index bf2cc26..0393039 100644
--- a/drawinglayer/source/processor2d/vclmetafileprocessor2d.hxx
+++ b/drawinglayer/source/processor2d/vclmetafileprocessor2d.hxx
@@ -27,163 +27,182 @@
#include <vcl/pdfextoutdevdata.hxx> // vcl::PDFExtOutDevData support
class GDIMetaFile;
namespace tools { class Rectangle; }
namespace tools
{
class Rectangle;
}
class Gradient;
class SvtGraphicFill;
class SvtGraphicStroke;
namespace drawinglayer::attribute {
class FillGradientAttribute;
class LineAttribute;
class StrokeAttribute;
class LineStartEndAttribute;
namespace drawinglayer::attribute
{
class FillGradientAttribute;
class LineAttribute;
class StrokeAttribute;
class LineStartEndAttribute;
}
namespace drawinglayer::primitive2d {
class GraphicPrimitive2D;
class ControlPrimitive2D;
class TextHierarchyFieldPrimitive2D;
class TextHierarchyLinePrimitive2D;
class TextHierarchyBulletPrimitive2D;
class TextHierarchyParagraphPrimitive2D;
class TextHierarchyBlockPrimitive2D;
class TextSimplePortionPrimitive2D;
class PolygonHairlinePrimitive2D;
class PolygonStrokePrimitive2D;
class PolygonStrokeArrowPrimitive2D;
class PolyPolygonGraphicPrimitive2D;
class PolyPolygonHatchPrimitive2D;
class PolyPolygonGradientPrimitive2D;
class PolyPolygonColorPrimitive2D;
class MaskPrimitive2D;
class UnifiedTransparencePrimitive2D;
class TransparencePrimitive2D;
class StructureTagPrimitive2D;
namespace drawinglayer::primitive2d
{
class GraphicPrimitive2D;
class ControlPrimitive2D;
class TextHierarchyFieldPrimitive2D;
class TextHierarchyLinePrimitive2D;
class TextHierarchyBulletPrimitive2D;
class TextHierarchyParagraphPrimitive2D;
class TextHierarchyBlockPrimitive2D;
class TextSimplePortionPrimitive2D;
class PolygonHairlinePrimitive2D;
class PolygonStrokePrimitive2D;
class PolygonStrokeArrowPrimitive2D;
class PolyPolygonGraphicPrimitive2D;
class PolyPolygonHatchPrimitive2D;
class PolyPolygonGradientPrimitive2D;
class PolyPolygonColorPrimitive2D;
class MaskPrimitive2D;
class UnifiedTransparencePrimitive2D;
class TransparencePrimitive2D;
class StructureTagPrimitive2D;
}
namespace basegfx {
class BColor;
namespace basegfx
{
class BColor;
}
namespace drawinglayer::processor2d
{
/** VclMetafileProcessor2D class
/** VclMetafileProcessor2D class
This processor derived from VclProcessor2D is the base class for rendering
all fed primitives to a classical VCL-Metafile, including all over the
time grown extra data in comments and PDF exception data creations. Also
printing needs some exception stuff.
This processor derived from VclProcessor2D is the base class for rendering
all fed primitives to a classical VCL-Metafile, including all over the
time grown extra data in comments and PDF exception data creations. Also
printing needs some exception stuff.
All in all it is needed to emulate the old ::paint output from the old
Drawinglayer as long as exporters and/or filters still use the Metafile
and the extra-data added to it (which can be seen mostly as 'extensions'
or simply as 'hacks').
*/
class VclMetafileProcessor2D : public VclProcessor2D
{
private:
/// local helper(s)
::tools::Rectangle impDumpToMetaFile(
const primitive2d::Primitive2DContainer& rContent,
GDIMetaFile& o_rContentMetafile);
void impConvertFillGradientAttributeToVCLGradient(
Gradient& o_rVCLGradient,
const attribute::FillGradientAttribute& rFiGrAtt,
bool bIsTransparenceGradient) const;
void impStartSvtGraphicFill(SvtGraphicFill const * pSvtGraphicFill);
void impEndSvtGraphicFill(SvtGraphicFill const * pSvtGraphicFill);
std::unique_ptr<SvtGraphicStroke> impTryToCreateSvtGraphicStroke(
const basegfx::B2DPolygon& rB2DPolygon,
const basegfx::BColor* pColor,
const attribute::LineAttribute* pLineAttribute,
const attribute::StrokeAttribute* pStrokeAttribute,
const attribute::LineStartEndAttribute* pStart,
const attribute::LineStartEndAttribute* pEnd);
void impStartSvtGraphicStroke(SvtGraphicStroke const * pSvtGraphicStroke);
void impEndSvtGraphicStroke(SvtGraphicStroke const * pSvtGraphicStroke);
void popStructureElement(vcl::PDFWriter::StructElement eElem);
void popListItem();
void popList();
All in all it is needed to emulate the old ::paint output from the old
Drawinglayer as long as exporters and/or filters still use the Metafile
and the extra-data added to it (which can be seen mostly as 'extensions'
or simply as 'hacks').
*/
class VclMetafileProcessor2D : public VclProcessor2D
{
private:
tools::Rectangle impDumpToMetaFile(const primitive2d::Primitive2DContainer& rContent,
GDIMetaFile& o_rContentMetafile);
void
impConvertFillGradientAttributeToVCLGradient(Gradient& o_rVCLGradient,
const attribute::FillGradientAttribute& rFiGrAtt,
bool bIsTransparenceGradient) const;
void impStartSvtGraphicFill(SvtGraphicFill const* pSvtGraphicFill);
void impEndSvtGraphicFill(SvtGraphicFill const* pSvtGraphicFill);
std::unique_ptr<SvtGraphicStroke>
impTryToCreateSvtGraphicStroke(const basegfx::B2DPolygon& rB2DPolygon,
const basegfx::BColor* pColor,
const attribute::LineAttribute* pLineAttribute,
const attribute::StrokeAttribute* pStrokeAttribute,
const attribute::LineStartEndAttribute* pStart,
const attribute::LineStartEndAttribute* pEnd);
void impStartSvtGraphicStroke(SvtGraphicStroke const* pSvtGraphicStroke);
void impEndSvtGraphicStroke(SvtGraphicStroke const* pSvtGraphicStroke);
void popStructureElement(vcl::PDFWriter::StructElement eElem);
void popListItem();
void popList();
void processGraphicPrimitive2D(const primitive2d::GraphicPrimitive2D& rGraphicPrimitive);
void processControlPrimitive2D(const primitive2d::ControlPrimitive2D& rControlPrimitive);
void processTextHierarchyFieldPrimitive2D(const primitive2d::TextHierarchyFieldPrimitive2D& rFieldPrimitive);
void processTextHierarchyLinePrimitive2D(const primitive2d::TextHierarchyLinePrimitive2D& rLinePrimitive);
void processTextHierarchyBulletPrimitive2D(const primitive2d::TextHierarchyBulletPrimitive2D& rBulletPrimitive);
void processTextHierarchyParagraphPrimitive2D(const primitive2d::TextHierarchyParagraphPrimitive2D& rParagraphPrimitive);
void processTextHierarchyBlockPrimitive2D(const primitive2d::TextHierarchyBlockPrimitive2D& rBlockPrimitive);
void processTextSimplePortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate);
void processPolygonHairlinePrimitive2D(const primitive2d::PolygonHairlinePrimitive2D& rHairlinePrimitive);
void processPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D& rStrokePrimitive);
void processPolygonStrokeArrowPrimitive2D(const primitive2d::PolygonStrokeArrowPrimitive2D& rStrokeArrowPrimitive);
void processPolyPolygonGraphicPrimitive2D(const primitive2d::PolyPolygonGraphicPrimitive2D& rBitmapCandidate);
void processPolyPolygonHatchPrimitive2D(const primitive2d::PolyPolygonHatchPrimitive2D& rHatchCandidate);
void processPolyPolygonGradientPrimitive2D(const primitive2d::PolyPolygonGradientPrimitive2D& rGradientCandidate);
void processPolyPolygonColorPrimitive2D(const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate);
void processMaskPrimitive2D(const primitive2d::MaskPrimitive2D& rMaskCandidate);
void processUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate);
void processTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D& rTransparenceCandidate);
void processStructureTagPrimitive2D(const primitive2d::StructureTagPrimitive2D& rStructureTagCandidate);
void processGraphicPrimitive2D(const primitive2d::GraphicPrimitive2D& rGraphicPrimitive);
void processControlPrimitive2D(const primitive2d::ControlPrimitive2D& rControlPrimitive);
void processTextHierarchyFieldPrimitive2D(
const primitive2d::TextHierarchyFieldPrimitive2D& rFieldPrimitive);
void processTextHierarchyLinePrimitive2D(
const primitive2d::TextHierarchyLinePrimitive2D& rLinePrimitive);
void processTextHierarchyBulletPrimitive2D(
const primitive2d::TextHierarchyBulletPrimitive2D& rBulletPrimitive);
void processTextHierarchyParagraphPrimitive2D(
const primitive2d::TextHierarchyParagraphPrimitive2D& rParagraphPrimitive);
void processTextHierarchyBlockPrimitive2D(
const primitive2d::TextHierarchyBlockPrimitive2D& rBlockPrimitive);
void processTextSimplePortionPrimitive2D(
const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate);
void processPolygonHairlinePrimitive2D(
const primitive2d::PolygonHairlinePrimitive2D& rHairlinePrimitive);
void
processPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D& rStrokePrimitive);
void processPolygonStrokeArrowPrimitive2D(
const primitive2d::PolygonStrokeArrowPrimitive2D& rStrokeArrowPrimitive);
void processPolyPolygonGraphicPrimitive2D(
const primitive2d::PolyPolygonGraphicPrimitive2D& rBitmapCandidate);
void processPolyPolygonHatchPrimitive2D(
const primitive2d::PolyPolygonHatchPrimitive2D& rHatchCandidate);
void processPolyPolygonGradientPrimitive2D(
const primitive2d::PolyPolygonGradientPrimitive2D& rGradientCandidate);
void processPolyPolygonColorPrimitive2D(
const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate);
void processMaskPrimitive2D(const primitive2d::MaskPrimitive2D& rMaskCandidate);
void processUnifiedTransparencePrimitive2D(
const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate);
void processTransparencePrimitive2D(
const primitive2d::TransparencePrimitive2D& rTransparenceCandidate);
void processStructureTagPrimitive2D(
const primitive2d::StructureTagPrimitive2D& rStructureTagCandidate);
/// Convert the fWidth to the same space as its coordinates.
double getTransformedLineWidth( double fWidth ) const;
/// Convert the fWidth to the same space as its coordinates.
double getTransformedLineWidth(double fWidth) const;
/// the current clipping tools::PolyPolygon from MaskPrimitive2D
basegfx::B2DPolyPolygon maClipPolyPolygon;
/// the current clipping tools::PolyPolygon from MaskPrimitive2D
basegfx::B2DPolyPolygon maClipPolyPolygon;
/// the target MetaFile
GDIMetaFile* mpMetaFile;
/// the target MetaFile
GDIMetaFile* mpMetaFile;
/* do not allow embedding SvtGraphicFills into each other,
use a counter to prevent that
*/
sal_uInt32 mnSvtGraphicFillCount;
/* do not allow embedding SvtGraphicFills into each other,
use a counter to prevent that
*/
sal_uInt32 mnSvtGraphicFillCount;
/// same for SvtGraphicStroke
sal_uInt32 mnSvtGraphicStrokeCount;
/// same for SvtGraphicStroke
sal_uInt32 mnSvtGraphicStrokeCount;
/* hold the last unified transparence value to have it handy
on SvtGraphicStroke creation
*/
double mfCurrentUnifiedTransparence;
/* hold the last unified transparence value to have it handy
on SvtGraphicStroke creation
*/
double mfCurrentUnifiedTransparence;
/* break iterator support
made static so it only needs to be fetched once, even with many single
constructed VclMetafileProcessor2D. It's still incarnated on demand,
but exists for OOo runtime now by purpose.
*/
static css::uno::Reference< css::i18n::XBreakIterator > mxBreakIterator;
/* break iterator support
made static so it only needs to be fetched once, even with many single
constructed VclMetafileProcessor2D. It's still incarnated on demand,
but exists for OOo runtime now by purpose.
*/
static css::uno::Reference<css::i18n::XBreakIterator> mxBreakIterator;
/* vcl::PDFExtOutDevData support
For the first step, some extra actions at vcl::PDFExtOutDevData need to
be emulated with the VclMetafileProcessor2D. These are potentially temporarily
since PDF export may use PrimitiveSequences one day directly.
*/
vcl::PDFExtOutDevData* mpPDFExtOutDevData;
/* vcl::PDFExtOutDevData support
For the first step, some extra actions at vcl::PDFExtOutDevData need to
be emulated with the VclMetafileProcessor2D. These are potentially temporarily
since PDF export may use PrimitiveSequences one day directly.
*/
vcl::PDFExtOutDevData* mpPDFExtOutDevData;
// Remember the current OutlineLevel. This is used when tagged PDF export
// is used to create/write valid structured list entries using PDF statements
// like '/L', '/LI', 'LBody' instead of simple '/P' (Paragraph).
// The value -1 means 'no OutlineLevel' and values >= 0 express the level.
sal_Int16 mnCurrentOutlineLevel;
bool mbInListItem;
bool mbBulletPresent;
// Remember the current OutlineLevel. This is used when tagged PDF export
// is used to create/write valid structured list entries using PDF statements
// like '/L', '/LI', 'LBody' instead of simple '/P' (Paragraph).
// The value -1 means 'no OutlineLevel' and values >= 0 express the level.
sal_Int16 mnCurrentOutlineLevel;
bool mbInListItem;
bool mbBulletPresent;
std::stack<vcl::PDFWriter::StructElement> maListElements;
std::stack<vcl::PDFWriter::StructElement> maListElements;
protected:
/* the local processor for BasePrimitive2D-Implementation based primitives,
called from the common process()-implementation
*/
virtual void processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate) override;
protected:
/* the local processor for BasePrimitive2D-Implementation based primitives,
called from the common process()-implementation
*/
virtual void processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate) override;
public:
/// constructor/destructor
VclMetafileProcessor2D(
const geometry::ViewInformation2D& rViewInformation,
OutputDevice& rOutDev);
virtual ~VclMetafileProcessor2D() override;
};
public:
/// constructor/destructor
VclMetafileProcessor2D(const geometry::ViewInformation2D& rViewInformation,
OutputDevice& rOutDev);
virtual ~VclMetafileProcessor2D() override;
};
} // end of namespace processor2d::drawinglayer
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/solenv/clang-format/blacklist b/solenv/clang-format/blacklist
index c347c84..d11bb2a 100644
--- a/solenv/clang-format/blacklist
+++ b/solenv/clang-format/blacklist
@@ -3747,8 +3747,6 @@ drawinglayer/source/processor2d/objectinfoextractor2d.cxx
drawinglayer/source/processor2d/processor2dtools.cxx
drawinglayer/source/processor2d/processorfromoutputdevice.cxx
drawinglayer/source/processor2d/textaspolygonextractor2d.cxx
drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
drawinglayer/source/processor2d/vclmetafileprocessor2d.hxx
drawinglayer/source/processor3d/baseprocessor3d.cxx
drawinglayer/source/processor3d/cutfindprocessor3d.cxx
drawinglayer/source/processor3d/defaultprocessor3d.cxx
