Update handling of AntiAliasing settings and processor2d
Currently SvtOptionsDrawinglayer::IsAntiAliasing() is used
in the constructor of the VCL based processor2Ds to decide
if AA is to be used or not. Using this inside the
constructors makes it currently impossible to use a
primitive renderer independent from these settings,
except when changing these settings temporarily what
may influence other renderings and is a hack.
The setting SvtOptionsDrawinglayer::IsAntiAliasing() is
intended to decide if LO shall use AA mode from user's
perspective, this means for the EditViews of the Apps
and some other occasions (previews, exports, conversions
to bitmap, ...).
This works currently since all visualizations for these
purposes use newly constructed primitive renderers. But
there is no way to use primitive renderers independent
from that setting. For future renderers which might be
used for other purposes this is not sufficient, there
has to be a method to create a renderer using e.g. AA
independent of the global setting.
To allow that, move the deciding flag to the already
used geometry::ViewInformation2D. To not change anything
initially, use the global flag for now to init that
default value at ViewInformation2D.
I took the opportunity to adapt ViewInformation2D to
no longer being read-only and not changeable, it uses
internally an impl class based on cow_wrapper already
anyways. Extending this would lead to the constructors
getting even bigger, when usually only 1-3 values
need to be changed and many usages want to copy an
existing instance and modify it. Adapted that usages
to a much smaller footprint.
Up to this point this does not change anything, but
move the usage of the SvtOptionsDrawinglayer to the
defaults (constructors) of the involved class
ViewInformation2D. Using this then in the primitive
rederers should be safe and will allow to use a
primitive renderer with or without AntiAliasing
independent of the user setting, so also for non-
EditView usages.
Also already added the PixelSnapHairline setting, this
will also be needed independent of user settings to
have full freedom of usage.
Unfortunately I cannot use SvtOptionsDrawinglayer
methods
::IsAntiAliasing() or
::IsSnapHorVerLinesToDiscrete
inside ViewInformation2D where I would need it. It's
now in drawinglayercore and thus not linked against
svtools (svt) anymore.
Thus I have to do some forwarding mechanisms to get
the correct values available in ViewInformation2D.
Not nice, caused by creating drawinglayercore...
Change-Id: I9f572ce67e5d86a242188bdc6d4ba7c9a12f6a9b
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/142393
Tested-by: Jenkins
Reviewed-by: Armin Le Grand <Armin.Le.Grand@me.com>
diff --git a/drawinglayer/Library_drawinglayercore.mk b/drawinglayer/Library_drawinglayercore.mk
index 9e089e9..7ec9544 100644
--- a/drawinglayer/Library_drawinglayercore.mk
+++ b/drawinglayer/Library_drawinglayercore.mk
@@ -39,6 +39,10 @@ $(eval $(call gb_Library_use_libraries,drawinglayercore,\
tl \
))
$(eval $(call gb_Library_use_custom_headers,drawinglayercore,\
officecfg/registry \
))
$(eval $(call gb_Library_add_exception_objects,drawinglayercore,\
drawinglayer/source/primitive2d/baseprimitive2d \
drawinglayer/source/primitive2d/BufferedDecompositionPrimitive2D \
diff --git a/drawinglayer/source/geometry/viewinformation2d.cxx b/drawinglayer/source/geometry/viewinformation2d.cxx
index 6de3092..d23dda6 100644
--- a/drawinglayer/source/geometry/viewinformation2d.cxx
+++ b/drawinglayer/source/geometry/viewinformation2d.cxx
@@ -25,6 +25,7 @@
#include <com/sun/star/drawing/XDrawPage.hpp>
#include <com/sun/star/geometry/AffineMatrix2D.hpp>
#include <com/sun/star/geometry/RealRectangle2D.hpp>
#include <officecfg/Office/Common.hxx>
#include <utility>
using namespace com::sun::star;
@@ -39,6 +40,15 @@ constexpr OUStringLiteral g_PropertyName_Viewport = u"Viewport";
constexpr OUStringLiteral g_PropertyName_Time = u"Time";
constexpr OUStringLiteral g_PropertyName_VisualizedPage = u"VisualizedPage";
constexpr OUStringLiteral g_PropertyName_ReducedDisplayQuality = u"ReducedDisplayQuality";
constexpr OUStringLiteral g_PropertyName_UseAntiAliasing = u"UseAntiAliasing";
constexpr OUStringLiteral g_PropertyName_PixelSnapHairline = u"PixelSnapHairline";
}
namespace
{
bool bForwardsAreInitialized(false);
bool bForwardedAntiAliasing(true);
bool bForwardPixelSnapHairline(true);
}
class ImpViewInformation2D
@@ -74,34 +84,54 @@ protected:
// the point in time
double mfViewTime;
// allow to reduce DisplayQuality (e.g. sw 3d fallback renderer for interactions)
bool mbReducedDisplayQuality : 1;
public:
ImpViewInformation2D(basegfx::B2DHomMatrix aObjectTransformation,
basegfx::B2DHomMatrix aViewTransformation,
const basegfx::B2DRange& rViewport,
uno::Reference<drawing::XDrawPage> xDrawPage, double fViewTime,
bool bReducedDisplayQuality)
: maObjectTransformation(std::move(aObjectTransformation))
, maViewTransformation(std::move(aViewTransformation))
, maViewport(rViewport)
, mxVisualizedPage(std::move(xDrawPage))
, mfViewTime(fViewTime)
, mbReducedDisplayQuality(bReducedDisplayQuality)
{
}
// determine if to use AntiAliasing on target pixel device
bool mbUseAntiAliasing : 1;
// determine if to use PixelSnapHairline on target pixel device
bool mbPixelSnapHairline : 1;
public:
ImpViewInformation2D()
: mfViewTime(0.0)
: maObjectTransformation()
, maViewTransformation()
, maObjectToViewTransformation()
, maInverseObjectToViewTransformation()
, maViewport()
, maDiscreteViewport()
, mxVisualizedPage()
, mfViewTime(0.0)
, mbReducedDisplayQuality(false)
, mbUseAntiAliasing(bForwardedAntiAliasing)
, mbPixelSnapHairline(bForwardedAntiAliasing && bForwardPixelSnapHairline)
{
}
const basegfx::B2DHomMatrix& getObjectTransformation() const { return maObjectTransformation; }
void setObjectTransformation(const basegfx::B2DHomMatrix& rNew)
{
maObjectTransformation = rNew;
maObjectToViewTransformation.identity();
maInverseObjectToViewTransformation.identity();
}
const basegfx::B2DHomMatrix& getViewTransformation() const { return maViewTransformation; }
void setViewTransformation(const basegfx::B2DHomMatrix& rNew)
{
maViewTransformation = rNew;
maDiscreteViewport.reset();
maObjectToViewTransformation.identity();
maInverseObjectToViewTransformation.identity();
}
const basegfx::B2DRange& getViewport() const { return maViewport; }
void setViewport(const basegfx::B2DRange& rNew)
{
maViewport = rNew;
maDiscreteViewport.reset();
}
const basegfx::B2DRange& getDiscreteViewport() const
{
@@ -143,10 +173,28 @@ public:
}
double getViewTime() const { return mfViewTime; }
void setViewTime(double fNew)
{
if (fNew >= 0.0)
{
mfViewTime = fNew;
}
}
const uno::Reference<drawing::XDrawPage>& getVisualizedPage() const { return mxVisualizedPage; }
void setVisualizedPage(const uno::Reference<drawing::XDrawPage>& rNew)
{
mxVisualizedPage = rNew;
}
bool getReducedDisplayQuality() const { return mbReducedDisplayQuality; }
void setReducedDisplayQuality(bool bNew) { mbReducedDisplayQuality = bNew; }
bool getUseAntiAliasing() const { return mbUseAntiAliasing; }
void setUseAntiAliasing(bool bNew) { mbUseAntiAliasing = bNew; }
bool getPixelSnapHairline() const { return mbPixelSnapHairline; }
void setPixelSnapHairline(bool bNew) { mbPixelSnapHairline = bNew; }
bool operator==(const ImpViewInformation2D& rCandidate) const
{
@@ -154,7 +202,10 @@ public:
&& maViewTransformation == rCandidate.maViewTransformation
&& maViewport == rCandidate.maViewport
&& mxVisualizedPage == rCandidate.mxVisualizedPage
&& mfViewTime == rCandidate.mfViewTime);
&& mfViewTime == rCandidate.mfViewTime
&& mbReducedDisplayQuality == rCandidate.mbReducedDisplayQuality
&& mbUseAntiAliasing == rCandidate.mbUseAntiAliasing
&& mbPixelSnapHairline == rCandidate.mbPixelSnapHairline);
}
};
@@ -167,20 +218,19 @@ ViewInformation2D::ImplType& theGlobalDefault()
}
}
ViewInformation2D::ViewInformation2D(const basegfx::B2DHomMatrix& rObjectTransformation,
const basegfx::B2DHomMatrix& rViewTransformation,
const basegfx::B2DRange& rViewport,
const uno::Reference<drawing::XDrawPage>& rxDrawPage,
double fViewTime, bool bReducedDisplayQuality)
: mpViewInformation2D(ImpViewInformation2D(rObjectTransformation, rViewTransformation,
rViewport, rxDrawPage, fViewTime,
bReducedDisplayQuality))
{
}
ViewInformation2D::ViewInformation2D()
: mpViewInformation2D(theGlobalDefault())
{
if (!bForwardsAreInitialized)
{
bForwardsAreInitialized = true;
bForwardedAntiAliasing = officecfg::Office::Common::Drawinglayer::AntiAliasing::get();
bForwardPixelSnapHairline
= officecfg::Office::Common::Drawinglayer::SnapHorVerLinesToDiscrete::get();
}
setUseAntiAliasing(bForwardedAntiAliasing);
setPixelSnapHairline(bForwardPixelSnapHairline);
}
ViewInformation2D::ViewInformation2D(const ViewInformation2D&) = default;
@@ -203,23 +253,53 @@ const basegfx::B2DHomMatrix& ViewInformation2D::getObjectTransformation() const
return mpViewInformation2D->getObjectTransformation();
}
void ViewInformation2D::setObjectTransformation(const basegfx::B2DHomMatrix& rNew)
{
if (std::as_const(mpViewInformation2D)->getObjectTransformation() != rNew)
mpViewInformation2D->setObjectTransformation(rNew);
}
const basegfx::B2DHomMatrix& ViewInformation2D::getViewTransformation() const
{
return mpViewInformation2D->getViewTransformation();
}
void ViewInformation2D::setViewTransformation(const basegfx::B2DHomMatrix& rNew)
{
if (std::as_const(mpViewInformation2D)->getViewTransformation() != rNew)
mpViewInformation2D->setViewTransformation(rNew);
}
const basegfx::B2DRange& ViewInformation2D::getViewport() const
{
return mpViewInformation2D->getViewport();
}
void ViewInformation2D::setViewport(const basegfx::B2DRange& rNew)
{
if (rNew != std::as_const(mpViewInformation2D)->getViewport())
mpViewInformation2D->setViewport(rNew);
}
double ViewInformation2D::getViewTime() const { return mpViewInformation2D->getViewTime(); }
void ViewInformation2D::setViewTime(double fNew)
{
if (fNew != std::as_const(mpViewInformation2D)->getViewTime())
mpViewInformation2D->setViewTime(fNew);
}
const uno::Reference<drawing::XDrawPage>& ViewInformation2D::getVisualizedPage() const
{
return mpViewInformation2D->getVisualizedPage();
}
void ViewInformation2D::setVisualizedPage(const uno::Reference<drawing::XDrawPage>& rNew)
{
if (rNew != std::as_const(mpViewInformation2D)->getVisualizedPage())
mpViewInformation2D->setVisualizedPage(rNew);
}
const basegfx::B2DHomMatrix& ViewInformation2D::getObjectToViewTransformation() const
{
return mpViewInformation2D->getObjectToViewTransformation();
@@ -240,55 +320,112 @@ bool ViewInformation2D::getReducedDisplayQuality() const
return mpViewInformation2D->getReducedDisplayQuality();
}
void ViewInformation2D::setReducedDisplayQuality(bool bNew)
{
if (bNew != std::as_const(mpViewInformation2D)->getReducedDisplayQuality())
mpViewInformation2D->setReducedDisplayQuality(bNew);
}
bool ViewInformation2D::getUseAntiAliasing() const
{
return mpViewInformation2D->getUseAntiAliasing();
}
void ViewInformation2D::setUseAntiAliasing(bool bNew)
{
if (bNew != std::as_const(mpViewInformation2D)->getUseAntiAliasing())
mpViewInformation2D->setUseAntiAliasing(bNew);
}
bool ViewInformation2D::getPixelSnapHairline() const
{
return mpViewInformation2D->getPixelSnapHairline();
}
void ViewInformation2D::setPixelSnapHairline(bool bNew)
{
if (bNew != std::as_const(mpViewInformation2D)->getPixelSnapHairline())
mpViewInformation2D->setPixelSnapHairline(bNew);
}
void ViewInformation2D::forwardAntiAliasing(bool bAntiAliasing)
{
bForwardedAntiAliasing = bAntiAliasing;
}
void ViewInformation2D::forwardPixelSnapHairline(bool bPixelSnapHairline)
{
bForwardPixelSnapHairline = bPixelSnapHairline;
}
ViewInformation2D
createViewInformation2D(const css::uno::Sequence<css::beans::PropertyValue>& rViewParameters)
{
if (!rViewParameters.hasElements())
return ViewInformation2D();
bool bReducedDisplayQuality = false;
basegfx::B2DHomMatrix aObjectTransformation;
basegfx::B2DHomMatrix aViewTransformation;
basegfx::B2DRange aViewport;
double fViewTime = 0.0;
uno::Reference<drawing::XDrawPage> xVisualizedPage;
ViewInformation2D aRetval;
for (auto const& rPropertyValue : rViewParameters)
{
if (rPropertyValue.Name == g_PropertyName_ReducedDisplayQuality)
{
rPropertyValue.Value >>= bReducedDisplayQuality;
bool bNew(false);
rPropertyValue.Value >>= bNew;
aRetval.setReducedDisplayQuality(bNew);
}
else if (rPropertyValue.Name == g_PropertyName_PixelSnapHairline)
{
bool bNew(
true); //SvtOptionsDrawinglayer::IsAntiAliasing() && SvtOptionsDrawinglayer::IsSnapHorVerLinesToDiscrete());
rPropertyValue.Value >>= bNew;
aRetval.setPixelSnapHairline(bNew);
}
else if (rPropertyValue.Name == g_PropertyName_UseAntiAliasing)
{
bool bNew(true); //SvtOptionsDrawinglayer::IsAntiAliasing());
rPropertyValue.Value >>= bNew;
aRetval.setUseAntiAliasing(bNew);
}
else if (rPropertyValue.Name == g_PropertyName_ObjectTransformation)
{
css::geometry::AffineMatrix2D aAffineMatrix2D;
rPropertyValue.Value >>= aAffineMatrix2D;
basegfx::unotools::homMatrixFromAffineMatrix(aObjectTransformation, aAffineMatrix2D);
basegfx::B2DHomMatrix aTransformation;
basegfx::unotools::homMatrixFromAffineMatrix(aTransformation, aAffineMatrix2D);
aRetval.setObjectTransformation(aTransformation);
}
else if (rPropertyValue.Name == g_PropertyName_ViewTransformation)
{
css::geometry::AffineMatrix2D aAffineMatrix2D;
rPropertyValue.Value >>= aAffineMatrix2D;
basegfx::unotools::homMatrixFromAffineMatrix(aViewTransformation, aAffineMatrix2D);
basegfx::B2DHomMatrix aTransformation;
basegfx::unotools::homMatrixFromAffineMatrix(aTransformation, aAffineMatrix2D);
aRetval.setViewTransformation(aTransformation);
}
else if (rPropertyValue.Name == g_PropertyName_Viewport)
{
css::geometry::RealRectangle2D aUnoViewport;
rPropertyValue.Value >>= aUnoViewport;
aViewport = basegfx::unotools::b2DRectangleFromRealRectangle2D(aUnoViewport);
const basegfx::B2DRange aViewport(
basegfx::unotools::b2DRectangleFromRealRectangle2D(aUnoViewport));
aRetval.setViewport(aViewport);
}
else if (rPropertyValue.Name == g_PropertyName_Time)
{
double fViewTime(0.0);
rPropertyValue.Value >>= fViewTime;
aRetval.setViewTime(fViewTime);
}
else if (rPropertyValue.Name == g_PropertyName_VisualizedPage)
{
css::uno::Reference<css::drawing::XDrawPage> xVisualizedPage;
rPropertyValue.Value >>= xVisualizedPage;
aRetval.setVisualizedPage(xVisualizedPage);
}
}
return ViewInformation2D(aObjectTransformation, aViewTransformation, aViewport, xVisualizedPage,
fViewTime, bReducedDisplayQuality);
return aRetval;
}
} // end of namespace drawinglayer::geometry
diff --git a/drawinglayer/source/primitive2d/GlowSoftEgdeShadowTools.cxx b/drawinglayer/source/primitive2d/GlowSoftEgdeShadowTools.cxx
index 0a32493..3c45fdd 100644
--- a/drawinglayer/source/primitive2d/GlowSoftEgdeShadowTools.cxx
+++ b/drawinglayer/source/primitive2d/GlowSoftEgdeShadowTools.cxx
@@ -79,14 +79,11 @@ drawinglayer::geometry::ViewInformation2D
expandB2DRangeAtViewInformation2D(const drawinglayer::geometry::ViewInformation2D& rViewInfo,
double nAmount)
{
drawinglayer::geometry::ViewInformation2D aRetval(rViewInfo);
basegfx::B2DRange viewport(rViewInfo.getViewport());
viewport.grow(nAmount);
return { rViewInfo.getObjectTransformation(),
rViewInfo.getViewTransformation(),
viewport,
rViewInfo.getVisualizedPage(),
rViewInfo.getViewTime(),
rViewInfo.getReducedDisplayQuality() };
aRetval.setViewport(viewport);
return aRetval;
}
} // end of namespace drawinglayer::primitive2d
diff --git a/drawinglayer/source/processor2d/contourextractor2d.cxx b/drawinglayer/source/processor2d/contourextractor2d.cxx
index a1d1200..65e8ef8 100644
--- a/drawinglayer/source/processor2d/contourextractor2d.cxx
+++ b/drawinglayer/source/processor2d/contourextractor2d.cxx
@@ -123,12 +123,8 @@ namespace drawinglayer::processor2d
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// create new local ViewInformation2D
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime());
geometry::ViewInformation2D aViewInformation2D(getViewInformation2D());
aViewInformation2D.setObjectTransformation(getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation());
updateViewInformation(aViewInformation2D);
// process content
diff --git a/drawinglayer/source/processor2d/hittestprocessor2d.cxx b/drawinglayer/source/processor2d/hittestprocessor2d.cxx
index dc7d6fa..1ebc8d5 100644
--- a/drawinglayer/source/processor2d/hittestprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/hittestprocessor2d.cxx
@@ -233,12 +233,8 @@ namespace drawinglayer::processor2d
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// create new local ViewInformation2D containing transformation
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime());
geometry::ViewInformation2D aViewInformation2D(getViewInformation2D());
aViewInformation2D.setObjectTransformation(getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation());
updateViewInformation(aViewInformation2D);
// process child content recursively
diff --git a/drawinglayer/source/processor2d/linegeometryextractor2d.cxx b/drawinglayer/source/processor2d/linegeometryextractor2d.cxx
index 08ec123..11af797 100644
--- a/drawinglayer/source/processor2d/linegeometryextractor2d.cxx
+++ b/drawinglayer/source/processor2d/linegeometryextractor2d.cxx
@@ -84,12 +84,8 @@ namespace drawinglayer::processor2d
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// create new transformations for CurrentTransformation and for local ViewInformation2D
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime());
geometry::ViewInformation2D aViewInformation2D(getViewInformation2D());
aViewInformation2D.setObjectTransformation(getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation());
updateViewInformation(aViewInformation2D);
// process content
diff --git a/drawinglayer/source/processor2d/textaspolygonextractor2d.cxx b/drawinglayer/source/processor2d/textaspolygonextractor2d.cxx
index fcf15b1..c98fae6 100644
--- a/drawinglayer/source/processor2d/textaspolygonextractor2d.cxx
+++ b/drawinglayer/source/processor2d/textaspolygonextractor2d.cxx
@@ -177,12 +177,8 @@ namespace drawinglayer::processor2d
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// create new transformations for CurrentTransformation and for local ViewInformation2D
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime());
geometry::ViewInformation2D aViewInformation2D(getViewInformation2D());
aViewInformation2D.setObjectTransformation(getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation());
updateViewInformation(aViewInformation2D);
// process content
diff --git a/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx b/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
index a231e20..539e012 100644
--- a/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx
@@ -2321,9 +2321,9 @@ void VclMetafileProcessor2D::processTransparencePrimitive2D(
// 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());
geometry::ViewInformation2D aViewInfo(getViewInformation2D());
aViewInfo.setViewTransformation(aViewTransform);
aViewInfo.setViewport(aViewRange);
VclPixelProcessor2D aBufferProcessor(aViewInfo, *aBufferDevice);
diff --git a/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx b/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
index 564b113d..f701ad9 100644
--- a/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
@@ -83,7 +83,7 @@ VclPixelProcessor2D::VclPixelProcessor2D(const geometry::ViewInformation2D& rVie
mpOutputDevice->SetMapMode();
// react on AntiAliasing settings
if (SvtOptionsDrawinglayer::IsAntiAliasing())
if (rViewInformation.getUseAntiAliasing())
{
mpOutputDevice->SetAntialiasing(m_nOrigAntiAliasing | AntialiasingFlags::Enable);
}
@@ -543,7 +543,7 @@ void VclPixelProcessor2D::processPolyPolygonColorPrimitive2D(
// when AA is on and this filled polygons are the result of stroked line geometry,
// draw the geometry once extra as lines to avoid AA 'gaps' between partial polygons
// Caution: This is needed in both cases (!)
if (!(mnPolygonStrokePrimitive2D && SvtOptionsDrawinglayer::IsAntiAliasing()
if (!(mnPolygonStrokePrimitive2D && getViewInformation2D().getUseAntiAliasing()
&& (mpOutputDevice->GetAntialiasing() & AntialiasingFlags::Enable)))
return;
@@ -758,7 +758,7 @@ void VclPixelProcessor2D::processPolygonStrokePrimitive2D(
void VclPixelProcessor2D::processFillHatchPrimitive2D(
const primitive2d::FillHatchPrimitive2D& rFillHatchPrimitive)
{
if (SvtOptionsDrawinglayer::IsAntiAliasing())
if (getViewInformation2D().getUseAntiAliasing())
{
// if AA is used (or ignore smoothing is on), there is no need to smooth
// hatch painting, use decomposition
@@ -925,8 +925,7 @@ void VclPixelProcessor2D::processInvertPrimitive2D(const primitive2d::BasePrimit
void VclPixelProcessor2D::processMetaFilePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
{
// #i98289#
const bool bForceLineSnap(SvtOptionsDrawinglayer::IsAntiAliasing()
&& SvtOptionsDrawinglayer::IsSnapHorVerLinesToDiscrete());
const bool bForceLineSnap(getViewInformation2D().getPixelSnapHairline());
const AntialiasingFlags nOldAntiAliase(mpOutputDevice->GetAntialiasing());
if (bForceLineSnap)
@@ -1045,7 +1044,7 @@ void VclPixelProcessor2D::processPatternFillPrimitive2D(
tools::Rectangle aMaskRect = vcl::unotools::rectangleFromB2DRectangle(aMaskRange);
// Unless smooth edges are needed, simply use clipping.
if (basegfx::utils::isRectangle(aMask) || !SvtOptionsDrawinglayer::IsAntiAliasing())
if (basegfx::utils::isRectangle(aMask) || !getViewInformation2D().getUseAntiAliasing())
{
mpOutputDevice->Push(vcl::PushFlags::CLIPREGION);
mpOutputDevice->IntersectClipRegion(vcl::Region(aMask));
diff --git a/drawinglayer/source/processor2d/vclprocessor2d.cxx b/drawinglayer/source/processor2d/vclprocessor2d.cxx
index a887445..77c35ca 100644
--- a/drawinglayer/source/processor2d/vclprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclprocessor2d.cxx
@@ -407,8 +407,7 @@ void VclProcessor2D::RenderPolygonHairlinePrimitive2D(
basegfx::B2DPolygon aLocalPolygon(rPolygonCandidate.getB2DPolygon());
aLocalPolygon.transform(maCurrentTransformation);
if (bPixelBased && SvtOptionsDrawinglayer::IsAntiAliasing()
&& SvtOptionsDrawinglayer::IsSnapHorVerLinesToDiscrete())
if (bPixelBased && getViewInformation2D().getPixelSnapHairline())
{
// #i98289#
// when a Hairline is painted and AntiAliasing is on the option SnapHorVerLinesToDiscrete
@@ -818,7 +817,7 @@ void VclProcessor2D::RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive
aMask.transform(maCurrentTransformation);
// Unless smooth edges are needed, simply use clipping.
if (isRectangles(aMask) || !SvtOptionsDrawinglayer::IsAntiAliasing())
if (isRectangles(aMask) || !getViewInformation2D().getUseAntiAliasing())
{
mpOutputDevice->Push(vcl::PushFlags::CLIPREGION);
mpOutputDevice->IntersectClipRegion(vcl::Region(aMask));
@@ -954,10 +953,9 @@ void VclProcessor2D::RenderTransformPrimitive2D(
// create new transformations for CurrentTransformation
// and for local ViewInformation2D
maCurrentTransformation = maCurrentTransformation * rTransformCandidate.getTransformation();
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
getViewInformation2D().getViewTransformation(), getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(), getViewInformation2D().getViewTime());
geometry::ViewInformation2D aViewInformation2D(getViewInformation2D());
aViewInformation2D.setObjectTransformation(getViewInformation2D().getObjectTransformation()
* rTransformCandidate.getTransformation());
updateViewInformation(aViewInformation2D);
// process content
@@ -976,10 +974,8 @@ void VclProcessor2D::RenderPagePreviewPrimitive2D(
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// create new local ViewInformation2D
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation(),
getViewInformation2D().getViewTransformation(), getViewInformation2D().getViewport(),
rPagePreviewCandidate.getXDrawPage(), getViewInformation2D().getViewTime());
geometry::ViewInformation2D aViewInformation2D(getViewInformation2D());
aViewInformation2D.setVisualizedPage(rPagePreviewCandidate.getXDrawPage());
updateViewInformation(aViewInformation2D);
// process decomposed content
@@ -1093,7 +1089,7 @@ void VclProcessor2D::RenderPolygonStrokePrimitive2D(
if (nCount)
{
const bool bAntiAliased(SvtOptionsDrawinglayer::IsAntiAliasing());
const bool bAntiAliased(getViewInformation2D().getUseAntiAliasing());
aHairlinePolyPolygon.transform(maCurrentTransformation);
if (bAntiAliased)
diff --git a/include/drawinglayer/geometry/viewinformation2d.hxx b/include/drawinglayer/geometry/viewinformation2d.hxx
index 2957b7d..e71ab08 100644
--- a/include/drawinglayer/geometry/viewinformation2d.hxx
+++ b/include/drawinglayer/geometry/viewinformation2d.hxx
@@ -91,14 +91,18 @@ public:
The time the view is defined for. Default is 0.0. This parameter is used e.g. for
animated objects
@param rReducedDisplayQuality
*/
ViewInformation2D(const basegfx::B2DHomMatrix& rObjectTransformation,
const basegfx::B2DHomMatrix& rViewTransformation,
const basegfx::B2DRange& rViewport,
const css::uno::Reference<css::drawing::XDrawPage>& rxDrawPage,
double fViewTime, bool bReducedDisplayQuality = false);
@param bReducedDisplayQuality
Support reduced DisplayQuality, PropertyName is 'ReducedDisplayQuality'. This
is used e.g. to allow to lower display quality for OverlayPrimitives and
may lead to simpler decompositions in the local create2DDecomposition
implementations of the primitives
@param bUseAntiAliasing
Determine if to use AntiAliasing on target pixel device
@param bPixelSnapHairline
Determine if to use PixelSnapHairline on target pixel device
*/
/// default (empty) constructor
ViewInformation2D();
@@ -120,11 +124,20 @@ public:
/// data access
const basegfx::B2DHomMatrix& getObjectTransformation() const;
void setObjectTransformation(const basegfx::B2DHomMatrix& rNew);
const basegfx::B2DHomMatrix& getViewTransformation() const;
void setViewTransformation(const basegfx::B2DHomMatrix& rNew);
/// Empty viewport means everything is visible.
const basegfx::B2DRange& getViewport() const;
void setViewport(const basegfx::B2DRange& rNew);
double getViewTime() const;
void setViewTime(double fNew);
const css::uno::Reference<css::drawing::XDrawPage>& getVisualizedPage() const;
void setVisualizedPage(const css::uno::Reference<css::drawing::XDrawPage>& rNew);
/// On-demand prepared Object to View transformation and its inverse for convenience
const basegfx::B2DHomMatrix& getObjectToViewTransformation() const;
@@ -134,12 +147,20 @@ public:
/// Empty viewport means everything is visible.
const basegfx::B2DRange& getDiscreteViewport() const;
/** support reduced DisplayQuality, PropertyName is 'ReducedDisplayQuality'. This
is used e.g. to allow to lower display quality for OverlayPrimitives and
may lead to simpler decompositions in the local create2DDecomposition
implementations of the primitives
*/
/// Support reduced DisplayQuality, PropertyName is 'ReducedDisplayQuality'.
bool getReducedDisplayQuality() const;
void setReducedDisplayQuality(bool bNew);
/// Determine if to use AntiAliasing on target pixel device, PropertyName is 'UseAntiAliasing'
bool getUseAntiAliasing() const;
void setUseAntiAliasing(bool bNew);
/// Determine if to use PixelSnapHairline on target pixel device, PropertyName is 'PixelSnapHairline'
bool getPixelSnapHairline() const;
void setPixelSnapHairline(bool bNew);
static void forwardAntiAliasing(bool bAntiAliasing);
static void forwardPixelSnapHairline(bool bPixelSnapHairline);
};
DRAWINGLAYERCORE_DLLPUBLIC ViewInformation2D
diff --git a/sc/source/ui/view/output.cxx b/sc/source/ui/view/output.cxx
index 77bc481..664eca6 100644
--- a/sc/source/ui/view/output.cxx
+++ b/sc/source/ui/view/output.cxx
@@ -1716,12 +1716,10 @@ std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> ScOutputData::Create
basegfx::B2DRange aViewRange;
SdrPage *pDrawPage = pDrawLayer->GetPage( static_cast< sal_uInt16 >( nTab ) );
const drawinglayer::geometry::ViewInformation2D aNewViewInfos(
basegfx::B2DHomMatrix( ),
mpDev->GetViewTransformation(),
aViewRange,
GetXDrawPageForSdrPage( pDrawPage ),
0.0);
drawinglayer::geometry::ViewInformation2D aNewViewInfos;
aNewViewInfos.setViewTransformation(mpDev->GetViewTransformation());
aNewViewInfos.setViewport(aViewRange);
aNewViewInfos.setVisualizedPage(GetXDrawPageForSdrPage( pDrawPage ));
return drawinglayer::processor2d::createProcessor2DFromOutputDevice(
*mpDev, aNewViewInfos );
diff --git a/svtools/Library_svt.mk b/svtools/Library_svt.mk
index a2bc1aa..ec2405d 100644
--- a/svtools/Library_svt.mk
+++ b/svtools/Library_svt.mk
@@ -44,6 +44,7 @@ $(eval $(call gb_Library_use_libraries,svt,\
comphelper \
cppu \
cppuhelper \
drawinglayercore \
i18nlangtag \
i18nutil \
$(if $(ENABLE_JAVA), \
diff --git a/svtools/source/config/optionsdrawinglayer.cxx b/svtools/source/config/optionsdrawinglayer.cxx
index 54efe4a..2fee811 100644
--- a/svtools/source/config/optionsdrawinglayer.cxx
+++ b/svtools/source/config/optionsdrawinglayer.cxx
@@ -22,6 +22,7 @@
#include <vcl/outdev.hxx>
#include <vcl/settings.hxx>
#include <officecfg/Office/Common.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <mutex>
// #i73602#
@@ -124,6 +125,12 @@ static bool gbAntiAliasing = false;
static bool gbAllowAAInit = false;
static bool gbAllowAA = false;
static bool gbAntiAliasingForwardInitial(false);
static bool gbAntiAliasingForwardLast(true);
static bool gbPixelSnapHairlineForwardInitial(false);
static bool gbPixelSnapHairlineForwardLast(true);
bool IsAAPossibleOnThisSystem()
{
std::scoped_lock aGuard(gaAntiAliasMutex);
@@ -148,7 +155,18 @@ bool IsAntiAliasing()
}
bAntiAliasing = gbAntiAliasing;
}
return bAntiAliasing && IsAAPossibleOnThisSystem();
bAntiAliasing = bAntiAliasing && IsAAPossibleOnThisSystem();
//
if (!gbAntiAliasingForwardInitial || gbAntiAliasingForwardLast != bAntiAliasing)
{
gbAntiAliasingForwardInitial = true;
gbAntiAliasingForwardLast = bAntiAliasing;
drawinglayer::geometry::ViewInformation2D::forwardAntiAliasing(bAntiAliasing);
}
return bAntiAliasing;
}
/**
@@ -165,6 +183,13 @@ void SetAntiAliasing( bool bOn, bool bTemporary )
comphelper::ConfigurationChanges::create();
officecfg::Office::Common::Drawinglayer::AntiAliasing::set(bOn, batch);
batch->commit();
if(!gbAntiAliasingForwardInitial || gbAntiAliasingForwardLast != bOn)
{
gbAntiAliasingForwardInitial = true;
gbAntiAliasingForwardLast = bOn;
drawinglayer::geometry::ViewInformation2D::forwardAntiAliasing(bOn);
}
}
gbAntiAliasing = bOn;
}
@@ -172,7 +197,16 @@ void SetAntiAliasing( bool bOn, bool bTemporary )
bool IsSnapHorVerLinesToDiscrete()
{
return IsAntiAliasing() && officecfg::Office::Common::Drawinglayer::SnapHorVerLinesToDiscrete::get();
const bool bRetval(IsAntiAliasing() && officecfg::Office::Common::Drawinglayer::SnapHorVerLinesToDiscrete::get());
if (!gbPixelSnapHairlineForwardInitial || gbPixelSnapHairlineForwardLast != bRetval)
{
gbPixelSnapHairlineForwardInitial = true;
gbPixelSnapHairlineForwardLast = bRetval;
drawinglayer::geometry::ViewInformation2D::forwardPixelSnapHairline(bRetval);
}
return bRetval;
}
bool IsSolidDragCreate()
diff --git a/svx/source/dialog/pagectrl.cxx b/svx/source/dialog/pagectrl.cxx
index a55f6a2..fe44562 100644
--- a/svx/source/dialog/pagectrl.cxx
+++ b/svx/source/dialog/pagectrl.cxx
@@ -352,8 +352,9 @@ void SvxPageWindow::drawFillAttributes(vcl::RenderContext& rRenderContext,
if (aSequence.empty())
return;
const drawinglayer::geometry::ViewInformation2D aViewInformation2D(
basegfx::B2DHomMatrix(), rRenderContext.GetViewTransformation(), aPaintRange, nullptr, 0.0);
drawinglayer::geometry::ViewInformation2D aViewInformation2D;
aViewInformation2D.setViewTransformation(rRenderContext.GetViewTransformation());
aViewInformation2D.setViewport(aPaintRange);
std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor(
drawinglayer::processor2d::createProcessor2DFromOutputDevice(rRenderContext, aViewInformation2D));
diff --git a/svx/source/dialog/weldeditview.cxx b/svx/source/dialog/weldeditview.cxx
index 3cfd53d7..a8716870 100644
--- a/svx/source/dialog/weldeditview.cxx
+++ b/svx/source/dialog/weldeditview.cxx
@@ -231,9 +231,9 @@ void WeldEditView::DoPaint(vcl::RenderContext& rRenderContext, const tools::Rect
sdr::overlay::OverlaySelection aCursorOverlay(sdr::overlay::OverlayType::Transparent,
aHighlight, std::move(aLogicRanges), true);
const drawinglayer::geometry::ViewInformation2D aViewInformation2D(
basegfx::B2DHomMatrix(), rRenderContext.GetViewTransformation(),
vcl::unotools::b2DRectangleFromRectangle(rRect), nullptr, 0.0);
drawinglayer::geometry::ViewInformation2D aViewInformation2D;
aViewInformation2D.setViewTransformation(rRenderContext.GetViewTransformation());
aViewInformation2D.setViewport(vcl::unotools::b2DRectangleFromRectangle(rRect));
std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> xProcessor(
drawinglayer::processor2d::createProcessor2DFromOutputDevice(rRenderContext,
diff --git a/svx/source/sdr/contact/objectcontactofobjlistpainter.cxx b/svx/source/sdr/contact/objectcontactofobjlistpainter.cxx
index ff65e60..cef1cbc 100644
--- a/svx/source/sdr/contact/objectcontactofobjlistpainter.cxx
+++ b/svx/source/sdr/contact/objectcontactofobjlistpainter.cxx
@@ -96,12 +96,10 @@ void ObjectContactOfObjListPainter::ProcessDisplay(DisplayInfo& rDisplayInfo)
}
// update local ViewInformation2D
const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D(
basegfx::B2DHomMatrix(),
pTargetDevice->GetViewTransformation(),
aViewRange,
GetXDrawPageForSdrPage(const_cast< SdrPage* >(mpProcessedPage)),
0.0);
drawinglayer::geometry::ViewInformation2D aNewViewInformation2D;
aNewViewInformation2D.setViewTransformation(pTargetDevice->GetViewTransformation());
aNewViewInformation2D.setViewport(aViewRange);
aNewViewInformation2D.setVisualizedPage(GetXDrawPageForSdrPage(const_cast< SdrPage* >(mpProcessedPage)));
updateViewInformation2D(aNewViewInformation2D);
// collect primitive data in a sequence; this will already use the updated ViewInformation2D
diff --git a/svx/source/sdr/contact/objectcontactofpageview.cxx b/svx/source/sdr/contact/objectcontactofpageview.cxx
index fd8cf5b..9d0918a 100644
--- a/svx/source/sdr/contact/objectcontactofpageview.cxx
+++ b/svx/source/sdr/contact/objectcontactofpageview.cxx
@@ -208,12 +208,11 @@ namespace sdr::contact
}
// update local ViewInformation2D
const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D(
basegfx::B2DHomMatrix(),
rTargetOutDev.GetViewTransformation(),
aViewRange,
GetXDrawPageForSdrPage(GetSdrPage()),
fCurrentTime);
drawinglayer::geometry::ViewInformation2D aNewViewInformation2D;
aNewViewInformation2D.setViewTransformation(rTargetOutDev.GetViewTransformation());
aNewViewInformation2D.setViewport(aViewRange);
aNewViewInformation2D.setVisualizedPage(GetXDrawPageForSdrPage(GetSdrPage()));
aNewViewInformation2D.setViewTime(fCurrentTime);
updateViewInformation2D(aNewViewInformation2D);
// if there is something to show, use a primitive processor to render it. There
diff --git a/svx/source/sdr/contact/viewobjectcontactofpageobj.cxx b/svx/source/sdr/contact/viewobjectcontactofpageobj.cxx
index d838a13..fb60e6b 100644
--- a/svx/source/sdr/contact/viewobjectcontactofpageobj.cxx
+++ b/svx/source/sdr/contact/viewobjectcontactofpageobj.cxx
@@ -124,20 +124,21 @@ drawinglayer::primitive2d::Primitive2DContainer PagePrimitiveExtractor::createPr
{
// update own ViewInformation2D for visualized page
const drawinglayer::geometry::ViewInformation2D& rOriginalViewInformation = mrViewObjectContactOfPageObj.GetObjectContact().getViewInformation2D();
const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D(
rOriginalViewInformation.getObjectTransformation(),
rOriginalViewInformation.getViewTransformation(),
drawinglayer::geometry::ViewInformation2D aNewViewInformation2D(rOriginalViewInformation);
// #i101075# use empty range for page content here to force
// the content not to be physically clipped in any way. This
// would be possible, but would require the internal transformation
// which maps between the page visualisation object and the page
// content, including the aspect ratios (for details see in
// PagePreviewPrimitive2D::create2DDecomposition)
basegfx::B2DRange(),
// #i101075# use empty range for page content here to force
// the content not to be physically clipped in any way. This
// would be possible, but would require the internal transformation
// which maps between the page visualisation object and the page
// content, including the aspect ratios (for details see in
// PagePreviewPrimitive2D::create2DDecomposition)
aNewViewInformation2D.setViewport(basegfx::B2DRange());
GetXDrawPageForSdrPage(pStartPage),
0.0); // no time; page previews are not animated
aNewViewInformation2D.setVisualizedPage(GetXDrawPageForSdrPage(pStartPage));
// no time; page previews are not animated
aNewViewInformation2D.setViewTime(0.0);
updateViewInformation2D(aNewViewInformation2D);
// create copy of DisplayInfo to set PagePainting
diff --git a/svx/source/sdr/overlay/overlaymanager.cxx b/svx/source/sdr/overlay/overlaymanager.cxx
index c29138d..21d3a54 100644
--- a/svx/source/sdr/overlay/overlaymanager.cxx
+++ b/svx/source/sdr/overlay/overlaymanager.cxx
@@ -46,7 +46,7 @@ namespace sdr::overlay
return;
const AntialiasingFlags nOriginalAA(rDestinationDevice.GetAntialiasing());
const bool bIsAntiAliasing(SvtOptionsDrawinglayer::IsAntiAliasing());
const bool bIsAntiAliasing(getCurrentViewInformation2D().getUseAntiAliasing());
// tdf#150622 for High Contrast we typically force colors to a single pair Fore/Back,
// but it seems reasonable to allow overlays to use the selection color
// taken from the system High Contrast settings
@@ -137,8 +137,8 @@ namespace sdr::overlay
mnStripeLengthPixel(5),
mfDiscreteOne(0.0)
{
// set Property 'ReducedDisplayQuality' to true to allow simpler interaction
// visualisations
// Set Property 'ReducedDisplayQuality' to true to allow simpler interaction
// visualisations. Note: Currently will use reduced quality for 3d scene soft renderer
uno::Sequence< beans::PropertyValue > xProperties{
comphelper::makePropertyValue("ReducedDisplayQuality", true)
};
@@ -172,12 +172,11 @@ namespace sdr::overlay
OverlayManager* pThis = const_cast< OverlayManager* >(this);
pThis->maViewTransformation = getOutputDevice().GetViewTransformation();
pThis->maViewInformation2D = drawinglayer::geometry::ViewInformation2D(
maViewInformation2D.getObjectTransformation(),
maViewTransformation,
aViewRange,
maViewInformation2D.getVisualizedPage(),
maViewInformation2D.getViewTime());
drawinglayer::geometry::ViewInformation2D aViewInformation(maViewInformation2D);
aViewInformation.setViewTransformation(maViewTransformation);
aViewInformation.setViewport(aViewRange);
pThis->maViewInformation2D = aViewInformation;
pThis->mfDiscreteOne = 0.0;
}
@@ -296,7 +295,7 @@ namespace sdr::overlay
if (rRange.isEmpty()) {
return {};
}
if (SvtOptionsDrawinglayer::IsAntiAliasing())
if (getCurrentViewInformation2D().getUseAntiAliasing())
{
// assume AA needs one pixel more and invalidate one pixel more
const double fDiscreteOne(getDiscreteOne());
diff --git a/svx/source/sdr/overlay/overlaymanagerbuffered.cxx b/svx/source/sdr/overlay/overlaymanagerbuffered.cxx
index 19babd0..3651717 100644
--- a/svx/source/sdr/overlay/overlaymanagerbuffered.cxx
+++ b/svx/source/sdr/overlay/overlaymanagerbuffered.cxx
@@ -412,7 +412,7 @@ namespace sdr::overlay
basegfx::B2DRange aDiscreteRange(rRange);
aDiscreteRange.transform(getOutputDevice().GetViewTransformation());
if(SvtOptionsDrawinglayer::IsAntiAliasing())
if(getCurrentViewInformation2D().getUseAntiAliasing())
{
// assume AA needs one pixel more and invalidate one pixel more
const double fDiscreteOne(getDiscreteOne());
diff --git a/sw/source/core/doc/notxtfrm.cxx b/sw/source/core/doc/notxtfrm.cxx
index 7436d23..b0e0a92 100644
--- a/sw/source/core/doc/notxtfrm.cxx
+++ b/sw/source/core/doc/notxtfrm.cxx
@@ -888,12 +888,10 @@ static bool paintUsingPrimitivesHelper(
// embed the primitives to it. Use original TargetRange here so there is also
// no need to embed the primitives to a MaskPrimitive for cropping. This works
// only in this case where the graphic object cannot be rotated, though.
const drawinglayer::geometry::ViewInformation2D aViewInformation2D(
aMappingTransform,
rOutputDevice.GetViewTransformation(),
rTargetRange,
nullptr,
0.0);
drawinglayer::geometry::ViewInformation2D aViewInformation2D;
aViewInformation2D.setObjectTransformation(aMappingTransform);
aViewInformation2D.setViewTransformation(rOutputDevice.GetViewTransformation());
aViewInformation2D.setViewport(rTargetRange);
// get a primitive processor for rendering
std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D(
diff --git a/sw/source/core/layout/paintfrm.cxx b/sw/source/core/layout/paintfrm.cxx
index b42fc48..5127624 100644
--- a/sw/source/core/layout/paintfrm.cxx
+++ b/sw/source/core/layout/paintfrm.cxx
@@ -1795,12 +1795,10 @@ bool DrawFillAttributes(
}
assert(pPrimitives && pPrimitives->size());
const drawinglayer::geometry::ViewInformation2D aViewInformation2D(
basegfx::B2DHomMatrix(),
rOut.GetViewTransformation(),
aPaintRange,
nullptr,
0.0);
drawinglayer::geometry::ViewInformation2D aViewInformation2D;
aViewInformation2D.setViewTransformation(rOut.GetViewTransformation());
aViewInformation2D.setViewport(aPaintRange);
std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor(drawinglayer::processor2d::createProcessor2DFromOutputDevice(
rOut,
aViewInformation2D) );
@@ -5187,12 +5185,10 @@ std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> SwFrame::CreateProce
basegfx::B2DRange aViewRange;
SdrPage *pDrawPage = getRootFrame()->GetCurrShell()->Imp()->GetPageView()->GetPage();
const drawinglayer::geometry::ViewInformation2D aNewViewInfos(
basegfx::B2DHomMatrix( ),
getRootFrame()->GetCurrShell()->GetOut()->GetViewTransformation(),
aViewRange,
GetXDrawPageForSdrPage( pDrawPage ),
0.0);
drawinglayer::geometry::ViewInformation2D aNewViewInfos;
aNewViewInfos.setViewTransformation(getRootFrame()->GetCurrShell()->GetOut()->GetViewTransformation());
aNewViewInfos.setViewport(aViewRange);
aNewViewInfos.setVisualizedPage(GetXDrawPageForSdrPage( pDrawPage ));
return drawinglayer::processor2d::createProcessor2DFromOutputDevice(
*getRootFrame()->GetCurrShell()->GetOut(),
