/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * 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 .

 */

#include <sal/types.h>

#include <sal/log.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/sequence.hxx>

#include <o3tl/safeint.hxx>

#include <officecfg/VCL.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <tools/debug.hxx>

#include <tools/mapunit.hxx>

#include <tools/urlobj.hxx>

#include <utility>

#include <vcl/metaact.hxx>

#include <vcl/print.hxx>

#include <vcl/printer/Options.hxx>

#include <vcl/rendercontext/DrawModeFlags.hxx>

#include <vcl/svapp.hxx>

#include <vcl/weld/Builder.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <printdlg.hxx>

#include <salinst.hxx>

#include <salprn.hxx>

#include <strings.hrc>

#include <svdata.hxx>

#include <com/sun/star/awt/Size.hpp>

#include <com/sun/star/lang/IllegalArgumentException.hpp>

#include <com/sun/star/ui/dialogs/FilePicker.hpp>

#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>

#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>

#include <com/sun/star/view/DuplexMode.hpp>

#include <com/sun/star/view/PaperOrientation.hpp>

#include <com/sun/star/view/PrintableState.hpp>

#include <unordered_map>

#include <unordered_set>

#ifdef MACOSX

#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>

#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>

#endif

using namespace vcl;

namespace {

class ImplPageCache

{

    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;

        }

    }

public:

    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;

        }

    }

};

}

class vcl::ImplPrinterControllerData

{

public:

    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                                                        mbOrientationFromUser;

    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 print dialog

    Orientation                                                 meUserOrientation;

    // 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 ),

        mbOrientationFromUser( false ),

        mbPrinterModified( false ),

        meJobState( css::view::PrintableState_JOB_STARTED ),

        meUserOrientation( Orientation::Portrait ),

        mnDefaultPaperBin( -1 ),

        mnFixedPaperBin( -1 )

    {}

    ~ImplPrinterControllerData()

    {

        if (mxProgress)

        {

            mxProgress->response(RET_CANCEL);

            mxProgress.reset();

        }

    }

    Size getRealPaperSize( const Size& i_rPageSize, bool bNoNUP ) const

    {

        Size size;

        if ( mbPapersizeFromUser )

            size = maUserPageSize;

        else if( mbPapersizeFromSetup )

            size =  maDefaultPageSize;

        else if( maMultiPage.nRows * maMultiPage.nColumns > 1 && ! bNoNUP )

            size = maMultiPage.aPaperSize;

        else

            size = i_rPageSize;

        bool bSwap = false;

        const bool bSizeIsLandscape = size.Width() > size.Height();

        if(mbOrientationFromUser)

        {

            bSwap = (bSizeIsLandscape && Orientation::Portrait == meUserOrientation)

                    || (!bSizeIsLandscape && Orientation::Landscape == meUserOrientation);

        }

        else if (mbPapersizeFromUser || mbPapersizeFromSetup) // automatic orientation

        {

            const bool bDocumentPageIsLandscape = i_rPageSize.Width() > i_rPageSize.Height();

            bSwap = bDocumentPageIsLandscape != bSizeIsLandscape;

        }

        if (bSwap)

        {

            // coverity[swapped_arguments : FALSE] - this is in the correct order

            size = Size(size.Height(), size.Width());

        }

        return size;

    }

    PrinterController::PageSize modifyJobSetup( const css::uno::Sequence< css::beans::PropertyValue >& i_rProps );

    void resetPaperToLastConfigured();

};

PrinterController::PrinterController(const VclPtr<Printer>& i_xPrinter, weld::Window* i_pWindow)

    : mpImplData( new ImplPrinterControllerData )

{

    mpImplData->mxPrinter = i_xPrinter;

    mpImplData->mpWindow = i_pWindow;

}

static OUString queryFile( Printer const * pPrinter, const OUString & rJobName )

{

    OUString aResult;

    const 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

    {

#ifdef MACOSX

        // Try to mimic the save dialog behavior when using the native

        // print dialog to save to PDF.

        if( pPrinter )

        {

            // Set the suggested file name if possible

            if( !rJobName.isEmpty() )

                xFilePicker->setDefaultName( rJobName );

            // macOS normally saves only to PDF

            if( pPrinter->GetCapabilities( PrinterCapType::PDF ) )

            {

                xFilePicker->appendFilter( u"Portable Document Format"_ustr, u"*.pdf"_ustr );

                css::uno::Reference< css::ui::dialogs::XFilePickerControlAccess > xControlAccess( xFilePicker, css::uno::UNO_QUERY );

                if( xControlAccess.is() )

                    xControlAccess->setValue( css::ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0, css::uno::Any( true ) );

            }

        }

#else

        (void)rJobName;

#ifdef UNX

        // 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( u"PostScript"_ustr, u"*.ps"_ustr );

        if( bPDF )

            xFilePicker->appendFilter( u"Portable Document Format"_ustr, u"*.pdf"_ustr );

#elif defined _WIN32

        (void)pPrinter;

        xFilePicker->appendFilter( "*.PRN", "*.prn" );

#endif

        // add arbitrary files

        xFilePicker->appendFilter(VclResId(SV_STDTEXT_ALLFILETYPES), u"*.*"_ustr);

#endif

    }

    catch (const css::lang::IllegalArgumentException&)

    {

        TOOLS_WARN_EXCEPTION( "vcl.gdi", "caught IllegalArgumentException when registering filter" );

    }

    if( xFilePicker->execute() == css::ui::dialogs::ExecutableDialogResults::OK )

    {

        css::uno::Sequence< OUString > aPathSeq( xFilePicker->getSelectedFiles() );

        INetURLObject aObj( aPathSeq[0] );

        aResult = aObj.PathToFileName();

    }

    return aResult;

}

namespace {

struct PrintJobAsync

{

    std::shared_ptr<PrinterController>  mxController;

    JobSetup                            maInitSetup;

    PrintJobAsync(std::shared_ptr<PrinterController>  i_xController,

                  const JobSetup& i_rInitSetup)

    : mxController(std::move( i_xController )), maInitSetup( i_rInitSetup )

    {}

    DECL_LINK( ExecJob, void*, void );

};

}

IMPL_LINK_NOARG(PrintJobAsync, ExecJob, void*, void)

{

    Printer::ImplPrintJob(mxController, maInitSetup);

    // clean up, do not access members after this

    delete this;

}

void Printer::PrintJob(const std::shared_ptr<PrinterController>& i_xController,

                       const JobSetup& i_rInitSetup)

{

    bool bSynchronous = false;

    css::beans::PropertyValue* pVal = i_xController->getValue( u"Wait"_ustr );

    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 ) );

    }

}

bool Printer::PreparePrintJob(std::shared_ptr<PrinterController> xController,

                           const JobSetup& i_rInitSetup)

{

    Printer::updatePrinters();

    // 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(), u"vcl/ui/errornoprinterdialog.ui"_ustr));

            std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog(u"ErrorNoPrinterDialog"_ustr));

            xBox->run();

        }

        xController->setValue( u"IsDirect"_ustr,

                               css::uno::Any( 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(u"PrintRange"_ustr);

    if( ! pContentVal )

        pContentVal = xController->getValue(u"PrintContent"_ustr);

    // case 1: UNO API has set "Pages"

    css::beans::PropertyValue* pPagesVal = xController->getValue(u"Pages"_ustr);

    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(u"PageRange"_ustr, 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(u"PageRange"_ustr);

                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( "-" + OUString::number( nPages ) );

                        }

                        xController->setValue(u"PageRange"_ustr, css::uno::Any(aBuf.makeStringAndClear()));

                    }

                }

            }

        }

    }

    css::beans::PropertyValue* pReverseVal = xController->getValue(u"PrintReverse"_ustr);

    if( pReverseVal )

    {

        bool bReverse = false;

        pReverseVal->Value >>= bReverse;

        xController->setReversePrint( bReverse );

    }

    css::beans::PropertyValue* pPapersizeFromSetupVal = xController->getValue(u"PapersizeFromSetup"_ustr);

    if( pPapersizeFromSetupVal )

    {

        bool bPapersizeFromSetup = false;

        pPapersizeFromSetupVal->Value >>= bPapersizeFromSetup;

        xController->setPapersizeFromSetup(bPapersizeFromSetup);

    }

    // setup NUp printing from properties

    sal_Int32 nRows = xController->getIntProperty(u"NUpRows"_ustr, 1);

    sal_Int32 nCols = xController->getIntProperty(u"NUpColumns"_ustr, 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(u"NUpPageMarginLeft"_ustr, aMPS.nLeftMargin);

        if( nValue >= 0 )

            aMPS.nLeftMargin = nValue;

        nValue = xController->getIntProperty(u"NUpPageMarginRight"_ustr, aMPS.nRightMargin);

        if( nValue >= 0 )

            aMPS.nRightMargin = nValue;

        nValue = xController->getIntProperty( u"NUpPageMarginTop"_ustr, aMPS.nTopMargin );

        if( nValue >= 0 )

            aMPS.nTopMargin = nValue;

        nValue = xController->getIntProperty( u"NUpPageMarginBottom"_ustr, aMPS.nBottomMargin );

        if( nValue >= 0 )

            aMPS.nBottomMargin = nValue;

        nValue = xController->getIntProperty( u"NUpHorizontalSpacing"_ustr, aMPS.nHorizontalSpacing );

        if( nValue >= 0 )

            aMPS.nHorizontalSpacing = nValue;

        nValue = xController->getIntProperty( u"NUpVerticalSpacing"_ustr, aMPS.nVerticalSpacing );

        if( nValue >= 0 )

            aMPS.nVerticalSpacing = nValue;

        aMPS.bDrawBorder = xController->getBoolProperty( u"NUpDrawBorder"_ustr, aMPS.bDrawBorder );

        aMPS.nOrder = static_cast<NupOrderType>(xController->getIntProperty( u"NUpSubPageOrder"_ustr, static_cast<sal_Int32>(aMPS.nOrder) ));

        aMPS.aPaperSize = xController->getPrinter()->PixelToLogic( xController->getPrinter()->GetPaperSizePixel(), MapMode( MapUnit::Map100thMM ) );

        css::beans::PropertyValue* pPgSizeVal = xController->getValue( u"NUpPaperSize"_ustr );

        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(), u"vcl/ui/errornocontentdialog.ui"_ustr));

            std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog(u"ErrorNoContentDialog"_ustr));

            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 aJobName;

                css::beans::PropertyValue* pJobNameVal = xController->getValue( u"JobName"_ustr );

                if( pJobNameVal )

                    pJobNameVal->Value >>= aJobName;

                OUString aFile = queryFile( xController->getPrinter().get(), aJobName );

                if( aFile.isEmpty() )

                {

                    xController->abortJob();

                    return false;

                }

                xController->setValue( u"LocalFileName"_ustr,

                                       css::uno::Any( aFile ) );

            }

            else if (aDlg.isSingleJobs())

            {

                xController->getPrinter()->SetSinglePrintJobs(true);

            }

        }

        catch (const std::bad_alloc&)

        {

        }

    }

    xController->pushPropertiesToPrinter();

    return true;

}

bool Printer::ExecutePrintJob(const std::shared_ptr<PrinterController>& xController)

{

    OUString aJobName;

    css::beans::PropertyValue* pJobNameVal = xController->getValue( u"JobName"_ustr );

    if( pJobNameVal )

        pJobNameVal->Value >>= aJobName;

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

}

void Printer::FinishPrintJob(const std::shared_ptr<PrinterController>& xController)

{

    xController->resetPaperToLastConfigured();

    xController->jobFinished( xController->getJobState() );

}

void Printer::ImplPrintJob(const std::shared_ptr<PrinterController>& xController,

                           const JobSetup& i_rInitSetup)

{

    if (PreparePrintJob(xController, i_rInitSetup))

    {

        ExecutePrintJob(xController);

    }

    FinishPrintJob(xController);

}

bool Printer::StartJob( const OUString& i_rJobName, std::shared_ptr<vcl::PrinterController> const & i_xController)

{

    mnError = ERRCODE_NONE;

    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;

    SalInstance* pSalInstance = GetSalInstance();

    mpPrinter = pSalInstance->CreatePrinter( mpInfoPrinter );

    if (!mpPrinter)

        return false;

    bool bSinglePrintJobs = i_xController->getPrinter()->IsSinglePrintJobs();

    css::beans::PropertyValue* pFileValue = i_xController->getValue(u"LocalFileName"_ustr);

    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_GENERALERROR;

            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 = pSalInstance->CreatePrinter(mpInfoPrinter);

                    if ( mpPrinter )

                        mbPrinting              = true;

                    else

                        bError = true;

                }

            }

            else

                bError = true;

            if( bError )

            {

                mnError = mpPrinter ? ImplSalPrinterErrorCodeToVCL(mpPrinter->GetErrorCode()) : ERRCODE_NONE;

                if ( !mnError )

                    mnError = PRINTER_GENERALERROR;

                i_xController->setJobState( mnError == PRINTER_ABORT

                                            ? 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())

    {

        std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());

        officecfg::VCL::VCLSettings::PrintDialog::LastPrinter::set( GetName(), batch );

        batch->commit();

    }

    return true;

}

PrinterController::~PrinterController()

{

}

css::view::PrintableState PrinterController::getJobState() const

{

    return mpImplData->meJobState;

}

void PrinterController::setJobState( css::view::PrintableState i_eState )

{

    mpImplData->meJobState = i_eState;

}

const VclPtr<Printer>& PrinterController::getPrinter() const

{

    return mpImplData->mxPrinter;

}

weld::Window* PrinterController::getWindow() const

{

    return mpImplData->mpWindow;

}

void PrinterController::dialogsParentClosing()

{

    mpImplData->mpWindow = nullptr;

    if (mpImplData->mxProgress)

    {

        // close the dialog without doing anything, just get rid of it

        mpImplData->mxProgress->response(RET_OK);

        mpImplData->mxProgress.reset();

    }

}

void PrinterController::setPrinter( const VclPtr<Printer>& i_rPrinter )

{

    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 )

    {

        // GetSizeOfPaper() — stable 1/100th mm, avoids PixelToLogic issues.

        aPaperSize = xPrinter->GetSizeOfPaper();

        eOrientation = xPrinter->GetOrientation();

        bSavedSizeOrientation = true;

    }

    mpImplData->mxPrinter = i_rPrinter;

    setValue( u"Name"_ustr,

              css::uno::Any( i_rPrinter->GetName() ) );

    mpImplData->mnDefaultPaperBin = mpImplData->mxPrinter->GetPaperBin();

    mpImplData->maDefaultPageSize = mpImplData->mxPrinter->GetSizeOfPaper();

    if ( bSavedSizeOrientation )

    {

        // SetPaperSizeUser needs logical units; aPaperSize is in 1/100th mm.

        auto popIt = mpImplData->mxPrinter->ScopedPush();

        mpImplData->mxPrinter->SetMapMode(MapMode(MapUnit::Map100thMM));

        mpImplData->mxPrinter->SetPaperSizeUser(aPaperSize);

        mpImplData->mxPrinter->SetOrientation(eOrientation);

    }

    mpImplData->mbPapersizeFromUser = false;

    mpImplData->mbOrientationFromUser = false;

    mpImplData->mnFixedPaperBin = -1;

}

void PrinterController::resetPrinterOptions( bool i_bFileOutput )

{

    vcl::printer::Options aOpt;

    aOpt.ReadFromConfig( i_bFileOutput );

    mpImplData->mxPrinter->SetPrinterOptions( aOpt );

}

void PrinterController::invalidatePageCache()

{

    mpImplData->maPageCache.invalidate();

}

void PrinterController::setupPrinter( weld::Window* i_pParent )

{

    bool bRet = false;