drawinglayer/Library_drawinglayercore.mk | 4 drawinglayer/source/geometry/viewinformation2d.cxx | 215 +++++++++-- drawinglayer/source/primitive2d/GlowSoftEgdeShadowTools.cxx | 9 drawinglayer/source/processor2d/contourextractor2d.cxx | 8 drawinglayer/source/processor2d/hittestprocessor2d.cxx | 8 drawinglayer/source/processor2d/linegeometryextractor2d.cxx | 8 drawinglayer/source/processor2d/textaspolygonextractor2d.cxx | 8 drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx | 6 drawinglayer/source/processor2d/vclpixelprocessor2d.cxx | 11 drawinglayer/source/processor2d/vclprocessor2d.cxx | 20 - include/drawinglayer/geometry/viewinformation2d.hxx | 45 +- sc/source/ui/view/output.cxx | 10 svtools/Library_svt.mk | 1 svtools/source/config/optionsdrawinglayer.cxx | 38 + svx/source/dialog/pagectrl.cxx | 5 svx/source/dialog/weldeditview.cxx | 6 svx/source/sdr/contact/objectcontactofobjlistpainter.cxx | 10 svx/source/sdr/contact/objectcontactofpageview.cxx | 11 svx/source/sdr/contact/viewobjectcontactofpageobj.cxx | 29 - svx/source/sdr/overlay/overlaymanager.cxx | 19 svx/source/sdr/overlay/overlaymanagerbuffered.cxx | 2 sw/source/core/doc/notxtfrm.cxx | 10 sw/source/core/layout/paintfrm.cxx | 20 - 23 files changed, 333 insertions(+), 170 deletions(-)
New commits: commit 444bf8710d5da7b584fbcb94693e4ed8d2e29297 Author: Armin Le Grand (allotropia) <[email protected]> AuthorDate: Sun Nov 6 13:57:11 2022 +0100 Commit: Armin Le Grand <[email protected]> CommitDate: Tue Nov 8 11:16:30 2022 +0100 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 <[email protected]> diff --git a/drawinglayer/Library_drawinglayercore.mk b/drawinglayer/Library_drawinglayercore.mk index 9e089e9a0760..7ec954416a23 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 6de309286d9d..d23dda648bed 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 0a3249399a44..3c45fdd030f4 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 a1d1200183cc..65e8ef86a29e 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 dc7d6fa7cb3f..1ebc8d541619 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 08ec1232d137..11af79725b41 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 fcf15b189ed2..c98fae69d301 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 a231e20153ef..539e01282a2f 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 564b113d8f86..f701ad9bbeeb 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 a8874453bd4f..77c35caa1e27 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 2957b7daf709..e71ab08faead 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 77bc4810f4a6..664eca6cb999 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 a2bc1aad7ccf..ec2405d65636 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 54efe4a66326..2fee81139800 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 a55f6a2577cb..fe44562ff230 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 3cfd53d707bb..a87168708ddb 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 ff65e60fcf7c..cef1cbc1f289 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 fd8cf5b4a1ca..9d0918a5d22a 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 d838a13c6eca..fb60e6b55965 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(), - - // #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(), - - GetXDrawPageForSdrPage(pStartPage), - 0.0); // no time; page previews are not animated + 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) + aNewViewInformation2D.setViewport(basegfx::B2DRange()); + + 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 c29138de8b87..21d3a5458cfa 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 19babd089e54..365171757934 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 7436d235485b..b0e0a92e6aac 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 b42fc48acb37..5127624df73c 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(),
