drawinglayer/source/geometry/viewinformation2d.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <drawinglayer/geometry/viewinformation2d.hxx>
  21 #include <basegfx/matrix/b2dhommatrix.hxx>
  22 #include <basegfx/range/b2drange.hxx>
  23 #include <basegfx/utils/canvastools.hxx>
  24 #include <com/sun/star/beans/PropertyValue.hpp>
  25 #include <com/sun/star/drawing/XDrawPage.hpp>
  26 #include <com/sun/star/geometry/AffineMatrix2D.hpp>
  27 #include <com/sun/star/geometry/RealRectangle2D.hpp>
  28 #include <officecfg/Office/Common.hxx>
  29 #include <unotools/configmgr.hxx>
  30 #include <utility>
  31
  32 using namespace com::sun::star;
  33
  34 namespace drawinglayer::geometry
  35 {
  36 namespace
  37 {
  38 constexpr OUStringLiteral g_PropertyName_ObjectTransformation = u"ObjectTransformation";
  39 constexpr OUStringLiteral g_PropertyName_ViewTransformation = u"ViewTransformation";
  40 constexpr OUStringLiteral g_PropertyName_Viewport = u"Viewport";
  41 constexpr OUStringLiteral g_PropertyName_Time = u"Time";
  42 constexpr OUStringLiteral g_PropertyName_VisualizedPage = u"VisualizedPage";
  43 constexpr OUStringLiteral g_PropertyName_ReducedDisplayQuality = u"ReducedDisplayQuality";
  44 constexpr OUStringLiteral g_PropertyName_UseAntiAliasing = u"UseAntiAliasing";
  45 constexpr OUStringLiteral g_PropertyName_PixelSnapHairline = u"PixelSnapHairline";
  46 }
  47
  48 namespace
  49 {
  50 bool bForwardsAreInitialized(false);
  51 bool bForwardedAntiAliasing(true);
  52 bool bForwardPixelSnapHairline(true);
  53 }
  54
  55 class ImpViewInformation2D
  56 {
  57 private:
  58     // ViewInformation2D implementation can change refcount, so we have only
  59     // two memory regions for pairs of ViewInformation2D/ImpViewInformation2D
  60     friend class ::drawinglayer::geometry::ViewInformation2D;
  61
  62 protected:
  63     // the object transformation
  64     basegfx::B2DHomMatrix maObjectTransformation;
  65
  66     // the view transformation
  67     basegfx::B2DHomMatrix maViewTransformation;
  68
  69     // the ObjectToView and it's inverse, both on demand from ObjectTransformation
  70     // and ViewTransformation
  71     basegfx::B2DHomMatrix maObjectToViewTransformation;
  72     basegfx::B2DHomMatrix maInverseObjectToViewTransformation;
  73
  74     // the visible range and the on-demand one in ViewCoordinates
  75     basegfx::B2DRange maViewport;
  76     basegfx::B2DRange maDiscreteViewport;
  77
  78     // the DrawPage which is target of visualisation. This is needed e.g. for
  79     // the view-dependent decomposition of PageNumber TextFields.
  80     // This parameter is buffered here, but mainly resides in mxExtendedInformation,
  81     // so it will be interpreted, but held there. It will also not be added
  82     // to mxExtendedInformation in impFillViewInformationFromContent (it's there already)
  83     uno::Reference<drawing::XDrawPage> mxVisualizedPage;
  84
  85     // the point in time
  86     double mfViewTime;
  87
  88     // allow to reduce DisplayQuality (e.g. sw 3d fallback renderer for interactions)
  89     bool mbReducedDisplayQuality : 1;
  90
  91     // determine if to use AntiAliasing on target pixel device
  92     bool mbUseAntiAliasing : 1;
  93
  94     // determine if to use PixelSnapHairline on target pixel device
  95     bool mbPixelSnapHairline : 1;
  96
  97 public:
  98     ImpViewInformation2D()
  99         : maObjectTransformation()
 100         , maViewTransformation()
 101         , maObjectToViewTransformation()
 102         , maInverseObjectToViewTransformation()
 103         , maViewport()
 104         , maDiscreteViewport()
 105         , mxVisualizedPage()
 106         , mfViewTime(0.0)
 107         , mbReducedDisplayQuality(false)
 108         , mbUseAntiAliasing(bForwardedAntiAliasing)
 109         , mbPixelSnapHairline(bForwardedAntiAliasing && bForwardPixelSnapHairline)
 110     {
 111     }
 112
 113     const basegfx::B2DHomMatrix& getObjectTransformation() const { return maObjectTransformation; }
 114     void setObjectTransformation(const basegfx::B2DHomMatrix& rNew)
 115     {
 116         maObjectTransformation = rNew;
 117         maObjectToViewTransformation.identity();
 118         maInverseObjectToViewTransformation.identity();
 119     }
 120
 121     const basegfx::B2DHomMatrix& getViewTransformation() const { return maViewTransformation; }
 122     void setViewTransformation(const basegfx::B2DHomMatrix& rNew)
 123     {
 124         maViewTransformation = rNew;
 125         maDiscreteViewport.reset();
 126         maObjectToViewTransformation.identity();
 127         maInverseObjectToViewTransformation.identity();
 128     }
 129
 130     const basegfx::B2DRange& getViewport() const { return maViewport; }
 131     void setViewport(const basegfx::B2DRange& rNew)
 132     {
 133         maViewport = rNew;
 134         maDiscreteViewport.reset();
 135     }
 136
 137     const basegfx::B2DRange& getDiscreteViewport() const
 138     {
 139         if (maDiscreteViewport.isEmpty() && !maViewport.isEmpty())
 140         {
 141             basegfx::B2DRange aDiscreteViewport(maViewport);
 142             aDiscreteViewport.transform(getViewTransformation());
 143             const_cast<ImpViewInformation2D*>(this)->maDiscreteViewport = aDiscreteViewport;
 144         }
 145
 146         return maDiscreteViewport;
 147     }
 148
 149     const basegfx::B2DHomMatrix& getObjectToViewTransformation() const
 150     {
 151         if (maObjectToViewTransformation.isIdentity()
 152             && (!maObjectTransformation.isIdentity() || !maViewTransformation.isIdentity()))
 153         {
 154             basegfx::B2DHomMatrix aObjectToView(maViewTransformation * maObjectTransformation);
 155             const_cast<ImpViewInformation2D*>(this)->maObjectToViewTransformation = aObjectToView;
 156         }
 157
 158         return maObjectToViewTransformation;
 159     }
 160
 161     const basegfx::B2DHomMatrix& getInverseObjectToViewTransformation() const
 162     {
 163         if (maInverseObjectToViewTransformation.isIdentity()
 164             && (!maObjectTransformation.isIdentity() || !maViewTransformation.isIdentity()))
 165         {
 166             basegfx::B2DHomMatrix aInverseObjectToView(maViewTransformation
 167                                                        * maObjectTransformation);
 168             aInverseObjectToView.invert();
 169             const_cast<ImpViewInformation2D*>(this)->maInverseObjectToViewTransformation
 170                 = aInverseObjectToView;
 171         }
 172
 173         return maInverseObjectToViewTransformation;
 174     }
 175
 176     double getViewTime() const { return mfViewTime; }
 177     void setViewTime(double fNew)
 178     {
 179         if (fNew >= 0.0)
 180         {
 181             mfViewTime = fNew;
 182         }
 183     }
 184
 185     const uno::Reference<drawing::XDrawPage>& getVisualizedPage() const { return mxVisualizedPage; }
 186     void setVisualizedPage(const uno::Reference<drawing::XDrawPage>& rNew)
 187     {
 188         mxVisualizedPage = rNew;
 189     }
 190
 191     bool getReducedDisplayQuality() const { return mbReducedDisplayQuality; }
 192     void setReducedDisplayQuality(bool bNew) { mbReducedDisplayQuality = bNew; }
 193
 194     bool getUseAntiAliasing() const { return mbUseAntiAliasing; }
 195     void setUseAntiAliasing(bool bNew) { mbUseAntiAliasing = bNew; }
 196
 197     bool getPixelSnapHairline() const { return mbPixelSnapHairline; }
 198     void setPixelSnapHairline(bool bNew) { mbPixelSnapHairline = bNew; }
 199
 200     bool operator==(const ImpViewInformation2D& rCandidate) const
 201     {
 202         return (maObjectTransformation == rCandidate.maObjectTransformation
 203                 && maViewTransformation == rCandidate.maViewTransformation
 204                 && maViewport == rCandidate.maViewport
 205                 && mxVisualizedPage == rCandidate.mxVisualizedPage
 206                 && mfViewTime == rCandidate.mfViewTime
 207                 && mbReducedDisplayQuality == rCandidate.mbReducedDisplayQuality
 208                 && mbUseAntiAliasing == rCandidate.mbUseAntiAliasing
 209                 && mbPixelSnapHairline == rCandidate.mbPixelSnapHairline);
 210     }
 211 };
 212
 213 namespace
 214 {
 215 ViewInformation2D::ImplType& theGlobalDefault()
 216 {
 217     static ViewInformation2D::ImplType SINGLETON;
 218     return SINGLETON;
 219 }
 220 }
 221
 222 ViewInformation2D::ViewInformation2D()
 223     : mpViewInformation2D(theGlobalDefault())
 224 {
 225     if (!bForwardsAreInitialized)
 226     {
 227         bForwardsAreInitialized = true;
 228         if (!utl::ConfigManager::IsFuzzing())
 229         {
 230             bForwardedAntiAliasing = officecfg::Office::Common::Drawinglayer::AntiAliasing::get();
 231             bForwardPixelSnapHairline
 232                 = officecfg::Office::Common::Drawinglayer::SnapHorVerLinesToDiscrete::get();
 233         }
 234     }
 235
 236     setUseAntiAliasing(bForwardedAntiAliasing);
 237     setPixelSnapHairline(bForwardPixelSnapHairline);
 238 }
 239
 240 ViewInformation2D::ViewInformation2D(const ViewInformation2D&) = default;
 241
 242 ViewInformation2D::ViewInformation2D(ViewInformation2D&&) = default;
 243
 244 ViewInformation2D::~ViewInformation2D() = default;
 245
 246 ViewInformation2D& ViewInformation2D::operator=(const ViewInformation2D&) = default;
 247
 248 ViewInformation2D& ViewInformation2D::operator=(ViewInformation2D&&) = default;
 249
 250 bool ViewInformation2D::operator==(const ViewInformation2D& rCandidate) const
 251 {
 252     return rCandidate.mpViewInformation2D == mpViewInformation2D;
 253 }
 254
 255 const basegfx::B2DHomMatrix& ViewInformation2D::getObjectTransformation() const
 256 {
 257     return mpViewInformation2D->getObjectTransformation();
 258 }
 259
 260 void ViewInformation2D::setObjectTransformation(const basegfx::B2DHomMatrix& rNew)
 261 {
 262     if (std::as_const(mpViewInformation2D)->getObjectTransformation() != rNew)
 263         mpViewInformation2D->setObjectTransformation(rNew);
 264 }
 265
 266 const basegfx::B2DHomMatrix& ViewInformation2D::getViewTransformation() const
 267 {
 268     return mpViewInformation2D->getViewTransformation();
 269 }
 270
 271 void ViewInformation2D::setViewTransformation(const basegfx::B2DHomMatrix& rNew)
 272 {
 273     if (std::as_const(mpViewInformation2D)->getViewTransformation() != rNew)
 274         mpViewInformation2D->setViewTransformation(rNew);
 275 }
 276
 277 const basegfx::B2DRange& ViewInformation2D::getViewport() const
 278 {
 279     return mpViewInformation2D->getViewport();
 280 }
 281
 282 void ViewInformation2D::setViewport(const basegfx::B2DRange& rNew)
 283 {
 284     if (rNew != std::as_const(mpViewInformation2D)->getViewport())
 285         mpViewInformation2D->setViewport(rNew);
 286 }
 287
 288 double ViewInformation2D::getViewTime() const { return mpViewInformation2D->getViewTime(); }
 289
 290 void ViewInformation2D::setViewTime(double fNew)
 291 {
 292     if (fNew != std::as_const(mpViewInformation2D)->getViewTime())
 293         mpViewInformation2D->setViewTime(fNew);
 294 }
 295
 296 const uno::Reference<drawing::XDrawPage>& ViewInformation2D::getVisualizedPage() const
 297 {
 298     return mpViewInformation2D->getVisualizedPage();
 299 }
 300
 301 void ViewInformation2D::setVisualizedPage(const uno::Reference<drawing::XDrawPage>& rNew)
 302 {
 303     if (rNew != std::as_const(mpViewInformation2D)->getVisualizedPage())
 304         mpViewInformation2D->setVisualizedPage(rNew);
 305 }
 306
 307 const basegfx::B2DHomMatrix& ViewInformation2D::getObjectToViewTransformation() const
 308 {
 309     return mpViewInformation2D->getObjectToViewTransformation();
 310 }
 311
 312 const basegfx::B2DHomMatrix& ViewInformation2D::getInverseObjectToViewTransformation() const
 313 {
 314     return mpViewInformation2D->getInverseObjectToViewTransformation();
 315 }
 316
 317 const basegfx::B2DRange& ViewInformation2D::getDiscreteViewport() const
 318 {
 319     return mpViewInformation2D->getDiscreteViewport();
 320 }
 321
 322 bool ViewInformation2D::getReducedDisplayQuality() const
 323 {
 324     return mpViewInformation2D->getReducedDisplayQuality();
 325 }
 326
 327 void ViewInformation2D::setReducedDisplayQuality(bool bNew)
 328 {
 329     if (bNew != std::as_const(mpViewInformation2D)->getReducedDisplayQuality())
 330         mpViewInformation2D->setReducedDisplayQuality(bNew);
 331 }
 332
 333 bool ViewInformation2D::getUseAntiAliasing() const
 334 {
 335     return mpViewInformation2D->getUseAntiAliasing();
 336 }
 337
 338 void ViewInformation2D::setUseAntiAliasing(bool bNew)
 339 {
 340     if (bNew != std::as_const(mpViewInformation2D)->getUseAntiAliasing())
 341         mpViewInformation2D->setUseAntiAliasing(bNew);
 342 }
 343
 344 bool ViewInformation2D::getPixelSnapHairline() const
 345 {
 346     return mpViewInformation2D->getPixelSnapHairline();
 347 }
 348
 349 void ViewInformation2D::setPixelSnapHairline(bool bNew)
 350 {
 351     if (bNew != std::as_const(mpViewInformation2D)->getPixelSnapHairline())
 352         mpViewInformation2D->setPixelSnapHairline(bNew);
 353 }
 354
 355 void ViewInformation2D::forwardAntiAliasing(bool bAntiAliasing)
 356 {
 357     bForwardedAntiAliasing = bAntiAliasing;
 358 }
 359
 360 void ViewInformation2D::forwardPixelSnapHairline(bool bPixelSnapHairline)
 361 {
 362     bForwardPixelSnapHairline = bPixelSnapHairline;
 363 }
 364
 365 ViewInformation2D
 366 createViewInformation2D(const css::uno::Sequence<css::beans::PropertyValue>& rViewParameters)
 367 {
 368     if (!rViewParameters.hasElements())
 369         return ViewInformation2D();
 370
 371     ViewInformation2D aRetval;
 372
 373     for (auto const& rPropertyValue : rViewParameters)
 374     {
 375         if (rPropertyValue.Name == g_PropertyName_ReducedDisplayQuality)
 376         {
 377             bool bNew(false);
 378             rPropertyValue.Value >>= bNew;
 379             aRetval.setReducedDisplayQuality(bNew);
 380         }
 381         else if (rPropertyValue.Name == g_PropertyName_PixelSnapHairline)
 382         {
 383             bool bNew(
 384                 true); //SvtOptionsDrawinglayer::IsAntiAliasing() && SvtOptionsDrawinglayer::IsSnapHorVerLinesToDiscrete());
 385             rPropertyValue.Value >>= bNew;
 386             aRetval.setPixelSnapHairline(bNew);
 387         }
 388         else if (rPropertyValue.Name == g_PropertyName_UseAntiAliasing)
 389         {
 390             bool bNew(true); //SvtOptionsDrawinglayer::IsAntiAliasing());
 391             rPropertyValue.Value >>= bNew;
 392             aRetval.setUseAntiAliasing(bNew);
 393         }
 394         else if (rPropertyValue.Name == g_PropertyName_ObjectTransformation)
 395         {
 396             css::geometry::AffineMatrix2D aAffineMatrix2D;
 397             rPropertyValue.Value >>= aAffineMatrix2D;
 398             basegfx::B2DHomMatrix aTransformation;
 399             basegfx::unotools::homMatrixFromAffineMatrix(aTransformation, aAffineMatrix2D);
 400             aRetval.setObjectTransformation(aTransformation);
 401         }
 402         else if (rPropertyValue.Name == g_PropertyName_ViewTransformation)
 403         {
 404             css::geometry::AffineMatrix2D aAffineMatrix2D;
 405             rPropertyValue.Value >>= aAffineMatrix2D;
 406             basegfx::B2DHomMatrix aTransformation;
 407             basegfx::unotools::homMatrixFromAffineMatrix(aTransformation, aAffineMatrix2D);
 408             aRetval.setViewTransformation(aTransformation);
 409         }
 410         else if (rPropertyValue.Name == g_PropertyName_Viewport)
 411         {
 412             css::geometry::RealRectangle2D aUnoViewport;
 413             rPropertyValue.Value >>= aUnoViewport;
 414             const basegfx::B2DRange aViewport(
 415                 basegfx::unotools::b2DRectangleFromRealRectangle2D(aUnoViewport));
 416             aRetval.setViewport(aViewport);
 417         }
 418         else if (rPropertyValue.Name == g_PropertyName_Time)
 419         {
 420             double fViewTime(0.0);
 421             rPropertyValue.Value >>= fViewTime;
 422             aRetval.setViewTime(fViewTime);
 423         }
 424         else if (rPropertyValue.Name == g_PropertyName_VisualizedPage)
 425         {
 426             css::uno::Reference<css::drawing::XDrawPage> xVisualizedPage;
 427             rPropertyValue.Value >>= xVisualizedPage;
 428             aRetval.setVisualizedPage(xVisualizedPage);
 429         }
 430     }
 431
 432     return aRetval;
 433 }
 434
 435 } // end of namespace drawinglayer::geometry
 436
 437 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */