LCOV - code coverage report
Current view: top level - drawinglayer/source/geometry - viewinformation2d.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 99 193 51.3 %
Date: 2014-11-03 Functions: 33 43 76.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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/tools/canvastools.hxx>
      24             : #include <com/sun/star/geometry/AffineMatrix2D.hpp>
      25             : #include <com/sun/star/geometry/RealRectangle2D.hpp>
      26             : #include <rtl/instance.hxx>
      27             : 
      28             : 
      29             : 
      30             : using namespace com::sun::star;
      31             : 
      32             : 
      33             : 
      34             : namespace drawinglayer
      35             : {
      36             :     namespace geometry
      37             :     {
      38      305441 :         class ImpViewInformation2D
      39             :         {
      40             :         private:
      41             :             // ViewInformation2D implementation can change refcount, so we have only
      42             :             // two memory regions for pairs of ViewInformation2D/ImpViewInformation2D
      43             :             friend class ::drawinglayer::geometry::ViewInformation2D;
      44             : 
      45             :         protected:
      46             :             // the object transformation
      47             :             basegfx::B2DHomMatrix                       maObjectTransformation;
      48             : 
      49             :             // the view transformation
      50             :             basegfx::B2DHomMatrix                       maViewTransformation;
      51             : 
      52             :             // the ObjectToView and it's inverse, both on demand from ObjectTransformation
      53             :             // and ViewTransformation
      54             :             basegfx::B2DHomMatrix                       maObjectToViewTransformation;
      55             :             basegfx::B2DHomMatrix                       maInverseObjectToViewTransformation;
      56             : 
      57             :             // the visible range and the on-demand one in ViewCoordinates
      58             :             basegfx::B2DRange                           maViewport;
      59             :             basegfx::B2DRange                           maDiscreteViewport;
      60             : 
      61             :             // the DrawPage which is target of visualisation. This is needed e.g. for
      62             :             // the view-dependent decomposition of PageNumber TextFields.
      63             :             // This parameter is buffered here, but mainly resides in mxExtendedInformation,
      64             :             // so it will be interpreted, but held there. It will also not be added
      65             :             // to mxExtendedInformation in impFillViewInformationFromContent (it's there already)
      66             :             uno::Reference< drawing::XDrawPage >        mxVisualizedPage;
      67             : 
      68             :             // the point in time
      69             :             double                                      mfViewTime;
      70             : 
      71             :             // bitfield
      72             :             bool                                        mbReducedDisplayQuality : 1;
      73             : 
      74             :             // the complete PropertyValue representation (if already created)
      75             :             uno::Sequence< beans::PropertyValue >       mxViewInformation;
      76             : 
      77             :             // the extra PropertyValues; not represented by ViewTransformation,
      78             :             // Viewport, VisualizedPage or ViewTime
      79             :             uno::Sequence< beans::PropertyValue >       mxExtendedInformation;
      80             : 
      81             :             // the local UNO API strings
      82           0 :             const OUString& getNamePropertyObjectTransformation()
      83             :             {
      84           0 :                 static OUString s_sNameProperty("ObjectTransformation");
      85           0 :                 return s_sNameProperty;
      86             :             }
      87             : 
      88           0 :             const OUString& getNamePropertyViewTransformation()
      89             :             {
      90           0 :                 static OUString s_sNameProperty("ViewTransformation");
      91           0 :                 return s_sNameProperty;
      92             :             }
      93             : 
      94           0 :             const OUString& getNamePropertyViewport()
      95             :             {
      96           0 :                 static OUString s_sNameProperty("Viewport");
      97           0 :                 return s_sNameProperty;
      98             :             }
      99             : 
     100           0 :             const OUString& getNamePropertyTime()
     101             :             {
     102           0 :                 static OUString s_sNameProperty("Time");
     103           0 :                 return s_sNameProperty;
     104             :             }
     105             : 
     106           0 :             const OUString& getNamePropertyVisualizedPage()
     107             :             {
     108           0 :                 static OUString s_sNameProperty("VisualizedPage");
     109           0 :                 return s_sNameProperty;
     110             :             }
     111             : 
     112        3241 :             const OUString& getNamePropertyReducedDisplayQuality()
     113             :             {
     114        3241 :                 static OUString s_sNameProperty("ReducedDisplayQuality");
     115        3241 :                 return s_sNameProperty;
     116             :             }
     117             : 
     118      101777 :             void impInterpretPropertyValues(const uno::Sequence< beans::PropertyValue >& rViewParameters)
     119             :             {
     120      101777 :                 if(rViewParameters.hasElements())
     121             :                 {
     122        3241 :                     const sal_Int32 nCount(rViewParameters.getLength());
     123        3241 :                     sal_Int32 nExtendedInsert(0);
     124             : 
     125             :                     // prepare extended information for filtering. Maximum size is nCount
     126        3241 :                     mxExtendedInformation.realloc(nCount);
     127             : 
     128        6482 :                     for(sal_Int32 a(0); a < nCount; a++)
     129             :                     {
     130        3241 :                         const beans::PropertyValue& rProp = rViewParameters[a];
     131             : 
     132        3241 :                         if(rProp.Name == getNamePropertyReducedDisplayQuality())
     133             :                         {
     134             :                             // extra information; add to filtered information
     135        3241 :                             mxExtendedInformation[nExtendedInsert++] = rProp;
     136             : 
     137             :                             // for performance reasons, also cache content locally
     138        3241 :                             bool bSalBool(false);
     139        3241 :                             rProp.Value >>= bSalBool;
     140        3241 :                             mbReducedDisplayQuality = bSalBool;
     141             :                         }
     142           0 :                         else if(rProp.Name == getNamePropertyObjectTransformation())
     143             :                         {
     144           0 :                             com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
     145           0 :                             rProp.Value >>= aAffineMatrix2D;
     146           0 :                             basegfx::unotools::homMatrixFromAffineMatrix(maObjectTransformation, aAffineMatrix2D);
     147             :                         }
     148           0 :                         else if(rProp.Name == getNamePropertyViewTransformation())
     149             :                         {
     150           0 :                             com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
     151           0 :                             rProp.Value >>= aAffineMatrix2D;
     152           0 :                             basegfx::unotools::homMatrixFromAffineMatrix(maViewTransformation, aAffineMatrix2D);
     153             :                         }
     154           0 :                         else if(rProp.Name == getNamePropertyViewport())
     155             :                         {
     156           0 :                             com::sun::star::geometry::RealRectangle2D aViewport;
     157           0 :                             rProp.Value >>= aViewport;
     158           0 :                             maViewport = basegfx::unotools::b2DRectangleFromRealRectangle2D(aViewport);
     159             :                         }
     160           0 :                         else if(rProp.Name == getNamePropertyTime())
     161             :                         {
     162           0 :                             rProp.Value >>= mfViewTime;
     163             :                         }
     164           0 :                         else if(rProp.Name == getNamePropertyVisualizedPage())
     165             :                         {
     166           0 :                             rProp.Value >>= mxVisualizedPage;
     167             :                         }
     168             :                         else
     169             :                         {
     170             :                             // extra information; add to filtered information
     171           0 :                             mxExtendedInformation[nExtendedInsert++] = rProp;
     172             :                         }
     173             :                     }
     174             : 
     175             :                     // extra information size is now known; realloc to final size
     176        3241 :                     mxExtendedInformation.realloc(nExtendedInsert);
     177             :                 }
     178      101777 :             }
     179             : 
     180           0 :             void impFillViewInformationFromContent()
     181             :             {
     182           0 :                 const bool bObjectTransformationUsed(!maObjectTransformation.isIdentity());
     183           0 :                 const bool bViewTransformationUsed(!maViewTransformation.isIdentity());
     184           0 :                 const bool bViewportUsed(!maViewport.isEmpty());
     185           0 :                 const bool bTimeUsed(0.0 < mfViewTime);
     186           0 :                 const bool bVisualizedPageUsed(mxVisualizedPage.is());
     187           0 :                 const bool bReducedDisplayQualityUsed(true == mbReducedDisplayQuality);
     188           0 :                 const bool bExtraInformation(mxExtendedInformation.hasElements());
     189           0 :                 sal_uInt32 nIndex(0);
     190             :                 const sal_uInt32 nCount(
     191           0 :                     (bObjectTransformationUsed ? 1 : 0) +
     192           0 :                     (bViewTransformationUsed ? 1 : 0) +
     193           0 :                     (bViewportUsed ? 1 : 0) +
     194           0 :                     (bTimeUsed ? 1 : 0) +
     195           0 :                     (bVisualizedPageUsed ? 1 : 0) +
     196           0 :                     (bReducedDisplayQualityUsed ? 1 : 0) +
     197           0 :                     (bExtraInformation ? mxExtendedInformation.getLength() : 0));
     198             : 
     199           0 :                 mxViewInformation.realloc(nCount);
     200             : 
     201           0 :                 if(bObjectTransformationUsed)
     202             :                 {
     203           0 :                     com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
     204           0 :                     basegfx::unotools::affineMatrixFromHomMatrix(aAffineMatrix2D, maObjectTransformation);
     205           0 :                     mxViewInformation[nIndex].Name = getNamePropertyObjectTransformation();
     206           0 :                     mxViewInformation[nIndex].Value <<= aAffineMatrix2D;
     207           0 :                     nIndex++;
     208             :                 }
     209             : 
     210           0 :                 if(bViewTransformationUsed)
     211             :                 {
     212           0 :                     com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
     213           0 :                     basegfx::unotools::affineMatrixFromHomMatrix(aAffineMatrix2D, maViewTransformation);
     214           0 :                     mxViewInformation[nIndex].Name = getNamePropertyViewTransformation();
     215           0 :                     mxViewInformation[nIndex].Value <<= aAffineMatrix2D;
     216           0 :                     nIndex++;
     217             :                 }
     218             : 
     219           0 :                 if(bViewportUsed)
     220             :                 {
     221           0 :                     const com::sun::star::geometry::RealRectangle2D aViewport(basegfx::unotools::rectangle2DFromB2DRectangle(maViewport));
     222           0 :                     mxViewInformation[nIndex].Name = getNamePropertyViewport();
     223           0 :                     mxViewInformation[nIndex].Value <<= aViewport;
     224           0 :                     nIndex++;
     225             :                 }
     226             : 
     227           0 :                 if(bTimeUsed)
     228             :                 {
     229           0 :                     mxViewInformation[nIndex].Name = getNamePropertyTime();
     230           0 :                     mxViewInformation[nIndex].Value <<= mfViewTime;
     231           0 :                     nIndex++;
     232             :                 }
     233             : 
     234           0 :                 if(bVisualizedPageUsed)
     235             :                 {
     236           0 :                     mxViewInformation[nIndex].Name = getNamePropertyVisualizedPage();
     237           0 :                     mxViewInformation[nIndex].Value <<= mxVisualizedPage;
     238           0 :                     nIndex++;
     239             :                 }
     240             : 
     241           0 :                 if(bExtraInformation)
     242             :                 {
     243           0 :                     const sal_Int32 nExtra(mxExtendedInformation.getLength());
     244             : 
     245           0 :                     for(sal_Int32 a(0); a < nExtra; a++)
     246             :                     {
     247           0 :                         mxViewInformation[nIndex++] = mxExtendedInformation[a];
     248             :                     }
     249             :                 }
     250           0 :             }
     251             : 
     252             :         public:
     253       95161 :             ImpViewInformation2D(
     254             :                 const basegfx::B2DHomMatrix& rObjectTransformation,
     255             :                 const basegfx::B2DHomMatrix& rViewTransformation,
     256             :                 const basegfx::B2DRange& rViewport,
     257             :                 const uno::Reference< drawing::XDrawPage >& rxDrawPage,
     258             :                 double fViewTime,
     259             :                 const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
     260             :             :   maObjectTransformation(rObjectTransformation),
     261             :                 maViewTransformation(rViewTransformation),
     262             :                 maObjectToViewTransformation(),
     263             :                 maInverseObjectToViewTransformation(),
     264             :                 maViewport(rViewport),
     265             :                 maDiscreteViewport(),
     266             :                 mxVisualizedPage(rxDrawPage),
     267             :                 mfViewTime(fViewTime),
     268             :                 mbReducedDisplayQuality(false),
     269             :                 mxViewInformation(),
     270       95161 :                 mxExtendedInformation()
     271             :             {
     272       95161 :                 impInterpretPropertyValues(rExtendedParameters);
     273       95161 :             }
     274             : 
     275        6616 :             explicit ImpViewInformation2D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
     276             :             :   maObjectTransformation(),
     277             :                 maViewTransformation(),
     278             :                 maObjectToViewTransformation(),
     279             :                 maInverseObjectToViewTransformation(),
     280             :                 maViewport(),
     281             :                 maDiscreteViewport(),
     282             :                 mxVisualizedPage(),
     283             :                 mfViewTime(),
     284             :                 mbReducedDisplayQuality(false),
     285             :                 mxViewInformation(rViewParameters),
     286        6616 :                 mxExtendedInformation()
     287             :             {
     288        6616 :                 impInterpretPropertyValues(rViewParameters);
     289        6616 :             }
     290             : 
     291         160 :             ImpViewInformation2D()
     292             :             :   maObjectTransformation(),
     293             :                 maViewTransformation(),
     294             :                 maObjectToViewTransformation(),
     295             :                 maInverseObjectToViewTransformation(),
     296             :                 maViewport(),
     297             :                 maDiscreteViewport(),
     298             :                 mxVisualizedPage(),
     299             :                 mfViewTime(),
     300             :                 mbReducedDisplayQuality(false),
     301             :                 mxViewInformation(),
     302         160 :                 mxExtendedInformation()
     303             :             {
     304         160 :             }
     305             : 
     306       10054 :             const basegfx::B2DHomMatrix& getObjectTransformation() const
     307             :             {
     308       10054 :                 return maObjectTransformation;
     309             :             }
     310             : 
     311       23920 :             const basegfx::B2DHomMatrix& getViewTransformation() const
     312             :             {
     313       23920 :                 return maViewTransformation;
     314             :             }
     315             : 
     316       69322 :             const basegfx::B2DRange& getViewport() const
     317             :             {
     318       69322 :                 return maViewport;
     319             :             }
     320             : 
     321        5516 :             const basegfx::B2DRange& getDiscreteViewport() const
     322             :             {
     323        5516 :                 if(maDiscreteViewport.isEmpty() && !maViewport.isEmpty())
     324             :                 {
     325        1313 :                     basegfx::B2DRange aDiscreteViewport(maViewport);
     326        1313 :                     aDiscreteViewport.transform(getViewTransformation());
     327        1313 :                     const_cast< ImpViewInformation2D* >(this)->maDiscreteViewport = aDiscreteViewport;
     328             :                 }
     329             : 
     330        5516 :                 return maDiscreteViewport;
     331             :             }
     332             : 
     333       69065 :             const basegfx::B2DHomMatrix& getObjectToViewTransformation() const
     334             :             {
     335      169507 :                 if(maObjectToViewTransformation.isIdentity() &&
     336      103534 :                     (!maObjectTransformation.isIdentity() || !maViewTransformation.isIdentity()))
     337             :                 {
     338       48641 :                     basegfx::B2DHomMatrix aObjectToView(maViewTransformation * maObjectTransformation);
     339       48641 :                     const_cast< ImpViewInformation2D* >(this)->maObjectToViewTransformation = aObjectToView;
     340             :                 }
     341             : 
     342       69065 :                 return maObjectToViewTransformation;
     343             :             }
     344             : 
     345      134824 :             const basegfx::B2DHomMatrix& getInverseObjectToViewTransformation() const
     346             :             {
     347      168168 :                 if(maInverseObjectToViewTransformation.isIdentity() &&
     348       56092 :                     (!maObjectTransformation.isIdentity() || !maViewTransformation.isIdentity()))
     349             :                 {
     350        4044 :                     basegfx::B2DHomMatrix aInverseObjectToView(maViewTransformation * maObjectTransformation);
     351        4044 :                     aInverseObjectToView.invert();
     352        4044 :                     const_cast< ImpViewInformation2D* >(this)->maInverseObjectToViewTransformation = aInverseObjectToView;
     353             :                 }
     354             : 
     355      134824 :                 return maInverseObjectToViewTransformation;
     356             :             }
     357             : 
     358        8470 :             double getViewTime() const
     359             :             {
     360        8470 :                 return mfViewTime;
     361             :             }
     362             : 
     363       25190 :             const uno::Reference< drawing::XDrawPage >& getVisualizedPage() const
     364             :             {
     365       25190 :                 return mxVisualizedPage;
     366             :             }
     367             : 
     368          21 :             bool getReducedDisplayQuality() const
     369             :             {
     370          21 :                 return mbReducedDisplayQuality;
     371             :             }
     372             : 
     373           0 :             const uno::Sequence< beans::PropertyValue >& getViewInformationSequence() const
     374             :             {
     375           0 :                 if(!mxViewInformation.hasElements())
     376             :                 {
     377           0 :                     const_cast< ImpViewInformation2D* >(this)->impFillViewInformationFromContent();
     378             :                 }
     379             : 
     380           0 :                 return mxViewInformation;
     381             :             }
     382             : 
     383        8470 :             const uno::Sequence< beans::PropertyValue >& getExtendedInformationSequence() const
     384             :             {
     385        8470 :                 return mxExtendedInformation;
     386             :             }
     387             : 
     388           0 :             bool operator==(const ImpViewInformation2D& rCandidate) const
     389             :             {
     390           0 :                 return (maObjectTransformation == rCandidate.maObjectTransformation
     391           0 :                     && maViewTransformation == rCandidate.maViewTransformation
     392           0 :                     && maViewport == rCandidate.maViewport
     393           0 :                     && mxVisualizedPage == rCandidate.mxVisualizedPage
     394           0 :                     && mfViewTime == rCandidate.mfViewTime
     395           0 :                     && mxExtendedInformation == rCandidate.mxExtendedInformation);
     396             :             }
     397             :         };
     398             :     } // end of anonymous namespace
     399             : } // end of namespace drawinglayer
     400             : 
     401             : 
     402             : 
     403             : namespace drawinglayer
     404             : {
     405             :     namespace geometry
     406             :     {
     407             :         namespace
     408             :         {
     409             :             struct theGlobalDefault :
     410             :                 public rtl::Static< ViewInformation2D::ImplType, theGlobalDefault > {};
     411             :         }
     412             : 
     413       95161 :         ViewInformation2D::ViewInformation2D(
     414             :             const basegfx::B2DHomMatrix& rObjectTransformation,
     415             :             const basegfx::B2DHomMatrix& rViewTransformation,
     416             :             const basegfx::B2DRange& rViewport,
     417             :             const uno::Reference< drawing::XDrawPage >& rxDrawPage,
     418             :             double fViewTime,
     419             :             const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
     420             :         :   mpViewInformation2D(ImpViewInformation2D(
     421             :                 rObjectTransformation,
     422             :                 rViewTransformation,
     423             :                 rViewport,
     424             :                 rxDrawPage,
     425             :                 fViewTime,
     426       95161 :                 rExtendedParameters))
     427             :         {
     428       95161 :         }
     429             : 
     430        6616 :         ViewInformation2D::ViewInformation2D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
     431        6616 :         :   mpViewInformation2D(ImpViewInformation2D(rViewParameters))
     432             :         {
     433        6616 :         }
     434             : 
     435       33413 :         ViewInformation2D::ViewInformation2D()
     436       33413 :         :   mpViewInformation2D(theGlobalDefault::get())
     437             :         {
     438       33413 :         }
     439             : 
     440       96393 :         ViewInformation2D::ViewInformation2D(const ViewInformation2D& rCandidate)
     441       96393 :         :   mpViewInformation2D(rCandidate.mpViewInformation2D)
     442             :         {
     443       96393 :         }
     444             : 
     445      231533 :         ViewInformation2D::~ViewInformation2D()
     446             :         {
     447      231533 :         }
     448             : 
     449       63914 :         ViewInformation2D& ViewInformation2D::operator=(const ViewInformation2D& rCandidate)
     450             :         {
     451       63914 :             mpViewInformation2D = rCandidate.mpViewInformation2D;
     452       63914 :             return *this;
     453             :         }
     454             : 
     455           0 :         bool ViewInformation2D::operator==(const ViewInformation2D& rCandidate) const
     456             :         {
     457           0 :             return rCandidate.mpViewInformation2D == mpViewInformation2D;
     458             :         }
     459             : 
     460       10054 :         const basegfx::B2DHomMatrix& ViewInformation2D::getObjectTransformation() const
     461             :         {
     462       10054 :             return mpViewInformation2D->getObjectTransformation();
     463             :         }
     464             : 
     465       22607 :         const basegfx::B2DHomMatrix& ViewInformation2D::getViewTransformation() const
     466             :         {
     467       22607 :             return mpViewInformation2D->getViewTransformation();
     468             :         }
     469             : 
     470       69322 :         const basegfx::B2DRange& ViewInformation2D::getViewport() const
     471             :         {
     472       69322 :             return mpViewInformation2D->getViewport();
     473             :         }
     474             : 
     475        8470 :         double ViewInformation2D::getViewTime() const
     476             :         {
     477        8470 :             return mpViewInformation2D->getViewTime();
     478             :         }
     479             : 
     480       25190 :         const uno::Reference< drawing::XDrawPage >& ViewInformation2D::getVisualizedPage() const
     481             :         {
     482       25190 :             return mpViewInformation2D->getVisualizedPage();
     483             :         }
     484             : 
     485       69065 :         const basegfx::B2DHomMatrix& ViewInformation2D::getObjectToViewTransformation() const
     486             :         {
     487       69065 :             return mpViewInformation2D->getObjectToViewTransformation();
     488             :         }
     489             : 
     490      134824 :         const basegfx::B2DHomMatrix& ViewInformation2D::getInverseObjectToViewTransformation() const
     491             :         {
     492      134824 :             return mpViewInformation2D->getInverseObjectToViewTransformation();
     493             :         }
     494             : 
     495        5516 :         const basegfx::B2DRange& ViewInformation2D::getDiscreteViewport() const
     496             :         {
     497        5516 :             return mpViewInformation2D->getDiscreteViewport();
     498             :         }
     499             : 
     500          21 :         bool ViewInformation2D::getReducedDisplayQuality() const
     501             :         {
     502          21 :             return mpViewInformation2D->getReducedDisplayQuality();
     503             :         }
     504             : 
     505           0 :         const uno::Sequence< beans::PropertyValue >& ViewInformation2D::getViewInformationSequence() const
     506             :         {
     507           0 :             return mpViewInformation2D->getViewInformationSequence();
     508             :         }
     509             : 
     510        8470 :         const uno::Sequence< beans::PropertyValue >& ViewInformation2D::getExtendedInformationSequence() const
     511             :         {
     512        8470 :             return mpViewInformation2D->getExtendedInformationSequence();
     513             :         }
     514             :     } // end of namespace geometry
     515             : } // end of namespace drawinglayer
     516             : 
     517             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10