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

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 192, column 9 Use of memory after it is freed

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 print3.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 /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/glm -isystem /usr/include/glib-2.0 -isystem /usr/lib64/glib-2.0/include -isystem /usr/include/libmount -isystem /usr/include/blkid -isystem /usr/include/cairo -isystem /usr/include/glib-2.0 -isystem /usr/lib64/glib-2.0/include -isystem /usr/include/pixman-1 -isystem /usr/include/freetype2 -isystem /usr/include/libpng16 -isystem /usr/include/libxml2 -isystem /usr/include/freetype2 -isystem /usr/include/libpng16 -isystem /usr/include/dbus-1.0 -isystem /usr/lib64/dbus-1.0/include -isystem /usr/include/freetype2 -isystem /usr/include/libpng16 -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 VCL_DLLIMPLEMENTATION -D DLLIMPLEMENTATION_UITEST -D CUI_DLL_NAME="libcuilo.so" -D DESKTOP_DETECTOR_DLL_NAME="libdesktop_detectorlo.so" -D TK_DLL_NAME="libtklo.so" -D SYSTEM_ZLIB -D GLM_FORCE_CTOR_INIT -D SK_USER_CONFIG_HEADER=</home/maarten/src/libreoffice/core/config_host/config_skia.h> -D SKIA_DLL -D ENABLE_CUPS -D HAVE_VALGRIND_HEADERS -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/skia/include/core -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/skia/include/effects -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/skia/include/gpu -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/skia/include/config -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/skia/include/ports -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/skia/include/third_party/vulkan -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/skia/tools/gpu -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/skia -I /home/maarten/src/libreoffice/core/external/skia/inc/ -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/mdds/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/lcms2/include -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/workdir/UnpackedTarball/harfbuzz/src -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/graphite/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -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/libpng -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/libjpeg-turbo -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/vcl/inc -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/CustomTarget/officecfg/registry -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libxml2 -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/vcl/source/gdi/print3.cxx

/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.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 <vcl/weld.hxx>
21#include <vcl/print.hxx>
22#include <vcl/svapp.hxx>
23#include <vcl/metaact.hxx>
24#include <configsettings.hxx>
25#include <tools/urlobj.hxx>
26#include <comphelper/processfactory.hxx>
27#include <comphelper/sequence.hxx>
28#include <sal/types.h>
29#include <sal/log.hxx>
30#include <tools/debug.hxx>
31#include <tools/diagnose_ex.h>

33#include <printdlg.hxx>
34#include <svdata.hxx>
35#include <salinst.hxx>
36#include <salprn.hxx>
37#include <strings.hrc>

39#include <com/sun/star/ui/dialogs/FilePicker.hpp>
40#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
41#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
42#include <com/sun/star/view/DuplexMode.hpp>
43#include <com/sun/star/lang/IllegalArgumentException.hpp>
44#include <com/sun/star/awt/Size.hpp>

46#include <unordered_map>
47#include <unordered_set>

49using namespace vcl;

51namespace {

53class ImplPageCache
54{
  struct CacheEntry
  {
      GDIMetaFile                 aPage;
      PrinterController::PageSize aSize;
  };

  std::vector< CacheEntry >   maPages;
  std::vector< sal_Int32 >    maPageNumbers;
  std::vector< sal_Int32 >    maCacheRanking;

  static const sal_Int32      nCacheSize = 6;

  void updateRanking( sal_Int32 nLastHit )
  {
      if( maCacheRanking[0] != nLastHit )
      {
          for( sal_Int32 i = nCacheSize-1; i > 0; i-- )
              maCacheRanking[i] = maCacheRanking[i-1];
          maCacheRanking[0] = nLastHit;
      }
  }

77public:
  ImplPageCache()
  : maPages( nCacheSize )
  , maPageNumbers( nCacheSize, -1 )
  , maCacheRanking( nCacheSize )
  {
      for( sal_Int32 i = 0; i < nCacheSize; i++ )
          maCacheRanking[i] = nCacheSize - i - 1;
  }

  // caution: does not ensure uniqueness
  void insert( sal_Int32 i_nPageNo, const GDIMetaFile& i_rPage, const PrinterController::PageSize& i_rSize )
  {
      sal_Int32 nReplacePage = maCacheRanking.back();
      maPages[ nReplacePage ].aPage = i_rPage;
      maPages[ nReplacePage ].aSize = i_rSize;
      maPageNumbers[ nReplacePage ] = i_nPageNo;
      // cache insertion means in our case, the page was just queried
      // so update the ranking
      updateRanking( nReplacePage );
  }

  // caution: bad algorithm; should there ever be reason to increase the cache size beyond 6
  // this needs to be urgently rewritten. However do NOT increase the cache size lightly,
  // whole pages can be rather memory intensive
  bool get( sal_Int32 i_nPageNo, GDIMetaFile& o_rPageFile, PrinterController::PageSize& o_rSize )
  {
      for( sal_Int32 i = 0; i < nCacheSize; ++i )
      {
          if( maPageNumbers[i] == i_nPageNo )
          {
              updateRanking( i );
              o_rPageFile = maPages[i].aPage;
              o_rSize = maPages[i].aSize;
              return true;
          }
      }
      return false;
  }

  void invalidate()
  {
      for( sal_Int32 i = 0; i < nCacheSize; ++i )
      {
          maPageNumbers[i] = -1;
          maPages[i].aPage.Clear();
          maCacheRanking[i] = nCacheSize - i - 1;
      }
  }
126};

128}

130class vcl::ImplPrinterControllerData
131{
132public:
  struct ControlDependency
  {
      OUString       maDependsOnName;
      sal_Int32           mnDependsOnEntry;

      ControlDependency() : mnDependsOnEntry( -1 ) {}
  };

  typedef std::unordered_map< OUString, size_t > PropertyToIndexMap;
  typedef std::unordered_map< OUString, ControlDependency > ControlDependencyMap;
  typedef std::unordered_map< OUString, css::uno::Sequence< sal_Bool > > ChoiceDisableMap;

  VclPtr< Printer >                                           mxPrinter;
  weld::Window*                                               mpWindow;
  css::uno::Sequence< css::beans::PropertyValue >             maUIOptions;
  std::vector< css::beans::PropertyValue >                    maUIProperties;
  std::vector< bool >                                         maUIPropertyEnabled;
  PropertyToIndexMap                                          maPropertyToIndex;
  ControlDependencyMap                                        maControlDependencies;
  ChoiceDisableMap                                            maChoiceDisableMap;
  bool                                                        mbFirstPage;
  bool                                                        mbLastPage;
  bool                                                        mbReversePageOrder;
  bool                                                        mbPapersizeFromSetup;
  bool                                                        mbPapersizeFromUser;
  bool                                                        mbPrinterModified;
  css::view::PrintableState                                   meJobState;

  vcl::PrinterController::MultiPageSetup                      maMultiPage;

  std::shared_ptr<vcl::PrintProgressDialog>                   mxProgress;

  ImplPageCache                                               maPageCache;

  // set by user through printer properties subdialog of printer settings dialog
  Size                                                        maDefaultPageSize;
  // set by user through print dialog
  Size                                                        maUserPageSize;
  // set by user through printer properties subdialog of printer settings dialog
  sal_Int32                                                   mnDefaultPaperBin;
  // Set by user through printer properties subdialog of print dialog.
  // Overrides application-set tray for a page.
  sal_Int32                                                   mnFixedPaperBin;

  // N.B. Apparently we have three levels of paper tray settings
  // (latter overrides former):
  // 1. default tray
  // 2. tray set for a concrete page by an application, e.g., writer
  //    allows setting a printer tray (for the default printer) for a
  //    page style. This setting can be overridden by user by selecting
  //    "Use only paper tray from printer preferences" on the Options
  //    page in the print dialog, in which case the default tray is
  //    used for all pages.
  // 3. tray set in printer properties the printer dialog
  // I'm not quite sure why 1. and 3. are distinct, but the commit
  // history suggests this is intentional...

  ImplPrinterControllerData() :
      mpWindow( nullptr ),
      mbFirstPage( true ),
      mbLastPage( false ),
      mbReversePageOrder( false ),
      mbPapersizeFromSetup( false ),
      mbPapersizeFromUser( false ),
      mbPrinterModified( false ),
      meJobState( css::view::PrintableState_JOB_STARTED ),
      mnDefaultPaperBin( -1 ),
      mnFixedPaperBin( -1 )
  {}

  ~ImplPrinterControllerData()
  {
      if (mxProgress)
      {
          mxProgress->response(RET_CANCEL);
          mxProgress.reset();
      }
  }

  const Size& getRealPaperSize( const Size& i_rPageSize, bool bNoNUP ) const
  {
      if ( mbPapersizeFromUser )
          return maUserPageSize;
      if( mbPapersizeFromSetup )
          return maDefaultPageSize;
      if( maMultiPage.nRows * maMultiPage.nColumns > 1 && ! bNoNUP )
          return maMultiPage.aPaperSize;
      return i_rPageSize;
  }
  PrinterController::PageSize modifyJobSetup( const css::uno::Sequence< css::beans::PropertyValue >& i_rProps );
  void resetPaperToLastConfigured();
224};

226PrinterController::PrinterController(const VclPtr<Printer>& i_xPrinter, weld::Window* i_pWindow)
  : mpImplData( new ImplPrinterControllerData )
228{
  mpImplData->mxPrinter = i_xPrinter;
  mpImplData->mpWindow = i_pWindow;
231}

233static OUString queryFile( Printer const * pPrinter )
234{
  OUString aResult;

  css::uno::Reference< css::uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
  css::uno::Reference< css::ui::dialogs::XFilePicker3 > xFilePicker = css::ui::dialogs::FilePicker::createWithMode(xContext, css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION);

  try
  {
242#ifdef UNX1
      // add PostScript and PDF
      bool bPS = true, bPDF = true;
      if( pPrinter )
      {
          if( pPrinter->GetCapabilities( PrinterCapType::PDF ) )
              bPS = false;
          else
              bPDF = false;
      }
      if( bPS )
          xFilePicker->appendFilter( "PostScript", "*.ps" );
      if( bPDF )
          xFilePicker->appendFilter( "Portable Document Format", "*.pdf" );
256#elif defined _WIN32
      (void)pPrinter;
      xFilePicker->appendFilter( "*.PRN", "*.prn" );
259#endif
      // add arbitrary files
      xFilePicker->appendFilter(VclResId(SV_STDTEXT_ALLFILETYPESreinterpret_cast<char const *>("SV_STDTEXT_ALLFILETYPES"
 "\004" u8"Any type")), "*.*");
  }
  catch (const css::lang::IllegalArgumentException&)
  {
      TOOLS_WARN_EXCEPTION( "vcl.gdi", "caught IllegalArgumentException when registering filter" )do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "vcl.gdi")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "caught IllegalArgumentException when registering filter"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "265" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "caught IllegalArgumentException when registering filter"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "caught IllegalArgumentException when registering filter"
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "265" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "caught IllegalArgumentException when registering filter"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "265" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "caught IllegalArgumentException when registering filter"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "caught IllegalArgumentException when registering filter"
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "265" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }

  if( xFilePicker->execute() == css::ui::dialogs::ExecutableDialogResults::OK )
  {
      css::uno::Sequence< OUString > aPathSeq( xFilePicker->getSelectedFiles() );
      INetURLObject aObj( aPathSeq[0] );
      aResult = aObj.PathToFileName();
  }
  return aResult;
275}

277namespace {

279struct PrintJobAsync
280{
  std::shared_ptr<PrinterController>  mxController;
  JobSetup                            maInitSetup;

  PrintJobAsync(const std::shared_ptr<PrinterController>& i_xController,
                const JobSetup& i_rInitSetup)
  : mxController( i_xController ), maInitSetup( i_rInitSetup )
  {}

  DECL_LINK( ExecJob, void*, void )static void LinkStubExecJob(void *, void*); void ExecJob(void
*);
290};

292}

294IMPL_LINK_NOARG(PrintJobAsync, ExecJob, void*, void)void PrintJobAsync::LinkStubExecJob(void * instance, void* data
) { return static_cast<PrintJobAsync *>(instance)->ExecJob
(data); } void PrintJobAsync::ExecJob(__attribute__ ((unused)
) void*)
295{
  Printer::ImplPrintJob(mxController, maInitSetup);

  // clean up, do not access members after this
  delete this;
300}

302void Printer::PrintJob(const std::shared_ptr<PrinterController>& i_xController,
                     const JobSetup& i_rInitSetup)
304{
  bool bSynchronous = false;
  css::beans::PropertyValue* pVal = i_xController->getValue( "Wait" );
  if( pVal )
      pVal->Value >>= bSynchronous;

  if( bSynchronous )
      ImplPrintJob(i_xController, i_rInitSetup);
  else
  {
      PrintJobAsync* pAsync = new PrintJobAsync(i_xController, i_rInitSetup);
      Application::PostUserEvent( LINK( pAsync, PrintJobAsync, ExecJob )::tools::detail::makeLink( ::tools::detail::castTo<PrintJobAsync
 *>(pAsync), &PrintJobAsync::LinkStubExecJob) );
  }
317}

319bool Printer::PreparePrintJob(std::shared_ptr<PrinterController> xController,
                         const JobSetup& i_rInitSetup)
321{
  // check if there is a default printer; if not, show an error box (if appropriate)
  if( GetDefaultPrinterName().isEmpty() )
  {
      if (xController->isShowDialogs())
      {
          std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(xController->getWindow(), "vcl/ui/errornoprinterdialog.ui"));
          std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("ErrorNoPrinterDialog"));
          xBox->run();
      }
      xController->setValue( "IsDirect",
                             css::uno::makeAny( false ) );
  }

  // setup printer

  // #i114306# changed behavior back from persistence
  // if no specific printer is already set, create the default printer
  if (!xController->getPrinter())
  {
      OUString aPrinterName( i_rInitSetup.GetPrinterName() );
      VclPtrInstance<Printer> xPrinter( aPrinterName );
      xPrinter->SetJobSetup(i_rInitSetup);
      xController->setPrinter(xPrinter);
      xController->setPapersizeFromSetup(xPrinter->GetPrinterSettingsPreferred());
  }

  // reset last page property
  xController->setLastPage(false);

  // update "PageRange" property inferring from other properties:
  // case 1: "Pages" set from UNO API ->
  //         setup "Print Selection" and insert "PageRange" attribute
  // case 2: "All pages" is selected
  //         update "Page range" attribute to have a sensible default,
  //         but leave "All" as selected

  // "Pages" attribute from API is now equivalent to "PageRange"
  // AND "PrintContent" = 1 except calc where it is "PrintRange" = 1
  // Argh ! That sure needs cleaning up
  css::beans::PropertyValue* pContentVal = xController->getValue("PrintRange");
  if( ! pContentVal )
      pContentVal = xController->getValue("PrintContent");

  // case 1: UNO API has set "Pages"
  css::beans::PropertyValue* pPagesVal = xController->getValue("Pages");
  if( pPagesVal )
  {
      OUString aPagesVal;
      pPagesVal->Value >>= aPagesVal;
      if( !aPagesVal.isEmpty() )
      {
          // "Pages" attribute from API is now equivalent to "PageRange"
          // AND "PrintContent" = 1 except calc where it is "PrintRange" = 1
          // Argh ! That sure needs cleaning up
          if( pContentVal )
          {
              pContentVal->Value <<= sal_Int32( 1 );
              xController->setValue("PageRange", pPagesVal->Value);
          }
      }
  }
  // case 2: is "All" selected ?
  else if( pContentVal )
  {
      sal_Int32 nContent = -1;
      if( pContentVal->Value >>= nContent )
      {
          if( nContent == 0 )
          {
              // do not overwrite PageRange if it is already set
              css::beans::PropertyValue* pRangeVal = xController->getValue("PageRange");
              OUString aRange;
              if( pRangeVal )
                  pRangeVal->Value >>= aRange;
              if( aRange.isEmpty() )
              {
                  sal_Int32 nPages = xController->getPageCount();
                  if( nPages > 0 )
                  {
                      OUStringBuffer aBuf( 32 );
                      aBuf.append( "1" );
                      if( nPages > 1 )
                      {
                          aBuf.append( "-" );
                          aBuf.append( nPages );
                      }
                      xController->setValue("PageRange", css::uno::makeAny(aBuf.makeStringAndClear()));
                  }
              }
          }
      }
  }

  css::beans::PropertyValue* pReverseVal = xController->getValue("PrintReverse");
  if( pReverseVal )
  {
      bool bReverse = false;
      pReverseVal->Value >>= bReverse;
      xController->setReversePrint( bReverse );
  }

  css::beans::PropertyValue* pPapersizeFromSetupVal = xController->getValue("PapersizeFromSetup");
  if( pPapersizeFromSetupVal )
  {
      bool bPapersizeFromSetup = false;
      pPapersizeFromSetupVal->Value >>= bPapersizeFromSetup;
      xController->setPapersizeFromSetup(bPapersizeFromSetup);
  }

  // setup NUp printing from properties
  sal_Int32 nRows = xController->getIntProperty("NUpRows", 1);
  sal_Int32 nCols = xController->getIntProperty("NUpColumns", 1);
  if( nRows > 1 || nCols > 1 )
  {
      PrinterController::MultiPageSetup aMPS;
      aMPS.nRows         = std::max<sal_Int32>(nRows, 1);
      aMPS.nColumns      = std::max<sal_Int32>(nCols, 1);
      sal_Int32 nValue = xController->getIntProperty("NUpPageMarginLeft", aMPS.nLeftMargin);
      if( nValue >= 0 )
          aMPS.nLeftMargin = nValue;
      nValue = xController->getIntProperty("NUpPageMarginRight", aMPS.nRightMargin);
      if( nValue >= 0 )
          aMPS.nRightMargin = nValue;
      nValue = xController->getIntProperty( "NUpPageMarginTop", aMPS.nTopMargin );
      if( nValue >= 0 )
          aMPS.nTopMargin = nValue;
      nValue = xController->getIntProperty( "NUpPageMarginBottom", aMPS.nBottomMargin );
      if( nValue >= 0 )
          aMPS.nBottomMargin = nValue;
      nValue = xController->getIntProperty( "NUpHorizontalSpacing", aMPS.nHorizontalSpacing );
      if( nValue >= 0 )
          aMPS.nHorizontalSpacing = nValue;
      nValue = xController->getIntProperty( "NUpVerticalSpacing", aMPS.nVerticalSpacing );
      if( nValue >= 0 )
          aMPS.nVerticalSpacing = nValue;
      aMPS.bDrawBorder = xController->getBoolProperty( "NUpDrawBorder", aMPS.bDrawBorder );
      aMPS.nOrder = static_cast<NupOrderType>(xController->getIntProperty( "NUpSubPageOrder", static_cast<sal_Int32>(aMPS.nOrder) ));
      aMPS.aPaperSize = xController->getPrinter()->PixelToLogic( xController->getPrinter()->GetPaperSizePixel(), MapMode( MapUnit::Map100thMM ) );
      css::beans::PropertyValue* pPgSizeVal = xController->getValue( "NUpPaperSize" );
      css::awt::Size aSizeVal;
      if( pPgSizeVal && (pPgSizeVal->Value >>= aSizeVal) )
      {
          aMPS.aPaperSize.setWidth( aSizeVal.Width );
          aMPS.aPaperSize.setHeight( aSizeVal.Height );
      }

      xController->setMultipage( aMPS );
  }

  // in direct print case check whether there is anything to print.
  // if not, show an errorbox (if appropriate)
  if( xController->isShowDialogs() && xController->isDirectPrint() )
  {
      if( xController->getFilteredPageCount() == 0 )
      {
          std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(xController->getWindow(), "vcl/ui/errornocontentdialog.ui"));
          std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("ErrorNoContentDialog"));
          xBox->run();
          return false;
      }
  }

  // check if the printer brings up its own dialog
  // in that case leave the work to that dialog
  if( ! xController->getPrinter()->GetCapabilities( PrinterCapType::ExternalDialog ) &&
      ! xController->isDirectPrint() &&
      xController->isShowDialogs()
      )
  {
      try
      {
          PrintDialog aDlg(xController->getWindow(), xController);
          if (!aDlg.run())
          {
              xController->abortJob();
              return false;
          }
          if (aDlg.isPrintToFile())
          {
              OUString aFile = queryFile( xController->getPrinter().get() );
              if( aFile.isEmpty() )
              {
                  xController->abortJob();
                  return false;
              }
              xController->setValue( "LocalFileName",
                                     css::uno::makeAny( aFile ) );
          }
          else if (aDlg.isSingleJobs())
          {
              xController->setValue( "PrintCollateAsSingleJobs",
                                      css::uno::makeAny( true ) );
          }
      }
      catch (const std::bad_alloc&)
      {
      }
  }

  xController->pushPropertiesToPrinter();
  return true;
523}

525bool Printer::ExecutePrintJob(const std::shared_ptr<PrinterController>& xController)
526{
  OUString aJobName;
  css::beans::PropertyValue* pJobNameVal = xController->getValue( "JobName" );
  if( pJobNameVal )
      pJobNameVal->Value >>= aJobName;

  return xController->getPrinter()->StartJob( aJobName, xController );
533}

535void Printer::FinishPrintJob(const std::shared_ptr<PrinterController>& xController)
536{
  xController->resetPaperToLastConfigured();
  xController->jobFinished( xController->getJobState() );
539}

541void Printer::ImplPrintJob(const std::shared_ptr<PrinterController>& xController,
                         const JobSetup& i_rInitSetup)
543{
  if (PreparePrintJob(xController, i_rInitSetup))
  {
      ExecutePrintJob(xController);
  }
  FinishPrintJob(xController);
549}

551bool Printer::StartJob( const OUString& i_rJobName, std::shared_ptr<vcl::PrinterController> const & i_xController)
552{
  mnError = ERRCODE_NONEErrCode(0);

  if ( IsDisplayPrinter() )
      return false;

  if ( IsJobActive() || IsPrinting() )
      return false;

  sal_uInt32 nCopies = mnCopyCount;
  bool    bCollateCopy = mbCollateCopy;
  bool    bUserCopy = false;

  if ( nCopies > 1 )
  {
      const sal_uInt32 nDevCopy = GetCapabilities( bCollateCopy
          ? PrinterCapType::CollateCopies
          : PrinterCapType::Copies );

      // need to do copies by hand ?
      if ( nCopies > nDevCopy )
      {
          bUserCopy = true;
          nCopies = 1;
          bCollateCopy = false;
      }
  }
  else
      bCollateCopy = false;

  ImplSVData* pSVData = ImplGetSVData();
  mpPrinter = pSVData->mpDefInst->CreatePrinter( mpInfoPrinter );

  if (!mpPrinter)
      return false;

  bool bSinglePrintJobs = false;
  css::beans::PropertyValue* pSingleValue = i_xController->getValue("PrintCollateAsSingleJobs");
  if( pSingleValue )
  {
      pSingleValue->Value >>= bSinglePrintJobs;
  }

  css::beans::PropertyValue* pFileValue = i_xController->getValue("LocalFileName");
  if( pFileValue )
  {
      OUString aFile;
      pFileValue->Value >>= aFile;
      if( !aFile.isEmpty() )
      {
          mbPrintFile = true;
          maPrintFile = aFile;
          bSinglePrintJobs = false;
      }
  }

  OUString* pPrintFile = nullptr;
  if ( mbPrintFile )
      pPrintFile = &maPrintFile;
  mpPrinterOptions->ReadFromConfig( mbPrintFile );

  mbPrinting              = true;
  if( GetCapabilities( PrinterCapType::UsePullModel ) )
  {
      mbJobActive             = true;
      // SAL layer does all necessary page printing
      // and also handles showing a dialog
      // that also means it must call jobStarted when the dialog is finished
      // it also must set the JobState of the Controller
      if( mpPrinter->StartJob( pPrintFile,
                               i_rJobName,
                               Application::GetDisplayName(),
                               &maJobSetup.ImplGetData(),
                               *i_xController) )
      {
          EndJob();
      }
      else
      {
          mnError = ImplSalPrinterErrorCodeToVCL(mpPrinter->GetErrorCode());
          if ( !mnError )
              mnError = PRINTER_GENERALERRORErrCode( ErrCodeArea::Io, ErrCodeClass::General, 13 );
          mbPrinting = false;
          mpPrinter.reset();
          mbJobActive = false;

          GDIMetaFile aDummyFile;
          i_xController->setLastPage(true);
          i_xController->getFilteredPageFile(0, aDummyFile);

          return false;
      }
  }
  else
  {
      // possibly a dialog has been shown
      // now the real job starts
      i_xController->setJobState( css::view::PrintableState_JOB_STARTED );
      i_xController->jobStarted();

      int nJobs = 1;
      int nOuterRepeatCount = 1;
      int nInnerRepeatCount = 1;
      if( bUserCopy )
      {
          if( mbCollateCopy )
              nOuterRepeatCount = mnCopyCount;
          else
              nInnerRepeatCount = mnCopyCount;
      }
      if( bSinglePrintJobs )
      {
          nJobs = mnCopyCount;
          nCopies = 1;
          nOuterRepeatCount = nInnerRepeatCount = 1;
      }

      for( int nJobIteration = 0; nJobIteration < nJobs; nJobIteration++ )
      {
          bool bError = false;
          if( mpPrinter->StartJob( pPrintFile,
                                   i_rJobName,
                                   Application::GetDisplayName(),
                                   nCopies,
                                   bCollateCopy,
                                   i_xController->isDirectPrint(),
                                   &maJobSetup.ImplGetData() ) )
          {
              bool bAborted = false;
              mbJobActive             = true;
              i_xController->createProgressDialog();
              const int nPages = i_xController->getFilteredPageCount();
              // abort job, if no pages will be printed.
              if ( nPages == 0 )
              {
                  i_xController->abortJob();
                  bAborted = true;
              }
              for( int nOuterIteration = 0; nOuterIteration < nOuterRepeatCount && ! bAborted; nOuterIteration++ )
              {
                  for( int nPage = 0; nPage < nPages && ! bAborted; nPage++ )
                  {
                      for( int nInnerIteration = 0; nInnerIteration < nInnerRepeatCount && ! bAborted; nInnerIteration++ )
                      {
                          if( nPage == nPages-1 &&
                              nOuterIteration == nOuterRepeatCount-1 &&
                              nInnerIteration == nInnerRepeatCount-1 &&
                              nJobIteration == nJobs-1 )
                          {
                              i_xController->setLastPage(true);
                          }
                          i_xController->printFilteredPage(nPage);
                          if (i_xController->isProgressCanceled())
                          {
                              i_xController->abortJob();
                          }
                          if (i_xController->getJobState() ==
                                  css::view::PrintableState_JOB_ABORTED)
                          {
                              bAborted = true;
                          }
                      }
                  }
                  // FIXME: duplex ?
              }
              EndJob();

              if( nJobIteration < nJobs-1 )
              {
                  mpPrinter = pSVData->mpDefInst->CreatePrinter( mpInfoPrinter );

                  if ( mpPrinter )
                      mbPrinting              = true;
                  else
                      bError = true;
              }
          }
          else
              bError = true;

          if( bError )
          {
              mnError = mpPrinter ? ImplSalPrinterErrorCodeToVCL(mpPrinter->GetErrorCode()) : ERRCODE_NONEErrCode(0);
              if ( !mnError )
                  mnError = PRINTER_GENERALERRORErrCode( ErrCodeArea::Io, ErrCodeClass::General, 13 );
              i_xController->setJobState( mnError == PRINTER_ABORTErrCode( ErrCodeArea::Io, ErrCodeClass::Abort, 27 )
                                          ? css::view::PrintableState_JOB_ABORTED
                                          : css::view::PrintableState_JOB_FAILED );
              mbPrinting = false;
              mpPrinter.reset();

              return false;
          }
      }

      if (i_xController->getJobState() == css::view::PrintableState_JOB_STARTED)
          i_xController->setJobState(css::view::PrintableState_JOB_SPOOLED);
  }

  // make last used printer persistent for UI jobs
  if (i_xController->isShowDialogs() && !i_xController->isDirectPrint())
  {
      SettingsConfigItem* pItem = SettingsConfigItem::get();
      pItem->setValue( "PrintDialog",
                       "LastPrinterUsed",
                       GetName()
                       );
  }

  return true;
762}

764PrinterController::~PrinterController()
765{
766}

768css::view::PrintableState PrinterController::getJobState() const
769{
  return mpImplData->meJobState;
771}

773void PrinterController::setJobState( css::view::PrintableState i_eState )
774{
  mpImplData->meJobState = i_eState;
776}

778const VclPtr<Printer>& PrinterController::getPrinter() const
779{
  return mpImplData->mxPrinter;
781}

783weld::Window* PrinterController::getWindow() const
784{
  return mpImplData->mpWindow;
786}

788void PrinterController::setPrinter( const VclPtr<Printer>& i_rPrinter )
789{
  VclPtr<Printer> xPrinter = mpImplData->mxPrinter;

  Size aPaperSize;          // Save current paper size
  Orientation eOrientation = Orientation::Portrait; // Save current paper orientation
  bool bSavedSizeOrientation = false;

  // #tdf 126744 Transfer paper size and orientation settings to newly selected printer
  if ( xPrinter )
  {
      aPaperSize = xPrinter->GetPaperSize();
      eOrientation = xPrinter->GetOrientation();
      bSavedSizeOrientation = true;
  }

  mpImplData->mxPrinter = i_rPrinter;
  setValue( "Name",
            css::uno::makeAny( i_rPrinter->GetName() ) );
  mpImplData->mnDefaultPaperBin = mpImplData->mxPrinter->GetPaperBin();
  mpImplData->mxPrinter->Push();
  mpImplData->mxPrinter->SetMapMode(MapMode(MapUnit::Map100thMM));
  mpImplData->maDefaultPageSize = mpImplData->mxPrinter->GetPaperSize();

  if ( bSavedSizeOrientation )
  {
        mpImplData->mxPrinter->SetPaperSizeUser(aPaperSize);
        mpImplData->mxPrinter->SetOrientation(eOrientation);
  }

  mpImplData->mbPapersizeFromUser = false;
  mpImplData->mxPrinter->Pop();
  mpImplData->mnFixedPaperBin = -1;
821}

823void PrinterController::resetPrinterOptions( bool i_bFileOutput )
824{
  PrinterOptions aOpt;
  aOpt.ReadFromConfig( i_bFileOutput );
  mpImplData->mxPrinter->SetPrinterOptions( aOpt );
828}

830void PrinterController::setupPrinter( weld::Window* i_pParent )
831{
  bool bRet = false;

  // Important to hold printer alive while doing setup etc.
  VclPtr< Printer > xPrinter = mpImplData->mxPrinter;
1
Calling implicit copy constructor for 'VclPtr<Printer>'→
2
←
Calling copy constructor for 'Reference<Printer>'→
5
←
Returning from copy constructor for 'Reference<Printer>'→
6
←
Returning from copy constructor for 'VclPtr<Printer>'→

  if( !xPrinter )
7
←
Taking false branch→
      return;

  xPrinter->Push();
  xPrinter->SetMapMode(MapMode(MapUnit::Map100thMM));

  // get current data
  Size aPaperSize(xPrinter->GetPaperSize());
  Orientation eOrientation = xPrinter->GetOrientation();
  sal_uInt16 nPaperBin = xPrinter->GetPaperBin();

  // reset paper size back to last configured size, not
  // whatever happens to be the current page
  // (but only if the printer config has changed, otherwise
  // don't override printer page auto-detection - tdf#91362)
  if (getPrinterModified() || getPapersizeFromSetup())
8
←
Assuming the condition is false→
9
←
Assuming the condition is false→
10
←
Taking false branch→
  {
      resetPaperToLastConfigured();
  }

  // call driver setup
  bRet = xPrinter->Setup( i_pParent, PrinterSetupMode::SingleJob );
  SAL_WARN_IF(xPrinter != mpImplData->mxPrinter, "vcl.gdi",do { if (true && (xPrinter != mpImplData->mxPrinter
)) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "vcl.gdi")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Printer changed underneath us during setup"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Printer changed underneath us during setup"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Printer changed underneath us during setup"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Printer changed underneath us during setup") == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Printer changed underneath us during setup"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Printer changed underneath us during setup"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false)
11
←
Taking false branch→
12
←
Loop condition is false.  Exiting loop→
              "Printer changed underneath us during setup")do { if (true && (xPrinter != mpImplData->mxPrinter
)) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "vcl.gdi")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Printer changed underneath us during setup"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Printer changed underneath us during setup"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Printer changed underneath us during setup"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Printer changed underneath us during setup") == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Printer changed underneath us during setup"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Printer changed underneath us during setup"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "860" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  xPrinter = mpImplData->mxPrinter;
13
←
Calling implicit copy assignment operator for 'VclPtr<Printer>'→
14
←
Calling copy assignment operator for 'Reference<Printer>'→
24
←
Returning; memory was released→
25
←
Returning; memory was released→

  Size aNewPaperSize(xPrinter->GetPaperSize());
26
←
Calling 'VclPtr::operator->'→
  if (bRet)
  {
      bool bInvalidateCache = false;
      setPapersizeFromSetup(xPrinter->GetPrinterSettingsPreferred());

      // was papersize overridden ? if so we need to take action if we're
      // configured to use the driver papersize
      if (aNewPaperSize != mpImplData->maDefaultPageSize)
      {
          mpImplData->maDefaultPageSize = aNewPaperSize;
          bInvalidateCache = getPapersizeFromSetup();
      }

      // was bin overridden ? if so we need to take action
      sal_uInt16 nNewPaperBin = xPrinter->GetPaperBin();
      if (nNewPaperBin != nPaperBin)
      {
          mpImplData->mnFixedPaperBin = nNewPaperBin;
          bInvalidateCache = true;
      }

      if (bInvalidateCache)
      {
          mpImplData->maPageCache.invalidate();
      }
  }
  else
  {
      //restore to whatever it was before we entered this method
      xPrinter->SetOrientation( eOrientation );
      if (aPaperSize != aNewPaperSize)
          xPrinter->SetPaperSizeUser(aPaperSize);
  }
  xPrinter->Pop();
898}

900PrinterController::PageSize vcl::ImplPrinterControllerData::modifyJobSetup( const css::uno::Sequence< css::beans::PropertyValue >& i_rProps )
901{
  PrinterController::PageSize aPageSize;
  aPageSize.aSize = mxPrinter->GetPaperSize();
  css::awt::Size aSetSize, aIsSize;
  sal_Int32 nPaperBin = mnDefaultPaperBin;
  for( const auto& rProp : i_rProps )
  {
      if ( rProp.Name == "PreferredPageSize" )
      {
          rProp.Value >>= aSetSize;
      }
      else if ( rProp.Name == "PageSize" )
      {
          rProp.Value >>= aIsSize;
      }
      else if ( rProp.Name == "PageIncludesNonprintableArea" )
      {
          bool bVal = false;
          rProp.Value >>= bVal;
          aPageSize.bFullPaper = bVal;
      }
      else if ( rProp.Name == "PrinterPaperTray" )
      {
          sal_Int32 nBin = -1;
          rProp.Value >>= nBin;
          if( nBin >= 0 && nBin < static_cast<sal_Int32>(mxPrinter->GetPaperBinCount()) )
              nPaperBin = nBin;
      }
  }

  Size aCurSize( mxPrinter->GetPaperSize() );
  if( aSetSize.Width && aSetSize.Height )
  {
      Size aSetPaperSize( aSetSize.Width, aSetSize.Height );
      Size aRealPaperSize( getRealPaperSize( aSetPaperSize, true/*bNoNUP*/ ) );
      if( aRealPaperSize != aCurSize )
          aIsSize = aSetSize;
  }

  if( aIsSize.Width && aIsSize.Height )
  {
      aPageSize.aSize.setWidth( aIsSize.Width );
      aPageSize.aSize.setHeight( aIsSize.Height );

      Size aRealPaperSize( getRealPaperSize( aPageSize.aSize, true/*bNoNUP*/ ) );
      if( aRealPaperSize != aCurSize )
          mxPrinter->SetPaperSizeUser( aRealPaperSize );
  }

  // paper bin set from properties in print dialog overrides
  // application default for a page
  if ( mnFixedPaperBin != -1 )
      nPaperBin = mnFixedPaperBin;

  if( nPaperBin != -1 && nPaperBin != mxPrinter->GetPaperBin() )
      mxPrinter->SetPaperBin( nPaperBin );

  return aPageSize;
959}

961//fdo#61886

963//when printing is finished, set the paper size of the printer to either what
964//the user explicitly set as the desired paper size, or fallback to whatever
965//the printer had before printing started. That way it doesn't contain the last
966//paper size of a multiple paper size using document when we are in our normal
967//auto accept document paper size mode and end up overwriting the original
968//paper size setting for file->printer_settings just by pressing "ok" in the
969//print dialog
970void vcl::ImplPrinterControllerData::resetPaperToLastConfigured()
971{
  mxPrinter->Push();
  mxPrinter->SetMapMode(MapMode(MapUnit::Map100thMM));
  Size aCurSize(mxPrinter->GetPaperSize());
  if (aCurSize != maDefaultPageSize)
      mxPrinter->SetPaperSizeUser(maDefaultPageSize);
  mxPrinter->Pop();
978}

980int PrinterController::getPageCountProtected() const
981{
  const MapMode aMapMode( MapUnit::Map100thMM );

  mpImplData->mxPrinter->Push();
  mpImplData->mxPrinter->SetMapMode( aMapMode );
  int nPages = getPageCount();
  mpImplData->mxPrinter->Pop();
  return nPages;
989}

991css::uno::Sequence< css::beans::PropertyValue > PrinterController::getPageParametersProtected( int i_nPage ) const
992{
  const MapMode aMapMode( MapUnit::Map100thMM );

  mpImplData->mxPrinter->Push();
  mpImplData->mxPrinter->SetMapMode( aMapMode );
  css::uno::Sequence< css::beans::PropertyValue > aResult( getPageParameters( i_nPage ) );
  mpImplData->mxPrinter->Pop();
  return aResult;
1000}

1002PrinterController::PageSize PrinterController::getPageFile( int i_nUnfilteredPage, GDIMetaFile& o_rMtf, bool i_bMayUseCache )
1003{
  // update progress if necessary
  if( mpImplData->mxProgress )
  {
      // do nothing if printing is canceled
      if( mpImplData->mxProgress->isCanceled() )
          return PrinterController::PageSize();
      mpImplData->mxProgress->tick();
      Application::Reschedule( true );
  }

  if( i_bMayUseCache )
  {
      PrinterController::PageSize aPageSize;
      if( mpImplData->maPageCache.get( i_nUnfilteredPage, o_rMtf, aPageSize ) )
      {
          return aPageSize;
      }
  }
  else
      mpImplData->maPageCache.invalidate();

  o_rMtf.Clear();

  // get page parameters
  css::uno::Sequence< css::beans::PropertyValue > aPageParm( getPageParametersProtected( i_nUnfilteredPage ) );
  const MapMode aMapMode( MapUnit::Map100thMM );

  mpImplData->mxPrinter->Push();
  mpImplData->mxPrinter->SetMapMode( aMapMode );

  // modify job setup if necessary
  PrinterController::PageSize aPageSize = mpImplData->modifyJobSetup( aPageParm );

  o_rMtf.SetPrefSize( aPageSize.aSize );
  o_rMtf.SetPrefMapMode( aMapMode );

  mpImplData->mxPrinter->EnableOutput( false );

  o_rMtf.Record( mpImplData->mxPrinter.get() );

  printPage( i_nUnfilteredPage );

  o_rMtf.Stop();
  o_rMtf.WindStart();
  mpImplData->mxPrinter->Pop();

  if( i_bMayUseCache )
      mpImplData->maPageCache.insert( i_nUnfilteredPage, o_rMtf, aPageSize );

  // reset "FirstPage" property to false now we've gotten at least our first one
  mpImplData->mbFirstPage = false;

  return aPageSize;
1057}

1059static void appendSubPage( GDIMetaFile& o_rMtf, const tools::Rectangle& i_rClipRect, GDIMetaFile& io_rSubPage, bool i_bDrawBorder )
1060{
  // intersect all clipregion actions with our clip rect
  io_rSubPage.WindStart();
  io_rSubPage.Clip( i_rClipRect );

  // save gstate
  o_rMtf.AddAction( new MetaPushAction( PushFlags::ALL ) );

  // clip to page rect
  o_rMtf.AddAction( new MetaClipRegionAction( vcl::Region( i_rClipRect ), true ) );

  // append the subpage
  io_rSubPage.WindStart();
  io_rSubPage.Play( o_rMtf );

  // restore gstate
  o_rMtf.AddAction( new MetaPopAction() );

  // draw a border
  if( !i_bDrawBorder )
      return;

  // save gstate
  o_rMtf.AddAction( new MetaPushAction( PushFlags::LINECOLOR | PushFlags::FILLCOLOR | PushFlags::CLIPREGION | PushFlags::MAPMODE ) );
  o_rMtf.AddAction( new MetaMapModeAction( MapMode( MapUnit::Map100thMM ) ) );

  tools::Rectangle aBorderRect( i_rClipRect );
  o_rMtf.AddAction( new MetaLineColorAction( COL_BLACK, true ) );
  o_rMtf.AddAction( new MetaFillColorAction( COL_TRANSPARENT, false ) );
  o_rMtf.AddAction( new MetaRectAction( aBorderRect ) );

  // restore gstate
  o_rMtf.AddAction( new MetaPopAction() );
1093}

1095PrinterController::PageSize PrinterController::getFilteredPageFile( int i_nFilteredPage, GDIMetaFile& o_rMtf, bool i_bMayUseCache )
1096{
  const MultiPageSetup& rMPS( mpImplData->maMultiPage );
  int nSubPages = rMPS.nRows * rMPS.nColumns;
  if( nSubPages < 1 )
      nSubPages = 1;

  // reverse sheet order
  if( mpImplData->mbReversePageOrder )
  {
      int nDocPages = getFilteredPageCount();
      i_nFilteredPage = nDocPages - 1 - i_nFilteredPage;
  }

  // there is no filtering to be done (and possibly the page size of the
  // original page is to be set), when N-Up is "neutral" that is there is
  // only one subpage and the margins are 0
  if( nSubPages == 1 &&
      rMPS.nLeftMargin == 0 && rMPS.nRightMargin == 0 &&
      rMPS.nTopMargin == 0 && rMPS.nBottomMargin == 0 )
  {
      PrinterController::PageSize aPageSize = getPageFile( i_nFilteredPage, o_rMtf, i_bMayUseCache );
      if (mpImplData->meJobState != css::view::PrintableState_JOB_STARTED)
      {   // rhbz#657394: check that we are still printing...
          return PrinterController::PageSize();
      }
      Size aPaperSize = mpImplData->getRealPaperSize( aPageSize.aSize, true );
      mpImplData->mxPrinter->SetMapMode( MapMode( MapUnit::Map100thMM ) );
      mpImplData->mxPrinter->SetPaperSizeUser( aPaperSize );
      if( aPaperSize != aPageSize.aSize )
      {
          // user overridden page size, center Metafile
          o_rMtf.WindStart();
          long nDX = (aPaperSize.Width() - aPageSize.aSize.Width()) / 2;
          long nDY = (aPaperSize.Height() - aPageSize.aSize.Height()) / 2;
          o_rMtf.Move( nDX, nDY, mpImplData->mxPrinter->GetDPIX(), mpImplData->mxPrinter->GetDPIY() );
          o_rMtf.WindStart();
          o_rMtf.SetPrefSize( aPaperSize );
          aPageSize.aSize = aPaperSize;
      }
      return aPageSize;
  }

  // set last page property really only on the very last page to be rendered
  // that is on the last subpage of a NUp run
  bool bIsLastPage = mpImplData->mbLastPage;
  mpImplData->mbLastPage = false;

  Size aPaperSize( mpImplData->getRealPaperSize( mpImplData->maMultiPage.aPaperSize, false ) );

  // multi page area: page size minus margins + one time spacing right and down
  // the added spacing is so each subpage can be calculated including its spacing
  Size aMPArea( aPaperSize );
  aMPArea.AdjustWidth( -(rMPS.nLeftMargin + rMPS.nRightMargin) );
  aMPArea.AdjustWidth(rMPS.nHorizontalSpacing );
  aMPArea.AdjustHeight( -(rMPS.nTopMargin + rMPS.nBottomMargin) );
  aMPArea.AdjustHeight(rMPS.nVerticalSpacing );

  // determine offsets
  long nAdvX = aMPArea.Width() / rMPS.nColumns;
  long nAdvY = aMPArea.Height() / rMPS.nRows;

  // determine size of a "cell" subpage, leave a little space around pages
  Size aSubPageSize( nAdvX - rMPS.nHorizontalSpacing, nAdvY - rMPS.nVerticalSpacing );

  o_rMtf.Clear();
  o_rMtf.SetPrefSize( aPaperSize );
  o_rMtf.SetPrefMapMode( MapMode( MapUnit::Map100thMM ) );
  o_rMtf.AddAction( new MetaMapModeAction( MapMode( MapUnit::Map100thMM ) ) );

  int nDocPages = getPageCountProtected();
  if (mpImplData->meJobState != css::view::PrintableState_JOB_STARTED)
  {   // rhbz#657394: check that we are still printing...
      return PrinterController::PageSize();
  }
  for( int nSubPage = 0; nSubPage < nSubPages; nSubPage++ )
  {
      // map current sub page to real page
      int nPage = i_nFilteredPage * nSubPages + nSubPage;
      if( nSubPage == nSubPages-1 ||
          nPage == nDocPages-1 )
      {
          mpImplData->mbLastPage = bIsLastPage;
      }
      if( nPage >= 0 && nPage < nDocPages )
      {
          GDIMetaFile aPageFile;
          PrinterController::PageSize aPageSize = getPageFile( nPage, aPageFile, i_bMayUseCache );
          if( aPageSize.aSize.Width() && aPageSize.aSize.Height() )
          {
              long nCellX = 0, nCellY = 0;
              switch( rMPS.nOrder )
              {
              case NupOrderType::LRTB:
                  nCellX = (nSubPage % rMPS.nColumns);
                  nCellY = (nSubPage / rMPS.nColumns);
                  break;
              case NupOrderType::TBLR:
                  nCellX = (nSubPage / rMPS.nRows);
                  nCellY = (nSubPage % rMPS.nRows);
                  break;
              case NupOrderType::RLTB:
                  nCellX = rMPS.nColumns - 1 - (nSubPage % rMPS.nColumns);
                  nCellY = (nSubPage / rMPS.nColumns);
                  break;
              case NupOrderType::TBRL:
                  nCellX = rMPS.nColumns - 1 - (nSubPage / rMPS.nRows);
                  nCellY = (nSubPage % rMPS.nRows);
                  break;
              }
              // scale the metafile down to a sub page size
              double fScaleX = double(aSubPageSize.Width())/double(aPageSize.aSize.Width());
              double fScaleY = double(aSubPageSize.Height())/double(aPageSize.aSize.Height());
              double fScale  = std::min( fScaleX, fScaleY );
              aPageFile.Scale( fScale, fScale );
              aPageFile.WindStart();

              // move the subpage so it is centered in its "cell"
              long nOffX = (aSubPageSize.Width() - long(double(aPageSize.aSize.Width()) * fScale)) / 2;
              long nOffY = (aSubPageSize.Height() - long(double(aPageSize.aSize.Height()) * fScale)) / 2;
              long nX = rMPS.nLeftMargin + nOffX + nAdvX * nCellX;
              long nY = rMPS.nTopMargin + nOffY + nAdvY * nCellY;
              aPageFile.Move( nX, nY, mpImplData->mxPrinter->GetDPIX(), mpImplData->mxPrinter->GetDPIY() );
              aPageFile.WindStart();
              // calculate border rectangle
              tools::Rectangle aSubPageRect( Point( nX, nY ),
                                      Size( long(double(aPageSize.aSize.Width())*fScale),
                                            long(double(aPageSize.aSize.Height())*fScale) ) );

              // append subpage to page
              appendSubPage( o_rMtf, aSubPageRect, aPageFile, rMPS.bDrawBorder );
          }
      }
  }
  o_rMtf.WindStart();

  // subsequent getPageFile calls have changed the paper, reset it to current value
  mpImplData->mxPrinter->SetMapMode( MapMode( MapUnit::Map100thMM ) );
  mpImplData->mxPrinter->SetPaperSizeUser( aPaperSize );

  return PrinterController::PageSize( aPaperSize, true );
1236}

1238int PrinterController::getFilteredPageCount() const
1239{
  int nDiv = mpImplData->maMultiPage.nRows * mpImplData->maMultiPage.nColumns;
  if( nDiv < 1 )
      nDiv = 1;
  return (getPageCountProtected() + (nDiv-1)) / nDiv;
1244}

1246DrawModeFlags PrinterController::removeTransparencies( GDIMetaFile const & i_rIn, GDIMetaFile& o_rOut )
1247{
  DrawModeFlags nRestoreDrawMode = mpImplData->mxPrinter->GetDrawMode();
  sal_Int32 nMaxBmpDPIX = mpImplData->mxPrinter->GetDPIX();
  sal_Int32 nMaxBmpDPIY = mpImplData->mxPrinter->GetDPIY();

  const PrinterOptions&   rPrinterOptions = mpImplData->mxPrinter->GetPrinterOptions();

  static const sal_Int32 OPTIMAL_BMP_RESOLUTION = 300;
  static const sal_Int32 NORMAL_BMP_RESOLUTION  = 200;

  if( rPrinterOptions.IsReduceBitmaps() )
  {
      // calculate maximum resolution for bitmap graphics
      if( PrinterBitmapMode::Optimal == rPrinterOptions.GetReducedBitmapMode() )
      {
          nMaxBmpDPIX = std::min( sal_Int32(OPTIMAL_BMP_RESOLUTION), nMaxBmpDPIX );
          nMaxBmpDPIY = std::min( sal_Int32(OPTIMAL_BMP_RESOLUTION), nMaxBmpDPIY );
      }
      else if( PrinterBitmapMode::Normal == rPrinterOptions.GetReducedBitmapMode() )
      {
          nMaxBmpDPIX = std::min( sal_Int32(NORMAL_BMP_RESOLUTION), nMaxBmpDPIX );
          nMaxBmpDPIY = std::min( sal_Int32(NORMAL_BMP_RESOLUTION), nMaxBmpDPIY );
      }
      else
      {
          nMaxBmpDPIX = std::min( sal_Int32(rPrinterOptions.GetReducedBitmapResolution()), nMaxBmpDPIX );
          nMaxBmpDPIY = std::min( sal_Int32(rPrinterOptions.GetReducedBitmapResolution()), nMaxBmpDPIY );
      }
  }

  // convert to greyscales
  if( rPrinterOptions.IsConvertToGreyscales() )
  {
      mpImplData->mxPrinter->SetDrawMode( mpImplData->mxPrinter->GetDrawMode() |
                                          ( DrawModeFlags::GrayLine | DrawModeFlags::GrayFill | DrawModeFlags::GrayText |
                                            DrawModeFlags::GrayBitmap | DrawModeFlags::GrayGradient ) );
  }

  // disable transparency output
  if( rPrinterOptions.IsReduceTransparency() && ( PrinterTransparencyMode::NONE == rPrinterOptions.GetReducedTransparencyMode() ) )
  {
      mpImplData->mxPrinter->SetDrawMode( mpImplData->mxPrinter->GetDrawMode() | DrawModeFlags::NoTransparency );
  }

  Color aBg( COL_TRANSPARENT ); // default: let RemoveTransparenciesFromMetaFile do its own background logic
  if( mpImplData->maMultiPage.nRows * mpImplData->maMultiPage.nColumns > 1 )
  {
      // in N-Up printing we have no "page" background operation
      // we also have no way to determine the paper color
      // so let's go for white, which will kill 99.9% of the real cases
      aBg = COL_WHITE;
  }
  mpImplData->mxPrinter->RemoveTransparenciesFromMetaFile( i_rIn, o_rOut, nMaxBmpDPIX, nMaxBmpDPIY,
                                                           rPrinterOptions.IsReduceTransparency(),
                                                           rPrinterOptions.GetReducedTransparencyMode() == PrinterTransparencyMode::Auto,
                                                           rPrinterOptions.IsReduceBitmaps() && rPrinterOptions.IsReducedBitmapIncludesTransparency(),
                                                           aBg
                                                           );
  return nRestoreDrawMode;
1306}

1308void PrinterController::printFilteredPage( int i_nPage )
1309{
  if( mpImplData->meJobState != css::view::PrintableState_JOB_STARTED )
      return; // rhbz#657394: check that we are still printing...

  GDIMetaFile aPageFile;
  PrinterController::PageSize aPageSize = getFilteredPageFile( i_nPage, aPageFile );

  if( mpImplData->mxProgress )
  {
      // do nothing if printing is canceled
      if( mpImplData->mxProgress->isCanceled() )
      {
          setJobState( css::view::PrintableState_JOB_ABORTED );
          return;
      }
  }

  // in N-Up printing set the correct page size
  mpImplData->mxPrinter->SetMapMode(MapMode(MapUnit::Map100thMM));
  // aPageSize was filtered through mpImplData->getRealPaperSize already by getFilteredPageFile()
  mpImplData->mxPrinter->SetPaperSizeUser( aPageSize.aSize );
  if( mpImplData->mnFixedPaperBin != -1 &&
      mpImplData->mxPrinter->GetPaperBin() != mpImplData->mnFixedPaperBin )
  {
      mpImplData->mxPrinter->SetPaperBin( mpImplData->mnFixedPaperBin );
  }

  // if full paper is meant to be used, move the output to accommodate for pageoffset
  if( aPageSize.bFullPaper )
  {
      Point aPageOffset( mpImplData->mxPrinter->GetPageOffset() );
      aPageFile.WindStart();
      aPageFile.Move( -aPageOffset.X(), -aPageOffset.Y(), mpImplData->mxPrinter->GetDPIX(), mpImplData->mxPrinter->GetDPIY() );
  }

  GDIMetaFile aCleanedFile;
  DrawModeFlags nRestoreDrawMode = removeTransparencies( aPageFile, aCleanedFile );

  mpImplData->mxPrinter->EnableOutput();

  // actually print the page
  mpImplData->mxPrinter->ImplStartPage();

  mpImplData->mxPrinter->Push();
  aCleanedFile.WindStart();
  aCleanedFile.Play( mpImplData->mxPrinter.get() );
  mpImplData->mxPrinter->Pop();

  mpImplData->mxPrinter->ImplEndPage();

  mpImplData->mxPrinter->SetDrawMode( nRestoreDrawMode );
1360}

1362void PrinterController::jobStarted()
1363{
1364}

1366void PrinterController::jobFinished( css::view::PrintableState )
1367{
1368}

1370void PrinterController::abortJob()
1371{
  setJobState( css::view::PrintableState_JOB_ABORTED );
  // applications (well, sw) depend on a page request with "IsLastPage" = true
  // to free resources, else they (well, sw) will crash eventually
  setLastPage( true );

  if (mpImplData->mxProgress)
  {
      mpImplData->mxProgress->response(RET_CANCEL);
      mpImplData->mxProgress.reset();
  }

  GDIMetaFile aMtf;
  getPageFile( 0, aMtf );
1385}

1387void PrinterController::setLastPage( bool i_bLastPage )
1388{
  mpImplData->mbLastPage = i_bLastPage;
1390}

1392void PrinterController::setReversePrint( bool i_bReverse )
1393{
  mpImplData->mbReversePageOrder = i_bReverse;
1395}

1397void PrinterController::setPapersizeFromSetup( bool i_bPapersizeFromSetup )
1398{
  mpImplData->mbPapersizeFromSetup = i_bPapersizeFromSetup;
  mpImplData->mxPrinter->SetPrinterSettingsPreferred( i_bPapersizeFromSetup );
  if ( i_bPapersizeFromSetup )
      mpImplData->mbPapersizeFromUser = !i_bPapersizeFromSetup;
1403}

1405bool PrinterController::getPapersizeFromSetup() const
1406{
  return mpImplData->mbPapersizeFromSetup;
1408}

1410Size& PrinterController::getPaperSizeSetup() const
1411{
  return mpImplData->maDefaultPageSize;
1413}

1415void PrinterController::setPaperSizeFromUser( Size i_aUserSize )
1416{
  mpImplData->mbPapersizeFromUser = true;
  mpImplData->mbPapersizeFromSetup = false;
  mpImplData->mxPrinter->SetPrinterSettingsPreferred( false );

  mpImplData->maUserPageSize = i_aUserSize;
1422}

1424Size& PrinterController::getPaperSizeFromUser() const
1425{
  return mpImplData->maUserPageSize;
1427}

1429bool PrinterController::isPaperSizeFromUser() const
1430{
  return mpImplData->mbPapersizeFromUser;
1432}

1434void PrinterController::setPrinterModified( bool i_bPrinterModified )
1435{
  mpImplData->mbPrinterModified = i_bPrinterModified;
1437}

1439bool PrinterController::getPrinterModified() const
1440{
  return mpImplData->mbPrinterModified;
1442}

1444css::uno::Sequence< css::beans::PropertyValue > PrinterController::getJobProperties( const css::uno::Sequence< css::beans::PropertyValue >& i_rMergeList ) const
1445{
  std::unordered_set< OUString > aMergeSet;
  size_t nResultLen = size_t(i_rMergeList.getLength()) + mpImplData->maUIProperties.size() + 3;
  for( const auto& rPropVal : i_rMergeList )
      aMergeSet.insert( rPropVal.Name );

  css::uno::Sequence< css::beans::PropertyValue > aResult( nResultLen );
  std::copy(i_rMergeList.begin(), i_rMergeList.end(), aResult.begin());
  int nCur = i_rMergeList.getLength();
  for(const css::beans::PropertyValue & rPropVal : mpImplData->maUIProperties)
  {
      if( aMergeSet.find( rPropVal.Name ) == aMergeSet.end() )
          aResult[nCur++] = rPropVal;
  }
  // append IsFirstPage
  if( aMergeSet.find( "IsFirstPage" ) == aMergeSet.end() )
  {
      css::beans::PropertyValue aVal;
      aVal.Name = "IsFirstPage";
      aVal.Value <<= mpImplData->mbFirstPage;
      aResult[nCur++] = aVal;
  }
  // append IsLastPage
  if( aMergeSet.find( "IsLastPage" ) == aMergeSet.end() )
  {
      css::beans::PropertyValue aVal;
      aVal.Name = "IsLastPage";
      aVal.Value <<= mpImplData->mbLastPage;
      aResult[nCur++] = aVal;
  }
  // append IsPrinter
  if( aMergeSet.find( "IsPrinter" ) == aMergeSet.end() )
  {
      css::beans::PropertyValue aVal;
      aVal.Name = "IsPrinter";
      aVal.Value <<= true;
      aResult[nCur++] = aVal;
  }
  aResult.realloc( nCur );
  return aResult;
1485}

1487const css::uno::Sequence< css::beans::PropertyValue >& PrinterController::getUIOptions() const
1488{
  return mpImplData->maUIOptions;
1490}

1492css::beans::PropertyValue* PrinterController::getValue( const OUString& i_rProperty )
1493{
  std::unordered_map< OUString, size_t >::const_iterator it =
      mpImplData->maPropertyToIndex.find( i_rProperty );
  return it != mpImplData->maPropertyToIndex.end() ? &mpImplData->maUIProperties[it->second] : nullptr;
1497}

1499const css::beans::PropertyValue* PrinterController::getValue( const OUString& i_rProperty ) const
1500{
  std::unordered_map< OUString, size_t >::const_iterator it =
      mpImplData->maPropertyToIndex.find( i_rProperty );
  return it != mpImplData->maPropertyToIndex.end() ? &mpImplData->maUIProperties[it->second] : nullptr;
1504}

1506void PrinterController::setValue( const OUString& i_rPropertyName, const css::uno::Any& i_rValue )
1507{
  css::beans::PropertyValue aVal;
  aVal.Name = i_rPropertyName;
  aVal.Value = i_rValue;

  setValue( aVal );
1513}

1515void PrinterController::setValue( const css::beans::PropertyValue& i_rPropertyValue )
1516{
  std::unordered_map< OUString, size_t >::const_iterator it =
      mpImplData->maPropertyToIndex.find( i_rPropertyValue.Name );
  if( it != mpImplData->maPropertyToIndex.end() )
      mpImplData->maUIProperties[ it->second ] = i_rPropertyValue;
  else
  {
      // insert correct index into property map
      mpImplData->maPropertyToIndex[ i_rPropertyValue.Name ] = mpImplData->maUIProperties.size();
      mpImplData->maUIProperties.push_back( i_rPropertyValue );
      mpImplData->maUIPropertyEnabled.push_back( true );
  }
1528}

1530void PrinterController::setUIOptions( const css::uno::Sequence< css::beans::PropertyValue >& i_rOptions )
1531{
  SAL_WARN_IF( mpImplData->maUIOptions.hasElements(), "vcl.gdi", "setUIOptions called twice !" )do { if (true && (mpImplData->maUIOptions.hasElements
())) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "vcl.gdi")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "setUIOptions called twice !"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1532" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "setUIOptions called twice !"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "setUIOptions called twice !"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1532" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "setUIOptions called twice !") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1532" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "setUIOptions called twice !"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "setUIOptions called twice !"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1532" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

  mpImplData->maUIOptions = i_rOptions;

  for( const auto& rOpt : i_rOptions )
  {
      css::uno::Sequence< css::beans::PropertyValue > aOptProp;
      rOpt.Value >>= aOptProp;
      bool bIsEnabled = true;
      bool bHaveProperty = false;
      OUString aPropName;
      vcl::ImplPrinterControllerData::ControlDependency aDep;
      css::uno::Sequence< sal_Bool > aChoicesDisabled;
      for( const css::beans::PropertyValue& rEntry : std::as_const(aOptProp) )
      {
          if ( rEntry.Name == "Property" )
          {
              css::beans::PropertyValue aVal;
              rEntry.Value >>= aVal;
              DBG_ASSERT( mpImplData->maPropertyToIndex.find( aVal.Name )do { if (true && (!(mpImplData->maPropertyToIndex.
find( aVal.Name ) == mpImplData->maPropertyToIndex.end()))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1552" ": "), "%s", "duplicate property entry"); } } while
 (false)
                          == mpImplData->maPropertyToIndex.end(), "duplicate property entry" )do { if (true && (!(mpImplData->maPropertyToIndex.
find( aVal.Name ) == mpImplData->maPropertyToIndex.end()))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1552" ": "), "%s", "duplicate property entry"); } } while
 (false);
              setValue( aVal );
              aPropName = aVal.Name;
              bHaveProperty = true;
          }
          else if ( rEntry.Name == "Enabled" )
          {
              bool bValue = true;
              rEntry.Value >>= bValue;
              bIsEnabled = bValue;
          }
          else if ( rEntry.Name == "DependsOnName" )
          {
              rEntry.Value >>= aDep.maDependsOnName;
          }
          else if ( rEntry.Name == "DependsOnEntry" )
          {
              rEntry.Value >>= aDep.mnDependsOnEntry;
          }
          else if ( rEntry.Name == "ChoicesDisabled" )
          {
              rEntry.Value >>= aChoicesDisabled;
          }
      }
      if( bHaveProperty )
      {
          vcl::ImplPrinterControllerData::PropertyToIndexMap::const_iterator it =
              mpImplData->maPropertyToIndex.find( aPropName );
          // sanity check
          if( it != mpImplData->maPropertyToIndex.end() )
          {
              mpImplData->maUIPropertyEnabled[ it->second ] = bIsEnabled;
          }
          if( !aDep.maDependsOnName.isEmpty() )
              mpImplData->maControlDependencies[ aPropName ] = aDep;
          if( aChoicesDisabled.hasElements() )
              mpImplData->maChoiceDisableMap[ aPropName ] = aChoicesDisabled;
      }
  }
1591}

1593bool PrinterController::isUIOptionEnabled( const OUString& i_rProperty ) const
1594{
  bool bEnabled = false;
  std::unordered_map< OUString, size_t >::const_iterator prop_it =
      mpImplData->maPropertyToIndex.find( i_rProperty );
  if( prop_it != mpImplData->maPropertyToIndex.end() )
  {
      bEnabled = mpImplData->maUIPropertyEnabled[prop_it->second];

      if( bEnabled )
      {
          // check control dependencies
          vcl::ImplPrinterControllerData::ControlDependencyMap::const_iterator it =
              mpImplData->maControlDependencies.find( i_rProperty );
          if( it != mpImplData->maControlDependencies.end() )
          {
              // check if the dependency is enabled
              // if the dependency is disabled, we are too
              bEnabled = isUIOptionEnabled( it->second.maDependsOnName );

              if( bEnabled )
              {
                  // does the dependency have the correct value ?
                  const css::beans::PropertyValue* pVal = getValue( it->second.maDependsOnName );
                  OSL_ENSURE( pVal, "unknown property in dependency" )do { if (true && (!(pVal))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1617" ": "), "%s", "unknown property in dependency"); }
 } while (false);
                  if( pVal )
                  {
                      sal_Int32 nDepVal = 0;
                      bool bDepVal = false;
                      if( pVal->Value >>= nDepVal )
                      {
                          bEnabled = (nDepVal == it->second.mnDependsOnEntry) || (it->second.mnDependsOnEntry == -1);
                      }
                      else if( pVal->Value >>= bDepVal )
                      {
                          // could be a dependency on a checked boolean
                          // in this case the dependency is on a non zero for checked value
                          bEnabled = (   bDepVal && it->second.mnDependsOnEntry != 0) ||
                                     ( ! bDepVal && it->second.mnDependsOnEntry == 0);
                      }
                      else
                      {
                          // if the type does not match something is awry
                          OSL_FAIL( "strange type in control dependency" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1636" ": "), "%s", "strange type in control dependency"
); } } while (false);
                          bEnabled = false;
                      }
                  }
              }
          }
      }
  }
  return bEnabled;
1645}

1647bool PrinterController::isUIChoiceEnabled( const OUString& i_rProperty, sal_Int32 i_nValue ) const
1648{
  bool bEnabled = true;
  ImplPrinterControllerData::ChoiceDisableMap::const_iterator it =
      mpImplData->maChoiceDisableMap.find( i_rProperty );
  if(it != mpImplData->maChoiceDisableMap.end() )
  {
      const css::uno::Sequence< sal_Bool >& rDisabled( it->second );
      if( i_nValue >= 0 && i_nValue < rDisabled.getLength() )
          bEnabled = ! rDisabled[i_nValue];
  }
  return bEnabled;
1659}

1661OUString PrinterController::makeEnabled( const OUString& i_rProperty )
1662{
  OUString aDependency;

  vcl::ImplPrinterControllerData::ControlDependencyMap::const_iterator it =
      mpImplData->maControlDependencies.find( i_rProperty );
  if( it != mpImplData->maControlDependencies.end() )
  {
      if( isUIOptionEnabled( it->second.maDependsOnName ) )
      {
         aDependency = it->second.maDependsOnName;
         const css::beans::PropertyValue* pVal = getValue( aDependency );
         OSL_ENSURE( pVal, "unknown property in dependency" )do { if (true && (!(pVal))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1673" ": "), "%s", "unknown property in dependency"); }
 } while (false);
         if( pVal )
         {
             sal_Int32 nDepVal = 0;
             bool bDepVal = false;
             if( pVal->Value >>= nDepVal )
             {
                 if( it->second.mnDependsOnEntry != -1 )
                 {
                     setValue( aDependency, css::uno::makeAny( sal_Int32( it->second.mnDependsOnEntry ) ) );
                 }
             }
             else if( pVal->Value >>= bDepVal )
             {
                 setValue( aDependency, css::uno::makeAny( it->second.mnDependsOnEntry != 0 ) );
             }
             else
             {
                 // if the type does not match something is awry
                 OSL_FAIL( "strange type in control dependency" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1692" ": "), "%s", "strange type in control dependency"
); } } while (false);
             }
         }
      }
  }

  return aDependency;
1699}

1701void PrinterController::createProgressDialog()
1702{
  if (!mpImplData->mxProgress)
  {
      bool bShow = true;
      css::beans::PropertyValue* pMonitor = getValue( "MonitorVisible" );
      if( pMonitor )
          pMonitor->Value >>= bShow;
      else
      {
          const css::beans::PropertyValue* pVal = getValue( "IsApi" );
          if( pVal )
          {
              bool bApi = false;
              pVal->Value >>= bApi;
              bShow = ! bApi;
          }
      }

      if( bShow && ! Application::IsHeadlessModeEnabled() )
      {
          mpImplData->mxProgress = std::make_shared<PrintProgressDialog>(getWindow(), getPageCountProtected());
          weld::DialogController::runAsync(mpImplData->mxProgress, [](sal_Int32 /*nResult*/){});
      }
  }
  else
  {
      mpImplData->mxProgress->response(RET_CANCEL);
      mpImplData->mxProgress.reset();
  }
1731}

1733bool PrinterController::isProgressCanceled() const
1734{
  return mpImplData->mxProgress && mpImplData->mxProgress->isCanceled();
1736}

1738void PrinterController::setMultipage( const MultiPageSetup& i_rMPS )
1739{
  mpImplData->maMultiPage = i_rMPS;
1741}

1743const PrinterController::MultiPageSetup& PrinterController::getMultipage() const
1744{
  return mpImplData->maMultiPage;
1746}

1748void PrinterController::resetPaperToLastConfigured()
1749{
  mpImplData->resetPaperToLastConfigured();
1751}

1753void PrinterController::pushPropertiesToPrinter()
1754{
  sal_Int32 nCopyCount = 1;
  // set copycount and collate
  const css::beans::PropertyValue* pVal = getValue( "CopyCount" );
  if( pVal )
      pVal->Value >>= nCopyCount;
  bool bCollate = false;
  pVal = getValue( "Collate" );
  if( pVal )
      pVal->Value >>= bCollate;
  mpImplData->mxPrinter->SetCopyCount( static_cast<sal_uInt16>(nCopyCount), bCollate );

  // duplex mode
  pVal = getValue( "DuplexMode" );
  if( pVal )
  {
      sal_Int16 nDuplex = css::view::DuplexMode::UNKNOWN;
      pVal->Value >>= nDuplex;
      switch( nDuplex )
      {
          case css::view::DuplexMode::OFF: mpImplData->mxPrinter->SetDuplexMode( DuplexMode::Off ); break;
          case css::view::DuplexMode::LONGEDGE: mpImplData->mxPrinter->SetDuplexMode( DuplexMode::LongEdge ); break;
          case css::view::DuplexMode::SHORTEDGE: mpImplData->mxPrinter->SetDuplexMode( DuplexMode::ShortEdge ); break;
      }
  }
1779}

1781bool PrinterController::isShowDialogs() const
1782{
  bool bApi = getBoolProperty( "IsApi", false );
  return ! bApi && ! Application::IsHeadlessModeEnabled();
1785}

1787bool PrinterController::isDirectPrint() const
1788{
  bool bDirect = getBoolProperty( "IsDirect", false );
  return bDirect;
1791}

1793bool PrinterController::getBoolProperty( const OUString& i_rProperty, bool i_bFallback ) const
1794{
  bool bRet = i_bFallback;
  const css::beans::PropertyValue* pVal = getValue( i_rProperty );
  if( pVal )
      pVal->Value >>= bRet;
  return bRet;
1800}

1802sal_Int32 PrinterController::getIntProperty( const OUString& i_rProperty, sal_Int32 i_nFallback ) const
1803{
  sal_Int32 nRet = i_nFallback;
  const css::beans::PropertyValue* pVal = getValue( i_rProperty );
  if( pVal )
      pVal->Value >>= nRet;
  return nRet;
1809}

1811/*
* PrinterOptionsHelper
1813**/
1814css::uno::Any PrinterOptionsHelper::getValue( const OUString& i_rPropertyName ) const
1815{
  css::uno::Any aRet;
  std::unordered_map< OUString, css::uno::Any >::const_iterator it =
      m_aPropertyMap.find( i_rPropertyName );
  if( it != m_aPropertyMap.end() )
      aRet = it->second;
  return aRet;
1822}

1824bool PrinterOptionsHelper::getBoolValue( const OUString& i_rPropertyName, bool i_bDefault ) const
1825{
  bool bRet = false;
  css::uno::Any aVal( getValue( i_rPropertyName ) );
  return (aVal >>= bRet) ? bRet : i_bDefault;
1829}

1831sal_Int64 PrinterOptionsHelper::getIntValue( const OUString& i_rPropertyName, sal_Int64 i_nDefault ) const
1832{
  sal_Int64 nRet = 0;
  css::uno::Any aVal( getValue( i_rPropertyName ) );
  return (aVal >>= nRet) ? nRet : i_nDefault;
1836}

1838OUString PrinterOptionsHelper::getStringValue( const OUString& i_rPropertyName ) const
1839{
  OUString aRet;
  css::uno::Any aVal( getValue( i_rPropertyName ) );
  return (aVal >>= aRet) ? aRet : OUString();
1843}

1845bool PrinterOptionsHelper::processProperties( const css::uno::Sequence< css::beans::PropertyValue >& i_rNewProp )
1846{
  bool bChanged = false;

  for( const auto& rVal : i_rNewProp )
  {
      std::unordered_map< OUString, css::uno::Any >::iterator it =
          m_aPropertyMap.find( rVal.Name );

      bool bElementChanged = (it == m_aPropertyMap.end()) || (it->second != rVal.Value);
      if( bElementChanged )
      {
          m_aPropertyMap[ rVal.Name ] = rVal.Value;
          bChanged = true;
      }
  }
  return bChanged;
1862}

1864void PrinterOptionsHelper::appendPrintUIOptions( css::uno::Sequence< css::beans::PropertyValue >& io_rProps ) const
1865{
  if( !m_aUIProperties.empty() )
  {
      sal_Int32 nIndex = io_rProps.getLength();
      io_rProps.realloc( nIndex+1 );
      css::beans::PropertyValue aVal;
      aVal.Name = "ExtraPrintUIOptions";
      aVal.Value <<= comphelper::containerToSequence(m_aUIProperties);
      io_rProps[ nIndex ] = aVal;
  }
1875}

1877css::uno::Any PrinterOptionsHelper::setUIControlOpt(const css::uno::Sequence< OUString >& i_rIDs,
                                        const OUString& i_rTitle,
                                        const css::uno::Sequence< OUString >& i_rHelpIds,
                                        const OUString& i_rType,
                                        const css::beans::PropertyValue* i_pVal,
                                        const PrinterOptionsHelper::UIControlOptions& i_rControlOptions)
1883{
  sal_Int32 nElements =
      2                                                             // ControlType + ID
      + (i_rTitle.isEmpty() ? 0 : 1)                                // Text
      + (i_rHelpIds.hasElements() ? 1 : 0)                          // HelpId
      + (i_pVal ? 1 : 0)                                            // Property
      + i_rControlOptions.maAddProps.size()                         // additional props
      + (i_rControlOptions.maGroupHint.isEmpty() ? 0 : 1)           // grouping
      + (i_rControlOptions.mbInternalOnly ? 1 : 0)                  // internal hint
      + (i_rControlOptions.mbEnabled ? 0 : 1)                       // enabled
      ;
  if( !i_rControlOptions.maDependsOnName.isEmpty() )
  {
      nElements += 1;
      if( i_rControlOptions.mnDependsOnEntry != -1 )
          nElements += 1;
      if( i_rControlOptions.mbAttachToDependency )
          nElements += 1;
  }

  css::uno::Sequence< css::beans::PropertyValue > aCtrl( nElements );
  sal_Int32 nUsed = 0;
  if( !i_rTitle.isEmpty() )
  {
      aCtrl[nUsed  ].Name  = "Text";
      aCtrl[nUsed++].Value <<= i_rTitle;
  }
  if( i_rHelpIds.hasElements() )
  {
      aCtrl[nUsed  ].Name = "HelpId";
      aCtrl[nUsed++].Value <<= i_rHelpIds;
  }
  aCtrl[nUsed  ].Name  = "ControlType";
  aCtrl[nUsed++].Value <<= i_rType;
  aCtrl[nUsed  ].Name  = "ID";
  aCtrl[nUsed++].Value <<= i_rIDs;
  if( i_pVal )
  {
      aCtrl[nUsed  ].Name  = "Property";
      aCtrl[nUsed++].Value <<= *i_pVal;
  }
  if( !i_rControlOptions.maDependsOnName.isEmpty() )
  {
      aCtrl[nUsed  ].Name  = "DependsOnName";
      aCtrl[nUsed++].Value <<= i_rControlOptions.maDependsOnName;
      if( i_rControlOptions.mnDependsOnEntry != -1 )
      {
          aCtrl[nUsed  ].Name  = "DependsOnEntry";
          aCtrl[nUsed++].Value <<= i_rControlOptions.mnDependsOnEntry;
      }
      if( i_rControlOptions.mbAttachToDependency )
      {
          aCtrl[nUsed  ].Name  = "AttachToDependency";
          aCtrl[nUsed++].Value <<= i_rControlOptions.mbAttachToDependency;
      }
  }
  if( !i_rControlOptions.maGroupHint.isEmpty() )
  {
      aCtrl[nUsed  ].Name    = "GroupingHint";
      aCtrl[nUsed++].Value <<= i_rControlOptions.maGroupHint;
  }
  if( i_rControlOptions.mbInternalOnly )
  {
      aCtrl[nUsed  ].Name    = "InternalUIOnly";
      aCtrl[nUsed++].Value <<= true;
  }
  if( ! i_rControlOptions.mbEnabled )
  {
      aCtrl[nUsed  ].Name    = "Enabled";
      aCtrl[nUsed++].Value <<= false;
  }

  sal_Int32 nAddProps = i_rControlOptions.maAddProps.size();
  for( sal_Int32 i = 0; i < nAddProps; i++ )
      aCtrl[ nUsed++ ] = i_rControlOptions.maAddProps[i];

  SAL_WARN_IF( nUsed != nElements, "vcl.gdi", "nUsed != nElements, probable heap corruption" )do { if (true && (nUsed != nElements)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "vcl.gdi")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "nUsed != nElements, probable heap corruption"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1959" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "nUsed != nElements, probable heap corruption"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "nUsed != nElements, probable heap corruption"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1959" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "nUsed != nElements, probable heap corruption") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"
), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1959" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "nUsed != nElements, probable heap corruption"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "nUsed != nElements, probable heap corruption"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("vcl.gdi"), ("/home/maarten/src/libreoffice/core/vcl/source/gdi/print3.cxx"
 ":" "1959" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

  return css::uno::makeAny( aCtrl );
1962}

1964css::uno::Any PrinterOptionsHelper::setGroupControlOpt(const OUString& i_rID,
                                           const OUString& i_rTitle,
                                           const OUString& i_rHelpId)
1967{
  css::uno::Sequence< OUString > aHelpId;
  if( !i_rHelpId.isEmpty() )
  {
      aHelpId.realloc( 1 );
      *aHelpId.getArray() = i_rHelpId;
  }
  css::uno::Sequence< OUString > aIds { i_rID };
  return setUIControlOpt(aIds, i_rTitle, aHelpId, "Group");
1976}

1978css::uno::Any PrinterOptionsHelper::setSubgroupControlOpt(const OUString& i_rID,
                                              const OUString& i_rTitle,
                                              const OUString& i_rHelpId,
                                              const PrinterOptionsHelper::UIControlOptions& i_rControlOptions)
1982{
  css::uno::Sequence< OUString > aHelpId;
  if( !i_rHelpId.isEmpty() )
  {
      aHelpId.realloc( 1 );
      *aHelpId.getArray() = i_rHelpId;
  }
  css::uno::Sequence< OUString > aIds { i_rID };
  return setUIControlOpt(aIds, i_rTitle, aHelpId, "Subgroup", nullptr, i_rControlOptions);
1991}

1993css::uno::Any PrinterOptionsHelper::setBoolControlOpt(const OUString& i_rID,
                                          const OUString& i_rTitle,
                                          const OUString& i_rHelpId,
                                          const OUString& i_rProperty,
                                          bool i_bValue,
                                          const PrinterOptionsHelper::UIControlOptions& i_rControlOptions)
1999{
  css::uno::Sequence< OUString > aHelpId;
  if( !i_rHelpId.isEmpty() )
  {
      aHelpId.realloc( 1 );
      *aHelpId.getArray() = i_rHelpId;
  }
  css::beans::PropertyValue aVal;
  aVal.Name = i_rProperty;
  aVal.Value <<= i_bValue;
  css::uno::Sequence< OUString > aIds { i_rID };
  return setUIControlOpt(aIds, i_rTitle, aHelpId, "Bool", &aVal, i_rControlOptions);
2011}

2013css::uno::Any PrinterOptionsHelper::setChoiceRadiosControlOpt(const css::uno::Sequence< OUString >& i_rIDs,
                                            const OUString& i_rTitle,
                                            const css::uno::Sequence< OUString >& i_rHelpId,
                                            const OUString& i_rProperty,
                                            const css::uno::Sequence< OUString >& i_rChoices,
                                            sal_Int32 i_nValue,
                                            const css::uno::Sequence< sal_Bool >& i_rDisabledChoices,
                                            const PrinterOptionsHelper::UIControlOptions& i_rControlOptions)
2021{
  UIControlOptions aOpt( i_rControlOptions );
  sal_Int32 nUsed = aOpt.maAddProps.size();
  aOpt.maAddProps.resize( nUsed + 1 + (i_rDisabledChoices.hasElements() ? 1 : 0) );
  aOpt.maAddProps[nUsed].Name = "Choices";
  aOpt.maAddProps[nUsed].Value <<= i_rChoices;
  if( i_rDisabledChoices.hasElements() )
  {
      aOpt.maAddProps[nUsed+1].Name = "ChoicesDisabled";
      aOpt.maAddProps[nUsed+1].Value <<= i_rDisabledChoices;
  }

  css::beans::PropertyValue aVal;
  aVal.Name = i_rProperty;
  aVal.Value <<= i_nValue;
  return setUIControlOpt(i_rIDs, i_rTitle, i_rHelpId, "Radio", &aVal, aOpt);
2037}

2039css::uno::Any PrinterOptionsHelper::setChoiceListControlOpt(const OUString& i_rID,
                                            const OUString& i_rTitle,
                                            const css::uno::Sequence< OUString >& i_rHelpId,
                                            const OUString& i_rProperty,
                                            const css::uno::Sequence< OUString >& i_rChoices,
                                            sal_Int32 i_nValue,
                                            const css::uno::Sequence< sal_Bool >& i_rDisabledChoices,
                                            const PrinterOptionsHelper::UIControlOptions& i_rControlOptions)
2047{
  UIControlOptions aOpt( i_rControlOptions );
  sal_Int32 nUsed = aOpt.maAddProps.size();
  aOpt.maAddProps.resize( nUsed + 1 + (i_rDisabledChoices.hasElements() ? 1 : 0) );
  aOpt.maAddProps[nUsed].Name = "Choices";
  aOpt.maAddProps[nUsed].Value <<= i_rChoices;
  if( i_rDisabledChoices.hasElements() )
  {
      aOpt.maAddProps[nUsed+1].Name = "ChoicesDisabled";
      aOpt.maAddProps[nUsed+1].Value <<= i_rDisabledChoices;
  }

  css::beans::PropertyValue aVal;
  aVal.Name = i_rProperty;
  aVal.Value <<= i_nValue;
  css::uno::Sequence< OUString > aIds { i_rID };
  return setUIControlOpt(aIds, i_rTitle, i_rHelpId, "List", &aVal, aOpt);
2064}

2066css::uno::Any PrinterOptionsHelper::setRangeControlOpt(const OUString& i_rID,
                                           const OUString& i_rTitle,
                                           const OUString& i_rHelpId,
                                           const OUString& i_rProperty,
                                           sal_Int32 i_nValue,
                                           sal_Int32 i_nMinValue,
                                           sal_Int32 i_nMaxValue,
                                           const PrinterOptionsHelper::UIControlOptions& i_rControlOptions)
2074{
  UIControlOptions aOpt( i_rControlOptions );
  if( i_nMaxValue >= i_nMinValue )
  {
      sal_Int32 nUsed = aOpt.maAddProps.size();
      aOpt.maAddProps.resize( nUsed + 2 );
      aOpt.maAddProps[nUsed  ].Name  = "MinValue";
      aOpt.maAddProps[nUsed++].Value <<= i_nMinValue;
      aOpt.maAddProps[nUsed  ].Name  = "MaxValue";
      aOpt.maAddProps[nUsed++].Value <<= i_nMaxValue;
  }

  css::uno::Sequence< OUString > aHelpId;
  if( !i_rHelpId.isEmpty() )
  {
      aHelpId.realloc( 1 );
      *aHelpId.getArray() = i_rHelpId;
  }
  css::beans::PropertyValue aVal;
  aVal.Name = i_rProperty;
  aVal.Value <<= i_nValue;
  css::uno::Sequence< OUString > aIds { i_rID };
  return setUIControlOpt(aIds, i_rTitle, aHelpId, "Range", &aVal, aOpt);
2097}

2099css::uno::Any PrinterOptionsHelper::setEditControlOpt(const OUString& i_rID,
                                          const OUString& i_rTitle,
                                          const OUString& i_rHelpId,
                                          const OUString& i_rProperty,
                                          const OUString& i_rValue,
                                          const PrinterOptionsHelper::UIControlOptions& i_rControlOptions)
2105{
  css::uno::Sequence< OUString > aHelpId;
  if( !i_rHelpId.isEmpty() )
  {
      aHelpId.realloc( 1 );
      *aHelpId.getArray() = i_rHelpId;
  }
  css::beans::PropertyValue aVal;
  aVal.Name = i_rProperty;
  aVal.Value <<= i_rValue;
  css::uno::Sequence< OUString > aIds { i_rID };
  return setUIControlOpt(aIds, i_rTitle, aHelpId, "Edit", &aVal, i_rControlOptions);
2117}

2119/* 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_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
3
←
Assuming field 'm_pBody' is non-null→
4
←
Taking true branch→
          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 (pBody15.1
'pBody' is non-null
1
'pBody' is non-null
1
'pBody' is non-null
1
'pBody' is non-null
)
16
←
Taking true branch→
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld16.1
'pOld' is non-null
1
'pOld' is non-null
1
'pOld' is non-null
1
'pOld' is non-null
)
17
←
Taking true branch→
          pOld->release();
18
←
Calling 'VclReferenceBase::release'→
22
←
Returning; memory was released→
      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 );
15
←
Calling 'Reference::set'→
23
←
Returning; memory was released via 1st parameter→
  }

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;
28
←
Use of memory after it is freed
  }


  /** 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/vcl/vclreferencebase.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#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
19
←
Assuming the condition is true→
20
←
Taking true branch→
40            delete this;
21
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif

←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.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_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** 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 >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
27
←
Calling 'Reference::get'→
  }

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

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
      if (aTmp.get()) {
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** 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 >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

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