/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx
Warning:	line 727, column 37 Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name UnoGraphicExporter.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SVXCORE_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium/public -D COMPONENT_BUILD -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/svx/sdi -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx

/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <vector>
21#include <com/sun/star/io/XOutputStream.hpp>
22#include <com/sun/star/beans/XPropertySet.hpp>
23#include <com/sun/star/container/XChild.hpp>
24#include <com/sun/star/lang/XServiceInfo.hpp>
25#include <com/sun/star/lang/XComponent.hpp>
26#include <com/sun/star/drawing/XShape.hpp>
27#include <com/sun/star/drawing/XDrawPage.hpp>
28#include <com/sun/star/drawing/XGraphicExportFilter.hpp>
29#include <com/sun/star/graphic/XGraphic.hpp>
30#include <com/sun/star/graphic/XGraphicRenderer.hpp>
31#include <com/sun/star/task/XStatusIndicator.hpp>
32#include <com/sun/star/task/XInteractionHandler.hpp>
33#include <com/sun/star/task/XInteractionContinuation.hpp>
34#include <com/sun/star/uno/XComponentContext.hpp>

36#include <tools/debug.hxx>
37#include <tools/diagnose_ex.h>
38#include <tools/urlobj.hxx>
39#include <comphelper/interaction.hxx>
40#include <framework/interaction.hxx>
41#include <com/sun/star/drawing/GraphicFilterRequest.hpp>
42#include <com/sun/star/util/URL.hpp>
43#include <cppuhelper/implbase.hxx>
44#include <cppuhelper/supportsservice.hxx>
45#include <vcl/metaact.hxx>
46#include <vcl/svapp.hxx>
47#include <vcl/virdev.hxx>
48#include <svl/outstrm.hxx>
49#include <sdr/contact/objectcontactofobjlistpainter.hxx>
50#include <svx/sdr/contact/viewobjectcontact.hxx>
51#include <svx/sdr/contact/viewcontact.hxx>
52#include <svx/sdr/contact/displayinfo.hxx>
53#include <editeng/numitem.hxx>
54#include <svx/svdograf.hxx>
55#include <svx/xoutbmp.hxx>
56#include <vcl/graphicfilter.hxx>
57#include <svx/unoapi.hxx>
58#include <svx/svdpage.hxx>
59#include <svx/svdmodel.hxx>
60#include <svx/fmview.hxx>
61#include <svx/fmmodel.hxx>
62#include <svx/unopage.hxx>
63#include <svx/svdoutl.hxx>
64#include <svx/xlineit0.hxx>
65#include <editeng/flditem.hxx>
66#include "UnoGraphicExporter.hxx"
67#include <memory>

69#define MAX_EXT_PIX2048         2048

71using namespace ::comphelper;
72using namespace ::cppu;
73using namespace ::com::sun::star;
74using namespace ::com::sun::star::uno;
75using namespace ::com::sun::star::util;
76using namespace ::com::sun::star::container;
77using namespace ::com::sun::star::drawing;
78using namespace ::com::sun::star::lang;
79using namespace ::com::sun::star::document;
80using namespace ::com::sun::star::beans;
81using namespace ::com::sun::star::task;

83// #i102251#
84#include <editeng/editstat.hxx>

86namespace {

  struct ExportSettings
  {
      OUString maFilterName;
      OUString maMediaType;
      URL maURL;
      css::uno::Reference< css::io::XOutputStream >         mxOutputStream;
      css::uno::Reference< css::graphic::XGraphicRenderer > mxGraphicRenderer;
      css::uno::Reference< css::task::XStatusIndicator >    mxStatusIndicator;
      css::uno::Reference< css::task::XInteractionHandler > mxInteractionHandler;

      sal_Int32 mnWidth;
      sal_Int32 mnHeight;
      bool mbExportOnlyBackground;
      bool mbScrollText;
      bool mbUseHighContrast;
      bool mbTranslucent;

      Sequence< PropertyValue >   maFilterData;

      Fraction    maScaleX;
      Fraction    maScaleY;

      TriState meAntiAliasing = TRISTATE_INDET;

      explicit ExportSettings(const SdrModel* pSdrModel);
  };

  ExportSettings::ExportSettings(const SdrModel* pSdrModel)
  :   mnWidth( 0 )
      ,mnHeight( 0 )
      ,mbExportOnlyBackground( false )
      ,mbScrollText( false )
      ,mbUseHighContrast( false )
      ,mbTranslucent( false )
      ,maScaleX( 1, 1 )
      ,maScaleY( 1, 1 )
  {
      if (pSdrModel)
      {
          maScaleX = pSdrModel->GetScaleFraction();
          maScaleY = pSdrModel->GetScaleFraction();
      }
  }

  /** implements a component to export shapes or pages to external graphic formats.

      @implements com.sun.star.drawing.GraphicExportFilter
  */
  class GraphicExporter : public WeakImplHelper< XGraphicExportFilter, XServiceInfo >
  {
  public:
      GraphicExporter();

      // XFilter
      virtual sal_Bool SAL_CALL filter( const Sequence< PropertyValue >& aDescriptor ) override;
      virtual void SAL_CALL cancel(  ) override;

      // XExporter
      virtual void SAL_CALL setSourceDocument( const Reference< XComponent >& xDoc ) override;

      // XServiceInfo
      virtual OUString SAL_CALL getImplementationName(  ) override;
      virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
      virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;

      // XMimeTypeInfo
      virtual sal_Bool SAL_CALL supportsMimeType( const OUString& MimeTypeName ) override;
      virtual Sequence< OUString > SAL_CALL getSupportedMimeTypeNames(  ) override;

      VclPtr<VirtualDevice> CreatePageVDev( SdrPage* pPage, long nWidthPixel, long nHeightPixel ) const;

      DECL_LINK( CalcFieldValueHdl, EditFieldInfo*, void )static void LinkStubCalcFieldValueHdl(void *, EditFieldInfo*)
; void CalcFieldValueHdl(EditFieldInfo*);

      void ParseSettings( const Sequence< PropertyValue >& aDescriptor, ExportSettings& rSettings );
      bool GetGraphic( ExportSettings const & rSettings, Graphic& aGraphic, bool bVectorType );

  private:
      Reference< XShape >     mxShape;
      Reference< XDrawPage >  mxPage;
      Reference< XShapes >    mxShapes;
      Graphic maGraphic;

      SvxDrawPage*        mpUnoPage;

      Link<EditFieldInfo*,void> maOldCalcFieldValueHdl;
      sal_Int32           mnPageNumber;
      SdrPage*            mpCurrentPage;
      SdrModel*           mpDoc;
  };

  /** creates a bitmap that is optionally transparent from a metafile
  */
  BitmapEx GetBitmapFromMetaFile( const GDIMetaFile& rMtf,bool bIsSelection, const Size* pSize )
  {
      // use new primitive conversion tooling
      basegfx::B2DRange aRange(basegfx::B2DPoint(0.0, 0.0));
      sal_uInt32 nMaximumQuadraticPixels(500000);

      if(pSize)
      {
          // use 100th mm for primitive bitmap converter tool, input is pixel
          // use a real OutDev to get the correct DPI, the static LogicToLogic assumes 72dpi which is wrong (!)
          const Size aSize100th(Application::GetDefaultDevice()->PixelToLogic(*pSize, MapMode(MapUnit::Map100thMM)));

          aRange.expand(basegfx::B2DPoint(aSize100th.Width(), aSize100th.Height()));

          // when explicitly pixels are requested from the GraphicExporter, use a *very* high limit
          // of 16gb (4096x4096 pixels), else use the default for the converters
          nMaximumQuadraticPixels = std::min(sal_uInt32(4096 * 4096), sal_uInt32(pSize->Width() * pSize->Height()));
      }
      else
      {
          // use 100th mm for primitive bitmap converter tool
          const Size aSize100th(OutputDevice::LogicToLogic(rMtf.GetPrefSize(), rMtf.GetPrefMapMode(), MapMode(MapUnit::Map100thMM)));

          aRange.expand(basegfx::B2DPoint(aSize100th.Width(), aSize100th.Height()));
      }

      // get hairline and full bound rect to evtl. correct logic size by the
      // equivalent of one pixel to make those visible at right and bottom
      tools::Rectangle aHairlineRect;
      const tools::Rectangle aRect(rMtf.GetBoundRect(*Application::GetDefaultDevice(), &aHairlineRect));

      if(!aRect.IsEmpty())
      {
          GDIMetaFile aMtf(rMtf);

          if (bIsSelection)
          {
              // tdf#105998 Correct the Metafile using information from it's real sizes measured
              // using rMtf.GetBoundRect above and a copy
              const Size aOnePixelInMtf(
                  Application::GetDefaultDevice()->PixelToLogic(
                      Size(1, 1),
                      rMtf.GetPrefMapMode()));
              const Size aHalfPixelInMtf(
                  (aOnePixelInMtf.getWidth() + 1) / 2,
                  (aOnePixelInMtf.getHeight() + 1) / 2);
              const bool bHairlineBR(
                  !aHairlineRect.IsEmpty() && (aRect.Right() == aHairlineRect.Right() || aRect.Bottom() == aHairlineRect.Bottom()));

              // Move the content to (0,0), usually TopLeft ist slightly
              // negative. For better visualization, add a half pixel, too
              aMtf.Move(
                  aHalfPixelInMtf.getWidth() - aRect.Left(),
                  aHalfPixelInMtf.getHeight() - aRect.Top());

              // Do not Scale, but set the PrefSize. Some levels deeper the
              // MetafilePrimitive will add a mapping to the decomposition
              // (and possibly a clipping) to map the graphic content to
              // a unit coordinate system.
              // Size is the measured size plus one pixel if needed (bHairlineBR)
              // and the moved half pixwel from above
              aMtf.SetPrefSize(
                  Size(
                      aRect.getWidth() + (bHairlineBR ? aOnePixelInMtf.getWidth() : 0) + aHalfPixelInMtf.getWidth(),
                      aRect.getHeight() + (bHairlineBR ? aOnePixelInMtf.getHeight() : 0) + aHalfPixelInMtf.getHeight()));
          }

          return convertMetafileToBitmapEx(aMtf, aRange, nMaximumQuadraticPixels);
      }

      return BitmapEx();
  }

  Size* CalcSize( sal_Int32 nWidth, sal_Int32 nHeight, const Size& aBoundSize, Size& aOutSize )
  {
      if( (nWidth == 0) && (nHeight == 0) )
          return nullptr;

      if( (nWidth == 0) && (nHeight != 0) && (aBoundSize.Height() != 0) )
      {
          nWidth = ( nHeight * aBoundSize.Width() ) / aBoundSize.Height();
      }
      else if( (nWidth != 0) && (nHeight == 0) && (aBoundSize.Width() != 0) )
      {
          nHeight = ( nWidth * aBoundSize.Height() ) / aBoundSize.Width();
      }

      aOutSize.setWidth( nWidth );
      aOutSize.setHeight( nHeight );

      return &aOutSize;
  }

273class ImplExportCheckVisisbilityRedirector : public sdr::contact::ViewObjectContactRedirector
274{
275public:
  explicit ImplExportCheckVisisbilityRedirector( SdrPage* pCurrentPage );

  virtual drawinglayer::primitive2d::Primitive2DContainer createRedirectedPrimitive2DSequence(
      const sdr::contact::ViewObjectContact& rOriginal,
      const sdr::contact::DisplayInfo& rDisplayInfo) override;

282private:
  SdrPage*    mpCurrentPage;
284};

286ImplExportCheckVisisbilityRedirector::ImplExportCheckVisisbilityRedirector( SdrPage* pCurrentPage )
  ViewObjectContactRedirector(), mpCurrentPage( pCurrentPage )
288{
289}

291drawinglayer::primitive2d::Primitive2DContainer ImplExportCheckVisisbilityRedirector::createRedirectedPrimitive2DSequence(
  const sdr::contact::ViewObjectContact& rOriginal,
  const sdr::contact::DisplayInfo& rDisplayInfo)
294{
  SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();

  if(pObject)
  {
      SdrPage* pPage = mpCurrentPage;

      if(nullptr == pPage)
      {
          pPage = pObject->getSdrPageFromSdrObject();
      }

      if( (pPage == nullptr) || pPage->checkVisibility(rOriginal, rDisplayInfo, false) )
      {
          return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
      }

      return drawinglayer::primitive2d::Primitive2DContainer();
  }
  else
  {
      // not an object, maybe a page
      return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
  }
318}

320GraphicExporter::GraphicExporter()
mpUnoPage( nullptr ), mnPageNumber(-1), mpCurrentPage(nullptr), mpDoc( nullptr )
322{
323}

325IMPL_LINK(GraphicExporter, CalcFieldValueHdl, EditFieldInfo*, pInfo, void)void GraphicExporter::LinkStubCalcFieldValueHdl(void * instance
, EditFieldInfo* data) { return static_cast<GraphicExporter
 *>(instance)->CalcFieldValueHdl(data); } void GraphicExporter
::CalcFieldValueHdl(EditFieldInfo* pInfo)
326{
  if( pInfo )
  {
      if( mpCurrentPage )
      {
          pInfo->SetSdrPage( mpCurrentPage );
      }
      else if( mnPageNumber != -1 )
      {
          const SvxFieldData* pField = pInfo->GetField().GetField();
          if( dynamic_cast<const SvxPageField*>( pField) )
          {
              OUString aPageNumValue;
              bool bUpper = false;

              switch(mpDoc->GetPageNumType())
              {
                  case css::style::NumberingType::CHARS_UPPER_LETTER:
                      aPageNumValue += OUStringChar( sal_Unicode((mnPageNumber - 1) % 26 + 'A') );
                      break;
                  case css::style::NumberingType::CHARS_LOWER_LETTER:
                      aPageNumValue += OUStringChar( sal_Unicode((mnPageNumber - 1) % 26 + 'a') );
                      break;
                  case css::style::NumberingType::ROMAN_UPPER:
                      bUpper = true;
                      [[fallthrough]];
                  case css::style::NumberingType::ROMAN_LOWER:
                      aPageNumValue += SvxNumberFormat::CreateRomanString(mnPageNumber, bUpper);
                      break;
                  case css::style::NumberingType::NUMBER_NONE:
                      aPageNumValue = " ";
                      break;
                  default:
                      aPageNumValue += OUString::number( mnPageNumber );
              }

              pInfo->SetRepresentation( aPageNumValue );

              return;
          }
      }
  }

  maOldCalcFieldValueHdl.Call( pInfo );

  if( pInfo && mpCurrentPage )
      pInfo->SetSdrPage( nullptr );
373}

375/** creates a virtual device for the given page

  @return the returned VirtualDevice is owned by the caller
378*/
379VclPtr<VirtualDevice> GraphicExporter::CreatePageVDev( SdrPage* pPage, long nWidthPixel, long nHeightPixel ) const
380{
  VclPtr<VirtualDevice>  pVDev = VclPtr<VirtualDevice>::Create();
  MapMode         aMM( MapUnit::Map100thMM );

  Point aPoint( 0, 0 );
  Size aPageSize(pPage->GetSize());

  // use scaling?
  if( nWidthPixel != 0 )
  {
      const Fraction aFrac( nWidthPixel, pVDev->LogicToPixel( aPageSize, aMM ).Width() );

      aMM.SetScaleX( aFrac );

      if( nHeightPixel == 0 )
          aMM.SetScaleY( aFrac );
  }

  if( nHeightPixel != 0 )
  {
      const Fraction aFrac( nHeightPixel, pVDev->LogicToPixel( aPageSize, aMM ).Height() );

      if( nWidthPixel == 0 )
          aMM.SetScaleX( aFrac );

      aMM.SetScaleY( aFrac );
  }

  pVDev->SetMapMode( aMM );
  bool bSuccess(false);

  // #i122820# If available, use pixel size directly
  if(nWidthPixel && nHeightPixel)
  {
      bSuccess = pVDev->SetOutputSizePixel(Size(nWidthPixel, nHeightPixel));
  }
  else
  {
      bSuccess = pVDev->SetOutputSize(aPageSize);
  }

  if(bSuccess)
  {
      std::unique_ptr<SdrView> pView(new SdrView(*mpDoc, pVDev));

      pView->SetPageVisible( false );
      pView->SetBordVisible( false );
      pView->SetGridVisible( false );
      pView->SetHlplVisible( false );
      pView->SetGlueVisible( false );
      pView->ShowSdrPage(pPage);

      vcl::Region aRegion (tools::Rectangle( aPoint, aPageSize ) );

      ImplExportCheckVisisbilityRedirector aRedirector( mpCurrentPage );

      pView->CompleteRedraw(pVDev, aRegion, &aRedirector);
  }
  else
  {
      OSL_ENSURE(false, "Could not get a VirtualDevice of requested size (!)")do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx"
 ":" "440" ": "), "%s", "Could not get a VirtualDevice of requested size (!)"
); } } while (false);
  }

  return pVDev;
444}

446void GraphicExporter::ParseSettings( const Sequence< PropertyValue >& aDescriptor, ExportSettings& rSettings )
447{
  for( const PropertyValue& rValue : aDescriptor )
  {
      if ( rValue.Name == "FilterName" )
      {
          rValue.Value >>= rSettings.maFilterName;
      }
      else if ( rValue.Name == "MediaType" )
      {
          rValue.Value >>= rSettings.maMediaType;
      }
      else if ( rValue.Name == "URL" )
      {
          if( !( rValue.Value >>= rSettings.maURL ) )
          {
              rValue.Value >>= rSettings.maURL.Complete;
          }
      }
      else if ( rValue.Name == "OutputStream" )
      {
          rValue.Value >>= rSettings.mxOutputStream;
      }
      else if ( rValue.Name == "GraphicRenderer" )
      {
          rValue.Value >>= rSettings.mxGraphicRenderer;
      }
      else if ( rValue.Name == "StatusIndicator" )
      {
          rValue.Value >>= rSettings.mxStatusIndicator;
      }
      else if ( rValue.Name == "InteractionHandler" )
      {
          rValue.Value >>= rSettings.mxInteractionHandler;
      }
      else if( rValue.Name == "Width" )  // for compatibility reasons, deprecated
      {
          rValue.Value >>= rSettings.mnWidth;
      }
      else if( rValue.Name == "Height" ) // for compatibility reasons, deprecated
      {
          rValue.Value >>= rSettings.mnHeight;
      }
      else if( rValue.Name == "ExportOnlyBackground" )   // for compatibility reasons, deprecated
      {
          rValue.Value >>= rSettings.mbExportOnlyBackground;
      }
      else if ( rValue.Name == "FilterData" )
      {
          rValue.Value >>= rSettings.maFilterData;

          for( PropertyValue& rDataValue : rSettings.maFilterData )
          {
              if ( rDataValue.Name == "Translucent" )
              {
                  if ( !( rDataValue.Value >>= rSettings.mbTranslucent ) )  // SJ: TODO: The GIF Transparency is stored as int32 in
                  {                                               // configuration files, this has to be changed to boolean
                      sal_Int32 nTranslucent = 0;
                      if ( rDataValue.Value >>= nTranslucent )
                          rSettings.mbTranslucent = nTranslucent != 0;
                  }
              }
              else if ( rDataValue.Name == "PixelWidth" )
              {
                  rDataValue.Value >>= rSettings.mnWidth;
              }
              else if ( rDataValue.Name == "PixelHeight" )
              {
                  rDataValue.Value >>= rSettings.mnHeight;
              }
              else if( rDataValue.Name == "Width" )  // for compatibility reasons, deprecated
              {
                  rDataValue.Value >>= rSettings.mnWidth;
                  rDataValue.Name = "PixelWidth";
              }
              else if( rDataValue.Name == "Height" ) // for compatibility reasons, deprecated
              {
                  rDataValue.Value >>= rSettings.mnHeight;
                  rDataValue.Name = "PixelHeight";
              }
              else if ( rDataValue.Name == "ExportOnlyBackground" )
              {
                  rDataValue.Value >>= rSettings.mbExportOnlyBackground;
              }
              else if ( rDataValue.Name == "HighContrast" )
              {
                  rDataValue.Value >>= rSettings.mbUseHighContrast;
              }
              else if ( rDataValue.Name == "PageNumber" )
              {
                  rDataValue.Value >>= mnPageNumber;
              }
              else if ( rDataValue.Name == "ScrollText" )
              {
                  // #110496# Read flag solitary scroll text metafile
                  rDataValue.Value >>= rSettings.mbScrollText;
              }
              else if ( rDataValue.Name == "CurrentPage" )
              {
                  Reference< XDrawPage >  xPage;
                  rDataValue.Value >>= xPage;
                  if( xPage.is() )
                  {
                      SvxDrawPage* pUnoPage = comphelper::getUnoTunnelImplementation<SvxDrawPage>( xPage );
                      if( pUnoPage && pUnoPage->GetSdrPage() )
                          mpCurrentPage = pUnoPage->GetSdrPage();
                  }
              }
              else if ( rDataValue.Name == "ScaleXNumerator" )
              {
                  sal_Int32 nVal = 1;
                  if( rDataValue.Value >>= nVal )
                      rSettings.maScaleX = Fraction( nVal, rSettings.maScaleX.GetDenominator() );
              }
              else if ( rDataValue.Name == "ScaleXDenominator" )
              {
                  sal_Int32 nVal = 1;
                  if( rDataValue.Value >>= nVal )
                      rSettings.maScaleX = Fraction( rSettings.maScaleX.GetNumerator(), nVal );
              }
              else if ( rDataValue.Name == "ScaleYNumerator" )
              {
                  sal_Int32 nVal = 1;
                  if( rDataValue.Value >>= nVal )
                      rSettings.maScaleY = Fraction( nVal, rSettings.maScaleY.GetDenominator() );
              }
              else if ( rDataValue.Name == "ScaleYDenominator" )
              {
                  sal_Int32 nVal = 1;
                  if( rDataValue.Value >>= nVal )
                      rSettings.maScaleY = Fraction( rSettings.maScaleY.GetNumerator(), nVal );
              }
              else if (rDataValue.Name == "AntiAliasing")
              {
                  bool bAntiAliasing;
                  if (rDataValue.Value >>= bAntiAliasing)
                      rSettings.meAntiAliasing = bAntiAliasing ? TRISTATE_TRUE : TRISTATE_FALSE;
              }
          }
      }
  }

  // putting the StatusIndicator that we got from the MediaDescriptor into our local FilterData copy
  if ( rSettings.mxStatusIndicator.is() )
  {
      int i = rSettings.maFilterData.getLength();
      rSettings.maFilterData.realloc( i + 1 );
      rSettings.maFilterData[ i ].Name = "StatusIndicator";
      rSettings.maFilterData[ i ].Value <<= rSettings.mxStatusIndicator;
  }
596}

598bool GraphicExporter::GetGraphic( ExportSettings const & rSettings, Graphic& aGraphic, bool bVectorType )
599{
  if( !mpDoc28.1
Field 'mpDoc' is non-null
1
Field 'mpDoc' is non-null
1
Field 'mpDoc' is non-null
1
Field 'mpDoc' is non-null
 || !mpUnoPage28.2
Field 'mpUnoPage' is non-null
2
Field 'mpUnoPage' is non-null
2
Field 'mpUnoPage' is non-null
2
Field 'mpUnoPage' is non-null
 )
29
←
Taking false branch→
      return false;

  SdrPage* pPage = mpUnoPage->GetSdrPage();
  if( !pPage29.1
'pPage' is non-null
1
'pPage' is non-null
1
'pPage' is non-null
1
'pPage' is non-null
 )
30
←
Taking false branch→
      return false;

  ScopedVclPtrInstance< VirtualDevice > aVDev;
  const MapMode       aMap( mpDoc->GetScaleUnit(), Point(), rSettings.maScaleX, rSettings.maScaleY );

  SdrOutliner& rOutl=mpDoc->GetDrawOutliner();
  maOldCalcFieldValueHdl = rOutl.GetCalcFieldValueHdl();
  rOutl.SetCalcFieldValueHdl( LINK(this, GraphicExporter, CalcFieldValueHdl)::tools::detail::makeLink( ::tools::detail::castTo<GraphicExporter
 *>(this), &GraphicExporter::LinkStubCalcFieldValueHdl
) );
31
←
Calling 'castTo<(anonymous namespace)::GraphicExporter *, (anonymous namespace)::GraphicExporter *>'→
34
←
Returning from 'castTo<(anonymous namespace)::GraphicExporter *, (anonymous namespace)::GraphicExporter *>'→
35
←
Calling 'makeLink<EditFieldInfo *, void>'→
38
←
Returning from 'makeLink<EditFieldInfo *, void>'→
  rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor() );
39
←
Value assigned to field 'mpDoc'→

  // #i102251#
  const EEControlBits nOldCntrl(rOutl.GetControlWord());
  EEControlBits nCntrl = nOldCntrl & ~EEControlBits::ONLINESPELLING;
  rOutl.SetControlWord(nCntrl);

  SdrObject* pTempBackgroundShape = nullptr;
  std::vector< SdrObject* > aShapes;
  bool bRet = true;

  // export complete page?
  if ( !mxShape.is() )
40
←
Calling 'BaseReference::is'→
43
←
Returning from 'BaseReference::is'→
44
←
Taking true branch→
  {
      if( rSettings.mbExportOnlyBackground )
45
←
Assuming field 'mbExportOnlyBackground' is false→
46
←
Taking false branch→
      {
          const SdrPageProperties* pCorrectProperties = pPage->getCorrectSdrPageProperties();

          if(pCorrectProperties)
          {
              pTempBackgroundShape = new SdrRectObj(
                  *mpDoc,
                  tools::Rectangle(Point(0,0), pPage->GetSize()));
              pTempBackgroundShape->SetMergedItemSet(pCorrectProperties->GetItemSet());
              pTempBackgroundShape->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
              pTempBackgroundShape->NbcSetStyleSheet(pCorrectProperties->GetStyleSheet(), true);
              aShapes.push_back(pTempBackgroundShape);
          }
      }
      else
      {
          const Size aSize( pPage->GetSize() );

          // generate a bitmap to convert it to a pixel format.
          // For gif pictures there can also be a vector format used (bTranslucent)
          if ( !bVectorType46.1
'bVectorType' is true
1
'bVectorType' is true
1
'bVectorType' is true
1
'bVectorType' is true
 && !rSettings.mbTranslucent )
          {
              long nWidthPix = 0;
              long nHeightPix = 0;
              if ( rSettings.mnWidth > 0 && rSettings.mnHeight > 0 )
              {
                  nWidthPix = rSettings.mnWidth;
                  nHeightPix = rSettings.mnHeight;
              }
              else
              {
                  const Size aSizePix( Application::GetDefaultDevice()->LogicToPixel( aSize, aMap ) );
                  if (aSizePix.Width() > MAX_EXT_PIX2048 || aSizePix.Height() > MAX_EXT_PIX2048)
                  {
                      if (aSizePix.Width() > MAX_EXT_PIX2048)
                          nWidthPix = MAX_EXT_PIX2048;
                      else
                          nWidthPix = aSizePix.Width();
                      if (aSizePix.Height() > MAX_EXT_PIX2048)
                          nHeightPix = MAX_EXT_PIX2048;
                      else
                          nHeightPix = aSizePix.Height();

                      double fWidthDif = static_cast<double>(aSizePix.Width()) / nWidthPix;
                      double fHeightDif = static_cast<double>(aSizePix.Height()) / nHeightPix;

                      if (fWidthDif > fHeightDif)
                          nHeightPix = static_cast<long>(aSizePix.Height() / fWidthDif);
                      else
                          nWidthPix = static_cast<long>(aSizePix.Width() / fHeightDif);
                  }
                  else
                  {
                      nWidthPix = aSizePix.Width();
                      nHeightPix = aSizePix.Height();
                  }
              }

              std::unique_ptr<SdrView> xLocalView;

              if (FmFormModel* pFormModel = dynamic_cast<FmFormModel*>(mpDoc))
              {
                  xLocalView.reset(new FmFormView(*pFormModel, aVDev));
              }
              else
              {
                  xLocalView.reset(new SdrView(*mpDoc, aVDev));
              }

              ScopedVclPtr<VirtualDevice> pVDev(CreatePageVDev( pPage, nWidthPix, nHeightPix ));

              if( pVDev )
              {
                  aGraphic = pVDev->GetBitmapEx( Point(), pVDev->GetOutputSize() );
                  aGraphic.SetPrefMapMode( aMap );
                  aGraphic.SetPrefSize( aSize );
              }
          }
          // create a metafile to export a vector format
          else
          {
              GDIMetaFile aMtf;

              aVDev->SetMapMode( aMap );
              if( rSettings.mbUseHighContrast )
47
←
Assuming field 'mbUseHighContrast' is false→
48
←
Taking false branch→
                  aVDev->SetDrawMode( aVDev->GetDrawMode() | DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient );
              aVDev->EnableOutput( false );
              aMtf.Record( aVDev );
              Size aNewSize;

              // create a view
              std::unique_ptr< SdrView > pView;

              if (FmFormModel *pFormModel = dynamic_cast<FmFormModel*>(mpDoc))
49
←
Assuming 'pFormModel' is null→
50
←
Taking false branch→
              {
                  pView.reset(new FmFormView(*pFormModel, aVDev));
              }
              else
              {
                  pView.reset(new SdrView(*mpDoc, aVDev));
51
←
Forming reference to null pointer
              }

              pView->SetBordVisible( false );
              pView->SetPageVisible( false );
              pView->ShowSdrPage( pPage );

              // tdf#96922 completely deactivate EditView PageVisualization, including
              // PageBackground (formerly 'wiese').
              pView->SetPagePaintingAllowed(false);

              const Point aNewOrg( pPage->GetLeftBorder(), pPage->GetUpperBorder() );
              aNewSize = Size( aSize.Width() - pPage->GetLeftBorder() - pPage->GetRightBorder(),
                               aSize.Height() - pPage->GetUpperBorder() - pPage->GetLowerBorder() );
              const tools::Rectangle aClipRect( aNewOrg, aNewSize );
              MapMode         aVMap( aMap );

              aVDev->Push();
              aVMap.SetOrigin( Point( -aNewOrg.X(), -aNewOrg.Y() ) );
              aVDev->SetRelativeMapMode( aVMap );
              aVDev->IntersectClipRegion( aClipRect );

              // Use new StandardCheckVisisbilityRedirector
              ImplExportCheckVisisbilityRedirector aRedirector( mpCurrentPage );

              pView->CompleteRedraw(aVDev, vcl::Region(tools::Rectangle(aNewOrg, aNewSize)), &aRedirector);

              aVDev->Pop();

              aMtf.Stop();
              aMtf.WindStart();
              aMtf.SetPrefMapMode( aMap );
              aMtf.SetPrefSize( aNewSize );

              // AW: Here the current version was filtering out the MetaActionType::CLIPREGIONs
              // from the metafile. I asked some other developers why this was done, but no
              // one knew a direct reason. Since it's in for long time, it may be an old
              // piece of code. MetaFiles save and load ClipRegions with polygons with preserving
              // the polygons, so a resolution-independent roundtrip is supported. Removed this
              // code since it destroys some MetaFiles where ClipRegions are used. Anyways,
              // just filtering them out is a hack, at least the encapsulated content would need
              // to be clipped geometrically.
              aGraphic = Graphic(aMtf);

              pView->HideSdrPage();

              if( rSettings.mbTranslucent )
              {
                  Size aOutSize;
                  aGraphic = GetBitmapFromMetaFile( aGraphic.GetGDIMetaFile(), false, CalcSize( rSettings.mnWidth, rSettings.mnHeight, aNewSize, aOutSize ) );
              }
          }
      }
  }

  // export only single shape or shape collection
  else
  {
      // build list of SdrObject
      if( mxShapes.is() )
      {
          Reference< XShape > xShape;
          const sal_Int32 nCount = mxShapes->getCount();

          for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
          {
              mxShapes->getByIndex( nIndex ) >>= xShape;
              SdrObject* pObj = GetSdrObjectFromXShape( xShape );
              if( pObj )
                  aShapes.push_back( pObj );
          }
      }
      else
      {
          // only one shape
          SdrObject* pObj = GetSdrObjectFromXShape( mxShape );
          if( pObj )
              aShapes.push_back( pObj );
      }

      if( aShapes.empty() )
          bRet = false;
  }

  if( bRet && !aShapes.empty() )
  {
      // special treatment for only one SdrGrafObj that has text
      bool bSingleGraphic = false;

      if( 1 == aShapes.size() )
      {
          if( !bVectorType )
          {
              SdrObject* pObj = aShapes.front();
              if( dynamic_cast<const SdrGrafObj*>( pObj) && !static_cast<SdrGrafObj*>(pObj)->HasText() )
              {
                  aGraphic = static_cast<SdrGrafObj*>(pObj)->GetTransformedGraphic();
                  if ( aGraphic.GetType() == GraphicType::Bitmap )
                  {
                      Size aSizePixel( aGraphic.GetSizePixel() );
                      if( rSettings.mnWidth && rSettings.mnHeight &&
                          ( ( rSettings.mnWidth != aSizePixel.Width() ) ||
                            ( rSettings.mnHeight != aSizePixel.Height() ) ) )
                      {
                          BitmapEx aBmpEx( aGraphic.GetBitmapEx() );
                          // export: use highest quality
                          aBmpEx.Scale( Size( rSettings.mnWidth, rSettings.mnHeight ), BmpScaleFlag::Lanczos );
                          aGraphic = aBmpEx;
                      }

                      // #118804# only accept for bitmap graphics, else the
                      // conversion to bitmap will happen anywhere without size control
                      // as evtl. defined in rSettings.mnWidth/mnHeight
                      bSingleGraphic = true;
                  }
              }
          }
          else if( rSettings.mbScrollText )
          {
              SdrObject* pObj = aShapes.front();
              if( dynamic_cast<const SdrTextObj*>( pObj)
                  && static_cast<SdrTextObj*>(pObj)->HasText() )
              {
                  tools::Rectangle aScrollRectangle;
                  tools::Rectangle aPaintRectangle;

                  const std::unique_ptr< GDIMetaFile > pMtf(
                      static_cast<SdrTextObj*>(pObj)->GetTextScrollMetaFileAndRectangle(
                         aScrollRectangle, aPaintRectangle ) );

                  // take the larger one of the two rectangles (that
                  // should be the bound rect of the retrieved
                  // metafile)
                  tools::Rectangle aTextRect;

                  if( aScrollRectangle.IsInside( aPaintRectangle ) )
                      aTextRect = aScrollRectangle;
                  else
                      aTextRect = aPaintRectangle;

                  // setup pref size and mapmode
                  pMtf->SetPrefSize( aTextRect.GetSize() );

                  // set actual origin (mtf is at actual shape
                  // output position)
                  MapMode aLocalMapMode( aMap );
                  aLocalMapMode.SetOrigin(
                      Point( -aPaintRectangle.Left(),
                             -aPaintRectangle.Top() ) );
                  pMtf->SetPrefMapMode( aLocalMapMode );

                  pMtf->AddAction( new MetaCommentAction(
                                       "XTEXT_SCROLLRECT", 0,
                                       reinterpret_cast<sal_uInt8 const*>(&aScrollRectangle),
                                       sizeof( tools::Rectangle ) ) );
                  pMtf->AddAction( new MetaCommentAction(
                                       "XTEXT_PAINTRECT", 0,
                                       reinterpret_cast<sal_uInt8 const*>(&aPaintRectangle),
                                       sizeof( tools::Rectangle ) ) );

                  aGraphic = Graphic( *pMtf );

                  bSingleGraphic = true;
              }
          }
      }

      if( !bSingleGraphic )
      {
          // create a metafile for all shapes
          ScopedVclPtrInstance< VirtualDevice > aOut;

          // calculate bound rect for all shapes
          tools::Rectangle aBound;

          {
              for( SdrObject* pObj : aShapes )
              {
                  tools::Rectangle aR1(pObj->GetCurrentBoundRect());
                  if (aBound.IsEmpty())
                      aBound=aR1;
                  else
                      aBound.Union(aR1);
              }
          }

          aOut->EnableOutput( false );
          aOut->SetMapMode( aMap );
          if( rSettings.mbUseHighContrast )
              aOut->SetDrawMode( aOut->GetDrawMode() | DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient );

          GDIMetaFile aMtf;
          aMtf.Clear();
          aMtf.Record( aOut );

          MapMode aOutMap( aMap );
          aOutMap.SetOrigin( Point( -aBound.TopLeft().X(), -aBound.TopLeft().Y() ) );
          aOut->SetRelativeMapMode( aOutMap );

          sdr::contact::DisplayInfo aDisplayInfo;

          if(mpCurrentPage)
          {
              if(mpCurrentPage->TRG_HasMasterPage() && pPage->IsMasterPage())
              {
                  // MasterPage is processed as another page's SubContent
                  aDisplayInfo.SetProcessLayers(mpCurrentPage->TRG_GetMasterPageVisibleLayers());
                  aDisplayInfo.SetSubContentActive(true);
              }
          }

          if(!aShapes.empty())
          {
              // more effective way to paint a vector of SdrObjects. Hand over the processed page
              // to have it in the
              sdr::contact::ObjectContactOfObjListPainter aMultiObjectPainter(*aOut, aShapes, mpCurrentPage);
              ImplExportCheckVisisbilityRedirector aCheckVisibilityRedirector(mpCurrentPage);
              aMultiObjectPainter.SetViewObjectContactRedirector(&aCheckVisibilityRedirector);

              aMultiObjectPainter.ProcessDisplay(aDisplayInfo);
          }

          aMtf.Stop();
          aMtf.WindStart();

          const Size  aExtSize( aOut->PixelToLogic( Size( 0, 0  ) ) );
          Size        aBoundSize( aBound.GetWidth() + ( aExtSize.Width() ),
                                  aBound.GetHeight() + ( aExtSize.Height() ) );

          aMtf.SetPrefMapMode( aMap );
          aMtf.SetPrefSize( aBoundSize );

          if( !bVectorType )
          {
              Size aOutSize;
              aGraphic = GetBitmapFromMetaFile( aMtf, true, CalcSize( rSettings.mnWidth, rSettings.mnHeight, aBoundSize, aOutSize ) );
          }
          else
          {
              aGraphic = aMtf;
          }
      }
  }

  if(pTempBackgroundShape)
  {
      SdrObject::Free(pTempBackgroundShape);
  }

  rOutl.SetCalcFieldValueHdl( maOldCalcFieldValueHdl );

  // #i102251#
  rOutl.SetControlWord(nOldCntrl);

  return bRet;

983}

985// XFilter
986sal_Bool SAL_CALL GraphicExporter::filter( const Sequence< PropertyValue >& aDescriptor )
987{
  ::SolarMutexGuard aGuard;

  if( maGraphic.IsNone() && nullptr == mpUnoPage )
      return false;

  if( maGraphic.IsNone() && ( nullptr == mpUnoPage->GetSdrPage() || nullptr == mpDoc ) )
      return false;

  GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();

  // get the arguments from the descriptor
  ExportSettings aSettings(mpDoc);
  ParseSettings(aDescriptor, aSettings);

  const sal_uInt16    nFilter = !aSettings.maMediaType.isEmpty()
                          ? rFilter.GetExportFormatNumberForMediaType( aSettings.maMediaType )
                          : rFilter.GetExportFormatNumberForShortName( aSettings.maFilterName );
  bool            bVectorType = !rFilter.IsExportPixelFormat( nFilter );

  // create the output stuff
  Graphic aGraphic = maGraphic;

  ErrCode nStatus = ERRCODE_NONEErrCode(0);
  if (maGraphic.IsNone())
  {
      SvtOptionsDrawinglayer aOptions;
      bool bAntiAliasing = aOptions.IsAntiAliasing();
      AllSettings aAllSettings = Application::GetSettings();
      StyleSettings aStyleSettings = aAllSettings.GetStyleSettings();
      bool bUseFontAAFromSystem = aStyleSettings.GetUseFontAAFromSystem();
      if (aSettings.meAntiAliasing != TRISTATE_INDET)
      {
          // This is safe to do globally as we own the solar mutex.
          aOptions.SetAntiAliasing(aSettings.meAntiAliasing == TRISTATE_TRUE);
          // Opt in to have AA affect font rendering as well.
          aStyleSettings.SetUseFontAAFromSystem(false);
          aAllSettings.SetStyleSettings(aStyleSettings);
          Application::SetSettings(aAllSettings);
      }
      nStatus = GetGraphic( aSettings, aGraphic, bVectorType ) ? ERRCODE_NONEErrCode(0) : ERRCODE_GRFILTER_FILTERERRORErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 5);
      if (aSettings.meAntiAliasing != TRISTATE_INDET)
      {
          aOptions.SetAntiAliasing(bAntiAliasing);
          aStyleSettings.SetUseFontAAFromSystem(bUseFontAAFromSystem);
          aAllSettings.SetStyleSettings(aStyleSettings);
          Application::SetSettings(aAllSettings);
      }
  }

  if( nStatus == ERRCODE_NONEErrCode(0) )
  {
      // export graphic only if it has a size
      const Size aGraphSize( aGraphic.GetPrefSize() );
      if ( aGraphSize.IsEmpty() )
      {
          nStatus = ERRCODE_GRFILTER_FILTERERRORErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 5);
      }
      else
      {
          // now we have a graphic, so export it
          if( aSettings.mxGraphicRenderer.is() )
          {
              // render graphic directly into given renderer
              aSettings.mxGraphicRenderer->render( aGraphic.GetXGraphic() );
          }
          else if( aSettings.mxOutputStream.is() )
          {
              // TODO: Either utilize optional XSeekable functionality for the
              // SvOutputStream, or adapt the graphic filter to not seek anymore.
              SvMemoryStream aStream( 1024, 1024 );

              nStatus = rFilter.ExportGraphic( aGraphic,"", aStream, nFilter, &aSettings.maFilterData );

              // copy temp stream to XOutputStream
              SvOutputStream aOutputStream( aSettings.mxOutputStream );
              aStream.Seek(0);
              aOutputStream.WriteStream( aStream );
          }
          else
          {
              INetURLObject aURLObject( aSettings.maURL.Complete );
              DBG_ASSERT( aURLObject.GetProtocol() != INetProtocol::NotValid, "invalid URL" )do { if (true && (!(aURLObject.GetProtocol() != INetProtocol
::NotValid))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx"
 ":" "1069" ": "), "%s", "invalid URL"); } } while (false);

              nStatus = XOutBitmap::ExportGraphic( aGraphic, aURLObject, rFilter, nFilter, &aSettings.maFilterData );
          }
      }
  }

  if ( aSettings.mxInteractionHandler.is() && ( nStatus != ERRCODE_NONEErrCode(0) ) )
  {
      Any aInteraction;
      Sequence< css::uno::Reference< css::task::XInteractionContinuation > > lContinuations(1);
      ::comphelper::OInteractionApprove* pApprove = new ::comphelper::OInteractionApprove();
      lContinuations[0].set(static_cast< XInteractionContinuation* >(pApprove), UNO_QUERY);

      GraphicFilterRequest aErrorCode;
      aErrorCode.ErrCode = sal_uInt32(nStatus);
      aInteraction <<= aErrorCode;
      aSettings.mxInteractionHandler->handle( framework::InteractionRequest::CreateRequest( aInteraction, lContinuations ) );
  }
  return nStatus == ERRCODE_NONEErrCode(0);
1089}

1091void SAL_CALL GraphicExporter::cancel()
1092{
1093}

1095// XExporter

1097/** the source 'document' could be a XDrawPage, a XShape or a generic XShapes */
1098void SAL_CALL GraphicExporter::setSourceDocument( const Reference< lang::XComponent >& xComponent )
1099{
  ::SolarMutexGuard aGuard;

  mxShapes = nullptr;
  mpUnoPage = nullptr;

  try
  {
  // any break inside this one loop while will throw an IllegalArgumentException
  do
  {
      mxPage.set( xComponent, UNO_QUERY );
      mxShapes.set( xComponent, UNO_QUERY );
      mxShape.set( xComponent, UNO_QUERY );

      // Step 1: try a generic XShapes
      if( !mxPage.is() && !mxShape.is() && mxShapes.is() )
5
←
Calling 'BaseReference::is'→
7
←
Returning from 'BaseReference::is'→
8
←
Calling 'BaseReference::is'→
10
←
Returning from 'BaseReference::is'→
11
←
Calling 'BaseReference::is'→
13
←
Returning from 'BaseReference::is'→
14
←
Taking true branch→
      {
          // we do not support empty shape collections
          if( 0 == mxShapes->getCount() )
15
←
Assuming the condition is false→
16
←
Taking false branch→
              break;

          // get first shape to detect corresponding page and model
          mxShapes->getByIndex(0) >>= mxShape;
      }
      else
      {
          mxShapes = nullptr;
      }

      // Step 2: try a shape
      if( mxShape.is() )
17
←
Calling 'BaseReference::is'→
20
←
Returning from 'BaseReference::is'→
21
←
Taking false branch→
      {
          if( nullptr == GetSdrObjectFromXShape( mxShape ) )
          {
              // This is not a Draw shape, let's see if it's a Writer one.
              uno::Reference<beans::XPropertySet> xPropertySet(mxShape, uno::UNO_QUERY);
              if (!xPropertySet.is())
                  break;
              uno::Reference<graphic::XGraphic> xGraphic(
                  xPropertySet->getPropertyValue("Graphic"), uno::UNO_QUERY);
              if (!xGraphic.is())
                  break;

              maGraphic = Graphic(xGraphic);
              if (!maGraphic.IsNone())
                  return;
              else
                  break;
          }

          // get page for this shape
          Reference< XChild > xChild( mxShape, UNO_QUERY );
          if( !xChild.is() )
              break;

          Reference< XInterface > xInt;
          do
          {
              xInt = xChild->getParent();
              mxPage.set( xInt, UNO_QUERY );
              if( !mxPage.is() )
                  xChild.set( xInt, UNO_QUERY );
          }
          while( !mxPage.is() && xChild.is() );

          if( !mxPage.is() )
              break;
      }

      // Step 3: check the page
      if( !mxPage.is() )
22
←
Taking false branch→
          break;

      mpUnoPage = comphelper::getUnoTunnelImplementation<SvxDrawPage>( mxPage );

      if( nullptr == mpUnoPage || nullptr == mpUnoPage->GetSdrPage() )
23
←
Assuming the condition is false→
24
←
Assuming the condition is false→
25
←
Taking false branch→
          break;

      mpDoc = &mpUnoPage->GetSdrPage()->getSdrModelFromSdrPage();

      // Step 4:  If we got a generic XShapes test all contained shapes
      //          if they belong to the same XDrawPage

      if( mxShapes.is() )
26
←
Taking false branch→
      {
          SdrPage* pPage = mpUnoPage->GetSdrPage();
          SdrObject* pObj;
          Reference< XShape > xShape;

          bool bOk = true;

          const sal_Int32 nCount = mxShapes->getCount();

          // test all but the first shape if they have the same page than
          // the first shape
          for( sal_Int32 nIndex = 1; bOk && ( nIndex < nCount ); nIndex++ )
          {
              mxShapes->getByIndex( nIndex ) >>= xShape;
              pObj = GetSdrObjectFromXShape( xShape );
              bOk = pObj && pObj->getSdrPageFromSdrObject() == pPage;
          }

          if( !bOk )
              break;
      }

      // no errors so far
      return;
  }
  while( false );
  }
  catch( Exception& )
  {
  }

  throw IllegalArgumentException();
1216}

1218// XServiceInfo
1219OUString SAL_CALL GraphicExporter::getImplementationName(  )
1220{
  return "com.sun.star.comp.Draw.GraphicExporter";
1222}

1224sal_Bool SAL_CALL GraphicExporter::supportsService( const OUString& ServiceName )
1225{
  return cppu::supportsService(this, ServiceName);
1227}

1229Sequence< OUString > SAL_CALL GraphicExporter::getSupportedServiceNames(  )
1230{
  Sequence< OUString > aSupportedServiceNames { "com.sun.star.drawing.GraphicExportFilter" };
  return aSupportedServiceNames;
1233}

1235// XMimeTypeInfo
1236sal_Bool SAL_CALL GraphicExporter::supportsMimeType( const OUString& rMimeTypeName )
1237{
  GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
  sal_uInt16 nCount = rFilter.GetExportFormatCount();
  sal_uInt16 nFilter;
  for( nFilter = 0; nFilter < nCount; nFilter++ )
  {
      if( rMimeTypeName == rFilter.GetExportFormatMediaType( nFilter ) )
      {
          return true;
      }
  }

  return false;
1250}

1252Sequence< OUString > SAL_CALL GraphicExporter::getSupportedMimeTypeNames(  )
1253{
  GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
  sal_uInt16 nCount = rFilter.GetExportFormatCount();
  sal_uInt16 nFilter;
  sal_uInt16 nFound = 0;

  Sequence< OUString > aSeq( nCount );
  OUString* pStr = aSeq.getArray();

  for( nFilter = 0; nFilter < nCount; nFilter++ )
  {
      OUString aMimeType( rFilter.GetExportFormatMediaType( nFilter ) );
      if( !aMimeType.isEmpty() )
      {
          *pStr++ = aMimeType;
          nFound++;
      }
  }

  if( nFound < nCount )
      aSeq.realloc( nFound );

  return aSeq;
1276}

1278}

1280Graphic SvxGetGraphicForShape( SdrObject& rShape )
1281{
  Graphic aGraphic;
  try
  {
      rtl::Reference< GraphicExporter > xExporter( new GraphicExporter() );
1
Calling constructor for 'Reference<(anonymous namespace)::GraphicExporter>'→
3
←
Returning from constructor for 'Reference<(anonymous namespace)::GraphicExporter>'→
      Reference< XComponent > xComp( rShape.getUnoShape(), UNO_QUERY_THROW );
      xExporter->setSourceDocument( xComp );
4
←
Calling 'GraphicExporter::setSourceDocument'→
27
←
Returning from 'GraphicExporter::setSourceDocument'→
      ExportSettings aSettings(&rShape.getSdrModelFromSdrObject());
      xExporter->GetGraphic( aSettings, aGraphic, true/*bVector*/ );
28
←
Calling 'GraphicExporter::GetGraphic'→
  }
  catch( Exception& )
  {
      TOOLS_WARN_EXCEPTION("svx", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "svx")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"svx"), ("/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx"
 ":" "1293" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("svx"), ("/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx"
 ":" "1293" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"svx"), ("/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx"
 ":" "1293" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("svx"), ("/home/maarten/src/libreoffice/core/svx/source/unodraw/UnoGraphicExporter.cxx"
 ":" "1293" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
  return aGraphic;
1296}

1298extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
1299com_sun_star_comp_Draw_GraphicExporter_get_implementation(
  css::uno::XComponentContext *,
  css::uno::Sequence<css::uno::Any> const &)
1302{
  return cppu::acquire(new GraphicExporter);
1304}

1306/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody1.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
2
←
Taking true branch→
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody)
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
19#ifndef INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H
20#define INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H

22#include "sal/config.h"

24#include <cassert>
25#include <cstddef>

27#if defined LIBO_INTERNAL_ONLY1
28#include <type_traits>
29#endif

31#include "rtl/alloc.h"

33namespace com
34{
35namespace sun
36{
37namespace star
38{
39namespace uno
40{

42class RuntimeException;
43class XInterface;
44class Type;
45class Any;

47/** Enum defining UNO_REF_NO_ACQUIRE for setting reference without acquiring a given interface.
  Deprecated, please use SAL_NO_ACQUIRE.
  @deprecated
50*/
51enum UnoReference_NoAcquire
52{
  /** This enum value can be used for creating a reference granting a given interface,
      i.e. transferring ownership to it.
  */
  UNO_REF_NO_ACQUIRE
57};

59/** This base class serves as a base class for all template reference classes and
  has been introduced due to compiler problems with templated operators ==, =!.
61*/
62class BaseReference
63{
64protected:
  /** the interface pointer
  */
  XInterface * _pInterface;

  /** Queries given interface for type rType.

      @param pInterface interface pointer
      @param rType interface type
      @return interface of demanded type (may be null)
  */
  inline static XInterface * SAL_CALL iquery( XInterface * pInterface, const Type & rType );
  /** Queries given interface for type rType.
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface interface pointer
      @param rType interface type
      @return interface of demanded type
  */
  inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface, const Type & rType );

85public:
  /** Gets interface pointer. This call does not acquire the interface.

      @return UNacquired interface pointer
  */
  XInterface * SAL_CALL get() const
      { return _pInterface; }

  /** Checks if reference is null.

      @return true if reference acquires an interface, i.e. true if it is not null
  */
  bool SAL_CALL is() const
      { return (NULL__null != _pInterface); }
6
←
Returning zero, which participates in a condition later→
9
←
Returning zero, which participates in a condition later→
12
←
Returning the value 1, which participates in a condition later→
18
←
Assuming NULL is equal to field '_pInterface'→
19
←
Returning zero, which participates in a condition later→
41
←
Assuming NULL is equal to field '_pInterface'→
42
←
Returning zero, which participates in a condition later→

100#if defined LIBO_INTERNAL_ONLY1
  /** Checks if reference is null.

      @return true if reference acquires an interface, i.e. true if it is not null
  */
  explicit operator bool() const
      { return is(); }
107#endif

  /** Equality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param pInterface another interface
      @return true if both references are null or refer to the same object, false otherwise
  */
  inline bool SAL_CALL operator == ( XInterface * pInterface ) const;
  /** Inequality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param pInterface another interface
      @return false if both references are null or refer to the same object, true otherwise
  */
  inline bool SAL_CALL operator != ( XInterface * pInterface ) const;

  /** Equality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param rRef another reference
      @return true if both references are null or refer to the same object, false otherwise
  */
  inline bool SAL_CALL operator == ( const BaseReference & rRef ) const;
  /** Inequality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param rRef another reference
      @return false if both references are null or refer to the same object, true otherwise
  */
  inline bool SAL_CALL operator != ( const BaseReference & rRef ) const;

  /** Needed by some STL containers.

      @param rRef another reference
      @return true, if this reference is less than rRef
  */
  inline bool SAL_CALL operator < ( const BaseReference & rRef ) const;
145};

147/** Enum defining UNO_QUERY for implicit interface query.
148*/
149enum UnoReference_Query
150{
  /** This enum value can be used for implicit interface query.
  */
  UNO_QUERY
154};
155/** Enum defining UNO_QUERY_THROW for implicit interface query.
  If the demanded interface is unavailable, then a RuntimeException is thrown.
157*/
158enum UnoReference_QueryThrow
159{
  /** This enum value can be used for implicit interface query.
  */
  UNO_QUERY_THROW
163};
164/** Enum defining UNO_SET_THROW for throwing if attempts are made to assign a null
  interface

  @since UDK 3.2.8
168*/
169enum UnoReference_SetThrow
170{
  UNO_SET_THROW
172};

174/** Template reference class for interface type derived from BaseReference.
  A special constructor given the UNO_QUERY identifier queries interfaces
  for reference type.
177*/
178template< class interface_type >
179class SAL_DLLPUBLIC_RTTI__attribute__ ((type_visibility("default"))) Reference : public BaseReference
180{
  /** Queries given interface for type interface_type.

      @param pInterface interface pointer
      @return interface of demanded type (may be null)
  */
  inline static XInterface * SAL_CALL iquery( XInterface * pInterface );
  /** Queries given interface for type interface_type.
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface interface pointer
      @return interface of demanded type
  */
  inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface );
  /** Returns the given interface if it is not <NULL/>, throws a RuntimeException otherwise.

      @param pInterface interface pointer
      @return pInterface
  */
  inline static interface_type * SAL_CALL iset_throw( interface_type * pInterface );

  /** Cast from an "interface pointer" (e.g., BaseReference::_pInterface) to a
      pointer to this interface_type.

      To work around ambiguities in the case of multiple-inheritance interface
      types (which inherit XInterface more than once), use reinterpret_cast
      (resp. a sequence of two static_casts, to avoid warnings about
      reinterpret_cast used between related classes) to switch from a pointer
      to XInterface to a pointer to this derived interface_type.  In
      principle, this is not guaranteed to work.  In practice, it seems to
      work on all supported platforms.
  */
  static interface_type * castFromXInterface(XInterface * p) {
      return static_cast< interface_type * >(static_cast< void * >(p));
  }

  /** Cast from a pointer to this interface_type to an "interface pointer"
      (e.g., BaseReference::_pInterface).

      To work around ambiguities in the case of multiple-inheritance interface
      types (which inherit XInterface more than once), use reinterpret_cast
      (resp. a sequence of two static_casts, to avoid warnings about
      reinterpret_cast used between related classes) to switch from a pointer
      to this derived interface_type to a pointer to XInterface.  In
      principle, this is not guaranteed to work.  In practice, it seems to
      work on all supported platforms.
  */
  static XInterface * castToXInterface(interface_type * p) {
      return static_cast< XInterface * >(static_cast< void * >(p));
  }

231public:
  /// @cond INTERNAL
  // these are here to force memory de/allocation to sal lib.
  static void * SAL_CALL operator new ( ::size_t nSize )
      { return ::rtl_allocateMemory( nSize ); }
  static void SAL_CALL operator delete ( void * pMem )
      { ::rtl_freeMemory( pMem ); }
  static void * SAL_CALL operator new ( ::size_t, void * pMem )
      { return pMem; }
  static void SAL_CALL operator delete ( void *, void * )
      {}
  /// @endcond

  /** Destructor: Releases interface if set.
  */
  inline ~Reference() COVERITY_NOEXCEPT_FALSE;

  /** Default Constructor: Sets null reference.
  */
  inline Reference();

  /** Copy constructor: Copies interface reference.

      @param rRef another reference
  */
  inline Reference( const Reference< interface_type > & rRef );

258#if defined LIBO_INTERNAL_ONLY1
  /** Move constructor

      @param rRef another reference
  */
  inline Reference( Reference< interface_type > && rRef ) noexcept;

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<
          std::is_base_of_v<interface_type, derived_type>
          && !std::is_same_v<interface_type, XInterface>, void *> = nullptr);
279#endif

  /** Constructor: Sets given interface pointer.

      @param pInterface an interface pointer
  */
  inline Reference( interface_type * pInterface );

  /** Constructor: Sets given interface pointer without acquiring it.

      @param pInterface another reference
      @param dummy SAL_NO_ACQUIRE to force obvious distinction to other constructors
  */
  inline Reference( interface_type * pInterface, __sal_NoAcquire dummy);
  /** Constructor: Sets given interface pointer without acquiring it.
      Deprecated, please use SAL_NO_ACQUIRE version.

      @deprecated
      @param pInterface another reference
      @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to other constructors
  */
  inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version")__attribute__((deprecated("use SAL_NO_ACQUIRE version"))) Reference( interface_type * pInterface, UnoReference_NoAcquire dummy );

  /** Constructor: Queries given interface for reference interface type (interface_type).

      @param rRef another reference
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( const BaseReference & rRef, UnoReference_Query dummy );
  /** Constructor: Queries given interface for reference interface type (interface_type).

      @param pInterface an interface pointer
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( XInterface * pInterface, UnoReference_Query dummy);
  /** Constructor: Queries given any for reference interface type (interface_type).

      @param rAny an any
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( const Any & rAny, UnoReference_Query dummy);
  /** Constructor: Queries given interface for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param rRef another reference
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( const BaseReference & rRef, UnoReference_QueryThrow dummy );
328#ifdef LIBO_INTERNAL_ONLY1
  /**
      Prevent code from calling the QUERY_THROW constructor, when they meant to use the SET_THROW constructor.
  */
  Reference( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
333#endif
  /** Constructor: Queries given interface for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( XInterface * pInterface, UnoReference_QueryThrow dummy );
  /** Constructor: Queries given any for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param rAny an any
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( const Any & rAny, UnoReference_QueryThrow dummy );
  /** Constructor: assigns from the given interface of the same type. Throws a RuntimeException
      if the source interface is NULL.

      @param rRef another interface reference of the same type
      @param dummy UNO_SET_THROW to distinguish from default copy constructor

      @since UDK 3.2.8
  */
  inline Reference( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy );
  /** Constructor: assigns from the given interface of the same type. Throws a RuntimeException
      if the source interface is NULL.

      @param pInterface an interface pointer
      @param dummy UNO_SET_THROW to distinguish from default assignment constructor

      @since UDK 3.2.8
  */
  inline Reference( interface_type * pInterface, UnoReference_SetThrow dummy );

  /** Cast operator to Reference< XInterface >: Reference objects are binary compatible and
      any interface must be derived from com.sun.star.uno.XInterface.
      This a useful direct cast possibility.
  */
  SAL_CALL operator const Reference< XInterface > & () const
      { return * reinterpret_cast< const Reference< XInterface > * >( this ); }

  /** Dereference operator: Used to call interface methods.

      @return UNacquired interface pointer
  */
  interface_type * SAL_CALL operator -> () const {
      assert(_pInterface != NULL)(static_cast <bool> (_pInterface != __null) ? void (0) :
 __assert_fail ("_pInterface != NULL", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h"
, 381, __extension__ __PRETTY_FUNCTION__));
      return castFromXInterface(_pInterface);
  }

  /** Indirection operator.

      @since LibreOffice 6.3
      @return UNacquired interface reference
  */
  interface_type & SAL_CALL operator * () const {
      assert(_pInterface != NULL)(static_cast <bool> (_pInterface != __null) ? void (0) :
 __assert_fail ("_pInterface != NULL", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h"
, 391, __extension__ __PRETTY_FUNCTION__));
      return *castFromXInterface(_pInterface);
  }

  /** Gets interface pointer. This call does not acquire the interface.

      @return UNacquired interface pointer
  */
  interface_type * SAL_CALL get() const
      { return castFromXInterface(_pInterface); }

  /** Clears reference, i.e. releases interface. Reference is null after clear() call.
  */
  inline void SAL_CALL clear();

  /** Sets the given interface. An interface already set will be released.

      @param rRef another reference
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( const Reference< interface_type > & rRef );
  /** Sets the given interface. An interface already set will be released.

      @param pInterface another interface
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( interface_type * pInterface );

  /** Sets interface pointer without acquiring it. An interface already set will be released.

      @param pInterface an interface pointer
      @param dummy SAL_NO_ACQUIRE to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( interface_type * pInterface, __sal_NoAcquire dummy);
  /** Sets interface pointer without acquiring it. An interface already set will be released.
      Deprecated, please use SAL_NO_ACQUIRE version.

      @deprecated
      @param pInterface an interface pointer
      @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version")__attribute__((deprecated("use SAL_NO_ACQUIRE version"))) bool SAL_CALL set( interface_type * pInterface, UnoReference_NoAcquire dummy);

  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( XInterface * pInterface, UnoReference_Query dummy );
  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.

      @param rRef another reference
      @param dummy UNO_QUERY to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( const BaseReference & rRef, UnoReference_Query dummy);

  /** Queries given any for reference interface type (interface_type)
      and sets it.  An interface already set will be released.

      @param rAny
             an Any containing an interface
      @param dummy
             UNO_QUERY to force obvious distinction
             to set methods
      @return
              true, if non-null interface was set
  */
  inline bool set( Any const & rAny, UnoReference_Query dummy );

  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to set methods
  */
  inline void SAL_CALL set( XInterface * pInterface, UnoReference_QueryThrow dummy );
  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param rRef another reference
      @param dummy UNO_QUERY_THROW to force obvious distinction
             to set methods
  */
  inline void SAL_CALL set( const BaseReference & rRef, UnoReference_QueryThrow dummy );
484#ifdef LIBO_INTERNAL_ONLY1
  /**
      Prevent code from calling the QUERY_THROW version, when they meant to use the SET_THROW version.
  */
  void set( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
489#endif

  /** Queries given any for reference interface type (interface_type) and
      sets it.  An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param rAny
             an Any containing an interface
      @param dummy
             UNO_QUERY_THROW to force obvious distinction to set methods
  */
  inline void set( Any const & rAny, UnoReference_QueryThrow dummy);
  /** sets the given interface
      An interface already set will be released.
      Throws a RuntimeException if the source interface is @b NULL.

      @param pInterface an interface pointer
      @param dummy UNO_SET_THROW to force obvious distinction to other set methods

      @since UDK 3.2.8
  */
  inline void SAL_CALL set( interface_type * pInterface, UnoReference_SetThrow dummy);
  /** sets the given interface
      An interface already set will be released.
      Throws a RuntimeException if the source interface is @b NULL.

      @param rRef an interface reference
      @param dummy UNO_SET_THROW to force obvious distinction to other set methods

      @since UDK 3.2.8
  */
  inline void SAL_CALL set( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy);


  /** Assignment operator: Acquires given interface pointer and sets reference.
      An interface already set will be released.

      @param pInterface an interface pointer
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( interface_type * pInterface );
  /** Assignment operator: Acquires given interface reference and sets reference.
      An interface already set will be released.

      @param rRef an interface reference
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( const Reference< interface_type > & rRef );
537#if defined LIBO_INTERNAL_ONLY1
  /** Assignment move operator: Acquires given interface reference and sets reference.
      An interface already set will be released.

      @param rRef an interface reference
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( Reference< interface_type > && rRef ) noexcept;
545#endif
  /** Queries given interface reference for type interface_type.

      @param rRef interface reference
      @return interface reference of demanded type (may be null)
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] inline static Reference< interface_type > SAL_CALL query( const BaseReference & rRef );
  /** Queries given interface for type interface_type.

      @param pInterface interface pointer
      @return interface reference of demanded type (may be null)
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] inline static Reference< interface_type > SAL_CALL query( XInterface * pInterface );
558};

560}
561}
562}
563}

565#endif

567/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/tools/link.hxx

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#ifndef INCLUDED_TOOLS_LINK_HXX
21#define INCLUDED_TOOLS_LINK_HXX
22 
23#include <sal/config.h>
24 
25#include <sal/macros.h>
26#include <sal/types.h>
27 
28#define DECL_LINK(Member, ArgType, RetType)static RetType LinkStubMember(void *, ArgType); RetType Member
(ArgType) \
29    static RetType LinkStub##Member(void *, ArgType); \
30    RetType Member(ArgType)
31 
32#define DECL_STATIC_LINK(Class, Member, ArgType, RetType)static RetType LinkStubMember(void *, ArgType); static RetType
 Member(Class *, ArgType) \
33    static RetType LinkStub##Member(void *, ArgType); \
34    static RetType Member(Class *, ArgType)
35 
36#define DECL_DLLPRIVATE_LINK(Member, ArgType, RetType)__attribute__ ((visibility("hidden"))) static RetType LinkStubMember
(void *, ArgType); __attribute__ ((visibility("hidden"))) RetType
 Member(ArgType) \
37    SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) static RetType LinkStub##Member(void *, ArgType); \
38    SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) RetType Member(ArgType)
39 
40#define DECL_DLLPRIVATE_STATIC_LINK(Class, Member, ArgType, RetType)__attribute__ ((visibility("hidden"))) static RetType LinkStubMember
(void *, ArgType); __attribute__ ((visibility("hidden"))) static
 RetType Member(Class *, ArgType) \
41    SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) static RetType LinkStub##Member(void *, ArgType); \
42    SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) static RetType Member(Class *, ArgType)
43 
44#define IMPL_LINK(Class, Member, ArgType, ArgName, RetType)RetType Class::LinkStubMember(void * instance, ArgType data) {
 return static_cast<Class *>(instance)->Member(data)
; } RetType Class::Member(ArgType ArgName) \
45    RetType Class::LinkStub##Member(void * instance, ArgType data) { \
46        return static_cast<Class *>(instance)->Member(data); \
47    } \
48    RetType Class::Member(ArgType ArgName)
49 
50#define IMPL_LINK_NOARG(Class, Member, ArgType, RetType)RetType Class::LinkStubMember(void * instance, ArgType data) {
 return static_cast<Class *>(instance)->Member(data)
; } RetType Class::Member(__attribute__ ((unused)) ArgType) \
51    RetType Class::LinkStub##Member(void * instance, ArgType data) { \
52        return static_cast<Class *>(instance)->Member(data); \
53    } \
54    RetType Class::Member(SAL_UNUSED_PARAMETER__attribute__ ((unused)) ArgType)
55 
56#define IMPL_STATIC_LINK( \RetType Class::LinkStubMember(void * instance, ArgType data) {
 return Member(static_cast<Class *>(instance), data); }
 RetType Class::Member(__attribute__ ((unused)) Class *, ArgType
 ArgName)
57        Class, Member, ArgType, ArgName, RetType)RetType Class::LinkStubMember(void * instance, ArgType data) {
 return Member(static_cast<Class *>(instance), data); }
 RetType Class::Member(__attribute__ ((unused)) Class *, ArgType
 ArgName) \
58    RetType Class::LinkStub##Member(void * instance, ArgType data) { \
59        return Member(static_cast<Class *>(instance), data); \
60    } \
61    RetType Class::Member(SAL_UNUSED_PARAMETER__attribute__ ((unused)) Class *, ArgType ArgName)
62 
63#define IMPL_STATIC_LINK_NOARG( \RetType Class::LinkStubMember(void * instance, ArgType data) {
 return Member(static_cast<Class *>(instance), data); }
 RetType Class::Member( __attribute__ ((unused)) Class *, __attribute__
 ((unused)) ArgType)
64        Class, Member, ArgType, RetType)RetType Class::LinkStubMember(void * instance, ArgType data) {
 return Member(static_cast<Class *>(instance), data); }
 RetType Class::Member( __attribute__ ((unused)) Class *, __attribute__
 ((unused)) ArgType) \
65    RetType Class::LinkStub##Member(void * instance, ArgType data) { \
66        return Member(static_cast<Class *>(instance), data); \
67    } \
68    RetType Class::Member( \
69        SAL_UNUSED_PARAMETER__attribute__ ((unused)) Class *, SAL_UNUSED_PARAMETER__attribute__ ((unused)) ArgType)
70 
71#ifdef DBG_UTIL
72#define LINK(Instance, Class, Member)::tools::detail::makeLink( ::tools::detail::castTo<Class *
>(Instance), &Class::LinkStubMember) ::tools::detail::makeLink( \
73    ::tools::detail::castTo<Class *>(Instance), &Class::LinkStub##Member, __FILE__"/home/maarten/src/libreoffice/core/include/tools/link.hxx", __LINE__73, SAL_STRINGIFY(Class::LinkStub##Member)"Class::LinkStub##Member")
74#else
75#define LINK(Instance, Class, Member)::tools::detail::makeLink( ::tools::detail::castTo<Class *
>(Instance), &Class::LinkStubMember) ::tools::detail::makeLink( \
76    ::tools::detail::castTo<Class *>(Instance), &Class::LinkStub##Member)
77#endif
78 
79template<typename Arg, typename Ret>
80class SAL_WARN_UNUSED__attribute__((warn_unused)) Link {
81public:
82    typedef Ret Stub(void *, Arg);
83 
84#ifdef DBG_UTIL
85    Link()
86        : function_(nullptr)
87        , instance_(nullptr)
88        , file_("unknown")
89        , line_(0)
90        , target_("unknown")
91    {
92    }
93 
94    Link(void* instance, Stub* function, const char* const file = "unknown", const int line = 0,
95         const char* const target = "unknown")
96        : function_(function)
97        , instance_(instance)
98        , file_(file)
99        , line_(line)
100        , target_(target)
101    {
102    }
103#else
104    Link(): function_(nullptr), instance_(nullptr) {}
105 
106    Link(void * instance, Stub * function):
107        function_(function), instance_(instance) {}
108#endif
109 
110    Ret Call(Arg data) const
111    { return function_ == nullptr ? Ret() : (*function_)(instance_, data); }
112 
113    bool IsSet() const { return function_ != nullptr; }
114 
115    bool operator !() const { return !IsSet(); }
116 
117    bool operator <(Link const & other) const {
118        char* ptr1 = reinterpret_cast<char*>(function_);
119        char* ptr2 = reinterpret_cast<char*>(other.function_);
120        if (ptr1 < ptr2)
121            return true;
122        else if (ptr1 > ptr2)
123            return false;
124        else
125            return instance_ < other.instance_;
126    };
127 
128    bool operator ==(Link const & other) const
129    { return function_ == other.function_ && instance_ == other.instance_; };
130 
131    void *GetInstance() const { return instance_; }
132 
133#ifdef DBG_UTIL
134    const char* getSourceFilename() const { return file_; }
135    int getSourceLineNumber() const { return line_; }
136    const char* getTargetName() const { return target_; }
137#endif
138 
139private:
140    Stub * function_;
141    void * instance_;
142 
143#ifdef DBG_UTIL
144    /// Support tracing link source and target.
145    /// When debugging async events, it's often critical
146    /// to find out not only where a link leads (i.e. the target
147    /// function), but also where it was created (file:line).
148    const char* file_;
149    int line_;
150    const char* target_;
151#endif
152};
153 
154// Class used to indicate that the Call() parameter is not in use:
155class LinkParamNone { LinkParamNone() = delete; };
156 
157namespace tools::detail {
158 
159// Avoids loplugin:redundantcast in LINK macro, in the common case that Instance
160// is already of type Class * (instead of a derived type):
161template<typename To, typename From> To castTo(From from)
162{ return static_cast<To>(from); }
32
←
Returning without writing to 'from->mpDoc', which participates in a condition later→
33
←
Returning without writing to 'from->mpDoc'→
163 
164#ifdef DBG_UTIL
165template<typename Arg, typename Ret>
166Link<Arg, Ret> makeLink(void * instance, Ret (* function)(void *, Arg), const char* file, int line, const char* target) {
167    return Link<Arg, Ret>(instance, function, file, line, target);
168}
169#else
170template<typename Arg, typename Ret>
171Link<Arg, Ret> makeLink(void * instance, Ret (* function)(void *, Arg)) {
172    return Link<Arg, Ret>(instance, function);
36
←
Returning without writing to 'instance->mpDoc', which participates in a condition later→
37
←
Returning without writing to 'instance->mpDoc'→
173}
174#endif
175 
176}
177 
178#endif
179 
180/* vim:set shiftwidth=4 softtabstop=4 expandtab: */