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

/*

 * 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 <o3tl/safeint.hxx>

#include <sal/log.hxx>

#include <osl/diagnose.h>

#include <rtl/ustrbuf.hxx>

#include <tools/mapunit.hxx>

#include <unotools/localedatawrapper.hxx>

#include <officecfg/Office/Common.hxx>

#include <officecfg/VCL.hxx>

#include <utility>

#include <vcl/QueueInfo.hxx>

#include <vcl/commandevent.hxx>

#include <vcl/decoview.hxx>

#include <vcl/help.hxx>

#include <vcl/naturalsort.hxx>

#include <vcl/print.hxx>

#include <vcl/printer/Options.hxx>

#include <vcl/PrinterSupport.hxx>

#include <vcl/rendercontext/DrawModeFlags.hxx>

#include <vcl/settings.hxx>

#include <vcl/svapp.hxx>

#include <vcl/virdev.hxx>

#include <vcl/wall.hxx>

#include <vcl/weld/Builder.hxx>

#include <vcl/weld/Dialog.hxx>

#include <vcl/weld/weldutils.hxx>

#include <vcl/windowstate.hxx>

#include <bitmaps.hlst>

#include <printdlg.hxx>

#include <strings.hrc>

#include <svdata.hxx>

#include <com/sun/star/beans/PropertyValue.hpp>

using namespace vcl;

using namespace com::sun::star;

using namespace com::sun::star::uno;

using namespace com::sun::star::container;

using namespace com::sun::star::beans;

enum

{

    ORIENTATION_AUTOMATIC,

    ORIENTATION_PORTRAIT,

    ORIENTATION_LANDSCAPE

};

namespace {

   bool lcl_ListBoxCompare( const OUString& rStr1, const OUString& rStr2 )

   {

       return vcl::NaturalSortCompare( rStr1, rStr2 ) < 0;

   }

}

PrintDialog::PrintPreviewWindow::PrintPreviewWindow(PrintDialog* pDialog)

    : mpDialog(pDialog)

    , maOrigSize( 10, 10 )

    , mnDPIX(Application::GetDefaultDevice()->GetDPIX())

    , mnDPIY(Application::GetDefaultDevice()->GetDPIY())

    , mbGreyscale( false )

{

}

PrintDialog::PrintPreviewWindow::~PrintPreviewWindow()

{

}

void PrintDialog::PrintPreviewWindow::Resize()

{

    Size aNewSize(GetOutputSizePixel());

    tools::Long nTextHeight = GetDrawingArea()->get_text_height();

    // leave small space for decoration

    aNewSize.AdjustWidth( -(nTextHeight + 2) );

    aNewSize.AdjustHeight( -(nTextHeight + 2) );

    Size aScaledSize;

    double fScale = 1.0;

    // #i106435# catch corner case of Size(0,0)

    Size aOrigSize( maOrigSize );

    if( aOrigSize.Width() < 1 )

        aOrigSize.setWidth( aNewSize.Width() );

    if( aOrigSize.Height() < 1 )

        aOrigSize.setHeight( aNewSize.Height() );

    if( aOrigSize.Width() > aOrigSize.Height() )

    {

        aScaledSize = Size( aNewSize.Width(), aNewSize.Width() * aOrigSize.Height() / aOrigSize.Width() );

        if( aScaledSize.Height() > aNewSize.Height() )

            fScale = double(aNewSize.Height())/double(aScaledSize.Height());

    }

    else

    {

        aScaledSize = Size( aNewSize.Height() * aOrigSize.Width() / aOrigSize.Height(), aNewSize.Height() );

        if( aScaledSize.Width() > aNewSize.Width() )

            fScale = double(aNewSize.Width())/double(aScaledSize.Width());

    }

    aScaledSize.setWidth( tools::Long(aScaledSize.Width()*fScale) );

    aScaledSize.setHeight( tools::Long(aScaledSize.Height()*fScale) );

    maPreviewSize = aScaledSize;

    // check and evtl. recreate preview bitmap

    preparePreviewBitmap();

}

void PrintDialog::PrintPreviewWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)

{

    auto popIt = rRenderContext.ScopedPush();

    weld::SetPointFont(rRenderContext, rRenderContext.GetSettings().GetStyleSettings().GetLabelFont());

    rRenderContext.SetTextColor(rRenderContext.GetSettings().GetStyleSettings().GetLabelTextColor());

    rRenderContext.SetBackground(Wallpaper(Application::GetSettings().GetStyleSettings().GetDialogColor()));

    rRenderContext.Erase();

    auto nTextHeight = rRenderContext.GetTextHeight();

    Size aSize(GetOutputSizePixel());

    Point aOffset((aSize.Width()  - maPreviewSize.Width()  + nTextHeight) / 2,

                  (aSize.Height() - maPreviewSize.Height() + nTextHeight) / 2);

    // horizontal line

    {

        auto nWidth = rRenderContext.GetTextWidth(maHorzText);

        auto nStart = aOffset.X() + (maPreviewSize.Width() - nWidth) / 2;

        rRenderContext.DrawText(Point(nStart, aOffset.Y() - nTextHeight), maHorzText, 0, maHorzText.getLength());

        DecorationView aDecoView(&rRenderContext);

        auto nTop = aOffset.Y() - (nTextHeight / 2);

        aDecoView.DrawSeparator(Point(aOffset.X(), nTop), Point(nStart - 2, nTop), false);

        aDecoView.DrawSeparator(Point(nStart + nWidth + 2, nTop), Point(aOffset.X() + maPreviewSize.Width(), nTop), false);

    }

    // vertical line

    {

        auto popIt2 = rRenderContext.ScopedPush(PushFlags::FONT);

        vcl::Font aFont(rRenderContext.GetFont());

        aFont.SetOrientation(900_deg10);

        rRenderContext.SetFont(aFont);

        auto nLeft = aOffset.X() - nTextHeight;

        auto nWidth = rRenderContext.GetTextWidth(maVertText);

        auto nStart = aOffset.Y() + (maPreviewSize.Height() + nWidth) / 2;

        rRenderContext.DrawText(Point(nLeft, nStart), maVertText, 0, maVertText.getLength());

        DecorationView aDecoView(&rRenderContext);

        nLeft = aOffset.X() - (nTextHeight / 2);

        aDecoView.DrawSeparator(Point(nLeft, aOffset.Y()), Point(nLeft, nStart - nWidth - 2), true);

        aDecoView.DrawSeparator(Point(nLeft, nStart + 2), Point(nLeft, aOffset.Y() + maPreviewSize.Height()), true);

    }

    if (!maReplacementString.isEmpty())

    {

        // replacement is active

        tools::Rectangle aTextRect(aOffset + Point(2, 2), Size(maPreviewSize.Width() - 4, maPreviewSize.Height() - 4));

        rRenderContext.DrawText(aTextRect, maReplacementString,

                                DrawTextFlags::Center | DrawTextFlags::VCenter |

                                DrawTextFlags::WordBreak | DrawTextFlags::MultiLine);

    }

    else

    {

        Bitmap aPreviewBitmap(maPreviewBitmap);

        // This explicit force-to-scale allows us to get the

        // mentioned best quality here. Unfortunately this is

        // currently not sure when using just ::DrawBitmap with

        // a defined size or ::DrawOutDev

        aPreviewBitmap.Scale(maPreviewSize, BmpScaleFlag::BestQuality);

        rRenderContext.DrawBitmap(aOffset, aPreviewBitmap);

    }

    tools::Rectangle aFrameRect(aOffset + Point(-1, -1), Size(maPreviewSize.Width() + 2, maPreviewSize.Height() + 2));

    DecorationView aDecorationView(&rRenderContext);

    aDecorationView.DrawFrame(aFrameRect, DrawFrameStyle::Group);

}

bool PrintDialog::PrintPreviewWindow::Command( const CommandEvent& rEvt )

{

    if( rEvt.GetCommand() == CommandEventId::Wheel )

    {

        const CommandWheelData* pWheelData = rEvt.GetWheelData();

        if(pWheelData->GetDelta() > 0)

            mpDialog->previewBackward();

        else if (pWheelData->GetDelta() < 0)

            mpDialog->previewForward();

        return true;

    }

    return CustomWidgetController::Command(rEvt);

}

void PrintDialog::PrintPreviewWindow::setPreview( const GDIMetaFile& i_rNewPreview,

                                                  const Size& i_rOrigSize,

                                                  std::u16string_view i_rPaperName,

                                                  const OUString& i_rReplacement,

                                                  sal_Int32 i_nDPIX,

                                                  sal_Int32 i_nDPIY,

                                                  bool i_bGreyscale

                                                 )

{

    maMtf = i_rNewPreview;

    mnDPIX = i_nDPIX;

    mnDPIY = i_nDPIY;

    maOrigSize = i_rOrigSize;

    maReplacementString = i_rReplacement;

    mbGreyscale = i_bGreyscale;

    // use correct measurements

    const LocaleDataWrapper& rLocWrap(Application::GetSettings().GetLocaleDataWrapper());

    o3tl::Length eUnit = o3tl::Length::mm;

    int nDigits = 0;

    if( rLocWrap.getMeasurementSystemEnum() == MeasurementSystem::US )

    {

        eUnit = o3tl::Length::in100;

        nDigits = 2;

    }

    Size aLogicPaperSize(o3tl::convert(i_rOrigSize, o3tl::Length::mm100, eUnit));

    OUString aNumText( rLocWrap.getNum( aLogicPaperSize.Width(), nDigits ) );

    OUStringBuffer aBuf( aNumText + " " );

    aBuf.appendAscii( eUnit == o3tl::Length::mm ? "mm" : "in" );

    if( !i_rPaperName.empty() )

    {

        aBuf.append( OUString::Concat(" (")  + i_rPaperName + ")" );

    }

    maHorzText = aBuf.makeStringAndClear();

    aNumText = rLocWrap.getNum( aLogicPaperSize.Height(), nDigits );

    aBuf.append( aNumText + " " );

    aBuf.appendAscii( eUnit == o3tl::Length::mm ? "mm" : "in" );

    maVertText = aBuf.makeStringAndClear();

    // We have a new Metafile and evtl. a new page, so we need to reset

    // the PreviewBitmap to force new creation

    maPreviewBitmap = Bitmap();

    // sets/calculates e.g. maPreviewSize

    // also triggers preparePreviewBitmap()

    Resize();

    Invalidate();

}

void PrintDialog::PrintPreviewWindow::preparePreviewBitmap()

{

    if(maPreviewSize.IsEmpty())

    {

        // not yet fully initialized, no need to prepare anything

        return;

    }

    // define an allowed number of pixels, also see

    // defaults for primitive renderers and similar. This

    // might be centralized and made dependent of 32/64bit

    const sal_uInt32 nMaxSquarePixels(500000);

    // check how big (squarePixels) the preview is currently (with

    // max value of MaxSquarePixels)

    const sal_uInt32 nCurrentSquarePixels(

        std::min(

            nMaxSquarePixels,

            static_cast<sal_uInt32>(maPreviewBitmap.GetSizePixel().getWidth())

            * static_cast<sal_uInt32>(maPreviewBitmap.GetSizePixel().getHeight())));

    // check how big (squarePixels) the preview needs to be (with

    // max value of MaxSquarePixels)

    const sal_uInt32 nRequiredSquarePixels(

        std::min(

            nMaxSquarePixels,

            static_cast<sal_uInt32>(maPreviewSize.getWidth())

            * static_cast<sal_uInt32>(maPreviewSize.getHeight())));

    // check if preview is big enough. Use a scaling value in

    // the comparison to not get bigger at the last possible moment

    // what may look awkward and pixelated (again). This means

    // to use a percentage value - if we have at least

    // that value of required pixels, we are good.

    static const double fPreventAwkwardFactor(1.35); // 35%

    if(nCurrentSquarePixels >= static_cast<sal_uInt32>(nRequiredSquarePixels * fPreventAwkwardFactor))

    {

        // at this place we also could add a mechanism to let the preview

        // bitmap 'shrink' again if it is currently 'too big' -> bigger

        // than required. I think this is not necessary for now.

        // already sufficient, done.

        return;

    }

    // check if we have enough square pixels e.g for 8x8 pixels

    if(nRequiredSquarePixels < 64)

    {

        // too small preview - let it empty

        return;

    }

    // Calculate nPlannedSquarePixels which is the required size

    // expanded by a percentage (with max value of MaxSquarePixels)

    static const double fExtraSpaceFactor(1.65); // 65%

    const sal_uInt32 nPlannedSquarePixels(

        std::min(

            nMaxSquarePixels,

            static_cast<sal_uInt32>(maPreviewSize.getWidth() * fExtraSpaceFactor)

            * static_cast<sal_uInt32>(maPreviewSize.getHeight() * fExtraSpaceFactor)));

    // calculate back new width and height - it might have been

    // truncated by MaxSquarePixels.

    // We know that w*h == nPlannedSquarePixels and w/h == ratio

    const double fRatio(static_cast<double>(maPreviewSize.getWidth()) / static_cast<double>(maPreviewSize.getHeight()));

    const double fNewWidth(sqrt(static_cast<double>(nPlannedSquarePixels) * fRatio));

    const double fNewHeight(sqrt(static_cast<double>(nPlannedSquarePixels) / fRatio));

    const Size aScaledSize(basegfx::fround<tools::Long>(fNewWidth), basegfx::fround<tools::Long>(fNewHeight));

    // check if this eventual maximum is already reached

    // due to having hit the MaxSquarePixels. Due to using

    // an integer AspectRatio, we cannot make a numeric exact

    // comparison - we need to compare if we are close

    const double fScaledSizeSquare(static_cast<double>(aScaledSize.getWidth() * aScaledSize.getHeight()));

    const double fPreviewSizeSquare(static_cast<double>(maPreviewBitmap.GetSizePixel().getWidth() * maPreviewBitmap.GetSizePixel().getHeight()));

    // test as equal up to 0.1% (0.001)

    if(fPreviewSizeSquare != 0.0 && fabs((fScaledSizeSquare / fPreviewSizeSquare) - 1.0) < 0.001)

    {

        // maximum is reached, avoid bigger scaling

        return;

    }

    // create temporary VDev with requested Size and DPI.

    // CAUTION: DPI *is* important here - it DIFFERS from 75x75, usually 600x600 is used

    ScopedVclPtrInstance<VirtualDevice> pPrerenderVDev(*Application::GetDefaultDevice());

    pPrerenderVDev->SetOutputSizePixel(aScaledSize, false);

    pPrerenderVDev->SetReferenceDevice( mnDPIX, mnDPIY );

    // calculate needed Scale for Metafile (using Size and DPI from VDev)

    Size aLogicSize( pPrerenderVDev->PixelToLogic( pPrerenderVDev->GetOutputSizePixel(), MapMode( MapUnit::Map100thMM ) ) );

    Size aOrigSize( maOrigSize );

    if( aOrigSize.Width() < 1 )

        aOrigSize.setWidth( aLogicSize.Width() );

    if( aOrigSize.Height() < 1 )

        aOrigSize.setHeight( aLogicSize.Height() );

    double fScale = double(aLogicSize.Width())/double(aOrigSize.Width());

    // tdf#141761

    // The display quality of the Preview is pretty ugly when

    // FormControls are used. I made a deep-dive why this happens,

    // and in principle the reason is the Metafile::Scale used

    // below. Since Metafile actions are integer, that floating point

    // scale leads to rounding errors that make the lines painting

    // the FormControls disappear in the surrounding ClipRegions.

    // That Scale cannot be avoided since the Metafile contains its

    // own SetMapMode commands which *will* be executed on ::Play,

    // so the ::Scale is the only possibility for Metafile currently:

    // Giving a Size as parameter in ::Play will *not* work due to

    // the relativeMapMode that gets created will fail on

    // ::SetMapMode actions in the Metafile - and FormControls DO

    // use ::SetMapMode(MapPixel).

    // This can only be solved better in the future using Primitives

    // which would allow any scale by embedding to a Transformation,

    // but that would be a bigger rework.

    // Until then, use this little 'trick' to improve quality.

    // It uses the fact to empirically having tested that the quality

    // gets really bad for FormControls starting by a scale factor

    // smaller than 0.2 - that makes the ClipRegion overlap start.

    // So - for now - try not to go below that.

    static const double fMinimumScale(0.2);

    double fFactor(0.0);

    if(fScale < fMinimumScale)

    {

        fFactor = fMinimumScale / fScale;

        fScale = fMinimumScale;

        double fWidth(aScaledSize.getWidth() * fFactor);

        double fHeight(aScaledSize.getHeight() * fFactor);

        const double fNewNeededPixels(fWidth * fHeight);

        // to not risk using too big bitmaps and running into

        // memory problems, still limit to a useful factor is

        // necessary, also empirically estimated to

        // avoid the quality from collapsing (using a direct

        // in-between, ceil'd result)

        static const double fMaximumQualitySquare(1396221.0);

        if(fNewNeededPixels > fMaximumQualitySquare)

        {

            const double fCorrection(fMaximumQualitySquare/fNewNeededPixels);

            fWidth *= fCorrection;

            fHeight *= fCorrection;

            fScale *= fCorrection;

        }

        const Size aScaledSize2(basegfx::fround<tools::Long>(fWidth), basegfx::fround<tools::Long>(fHeight));

        pPrerenderVDev->SetOutputSizePixel(aScaledSize2, false);

        aLogicSize = pPrerenderVDev->PixelToLogic( aScaledSize2, MapMode( MapUnit::Map100thMM ) );

    }

    pPrerenderVDev->EnableOutput();

    pPrerenderVDev->SetBackground( Wallpaper(COL_WHITE) );

    pPrerenderVDev->Erase();

    pPrerenderVDev->SetMapMode(MapMode(MapUnit::Map100thMM));

    if( mbGreyscale )

        pPrerenderVDev->SetDrawMode( pPrerenderVDev->GetDrawMode() |

                                ( DrawModeFlags::GrayLine | DrawModeFlags::GrayFill | DrawModeFlags::GrayText |

                                  DrawModeFlags::GrayBitmap | DrawModeFlags::GrayGradient ) );

    // Copy, Scale and Paint Metafile

    GDIMetaFile aMtf( maMtf );

    aMtf.WindStart();

    aMtf.Scale( fScale, fScale );

    aMtf.WindStart();

    aMtf.Play(*pPrerenderVDev, Point(0, 0), aLogicSize);

    pPrerenderVDev->SetMapMode(MapMode(MapUnit::MapPixel));

    maPreviewBitmap = pPrerenderVDev->GetBitmap(Point(0, 0), pPrerenderVDev->GetOutputSizePixel());

    if(0.0 != fFactor)

    {

        // Correct to needed size, BmpScaleFlag::Interpolate is acceptable,

        // but BmpScaleFlag::BestQuality is just better. In case of time

        // constraints, change to Interpolate would be possible

        maPreviewBitmap.Scale(aScaledSize, BmpScaleFlag::BestQuality);

    }

}

PrintDialog::ShowNupOrderWindow::ShowNupOrderWindow()

    : mnOrderMode( NupOrderType::LRTB )

    , mnRows( 1 )

    , mnColumns( 1 )

{

}

void PrintDialog::ShowNupOrderWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea)

{

    Size aSize(70, 70);

    pDrawingArea->set_size_request(aSize.Width(), aSize.Height());

    CustomWidgetController::SetDrawingArea(pDrawingArea);

    SetOutputSizePixel(aSize);

}

void PrintDialog::ShowNupOrderWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*i_rRect*/)

{

    rRenderContext.SetMapMode(MapMode(MapUnit::MapPixel));

    rRenderContext.SetTextColor(rRenderContext.GetSettings().GetStyleSettings().GetFieldTextColor());

    rRenderContext.SetBackground(Wallpaper(Application::GetSettings().GetStyleSettings().GetFieldColor()));

    rRenderContext.Erase();

    int nPages = mnRows * mnColumns;

    Font aFont(rRenderContext.GetSettings().GetStyleSettings().GetFieldFont());

    aFont.SetFontSize(Size(0, 24));

    rRenderContext.SetFont(aFont);

    Size aSampleTextSize(rRenderContext.GetTextWidth(OUString::number(nPages + 1)), rRenderContext.GetTextHeight());

    Size aOutSize(GetOutputSizePixel());

    Size aSubSize(aOutSize.Width() / mnColumns, aOutSize.Height() / mnRows);

    // calculate font size: shrink the sample text so it fits

    double fX = double(aSubSize.Width()) / double(aSampleTextSize.Width());

    double fY = double(aSubSize.Height()) / double(aSampleTextSize.Height());

    double fScale = (fX < fY) ? fX : fY;

    tools::Long nFontHeight = tools::Long(24.0 * fScale) - 3;

    if (nFontHeight < 5)

        nFontHeight = 5;

    aFont.SetFontSize(Size( 0, nFontHeight));

    rRenderContext.SetFont(aFont);

    tools::Long nTextHeight = rRenderContext.GetTextHeight();

    for (int i = 0; i < nPages; i++)

    {

        OUString aPageText(OUString::number(i + 1));

        int nX = 0, nY = 0;

        switch (mnOrderMode)

        {

        case NupOrderType::LRTB:

            nX = (i % mnColumns);

            nY = (i / mnColumns);

            break;

        case NupOrderType::TBLR:

            nX = (i / mnRows);

            nY = (i % mnRows);

            break;

        case NupOrderType::RLTB:

            nX = mnColumns - 1 - (i % mnColumns);

            nY = (i / mnColumns);

            break;

        case NupOrderType::TBRL:

            nX = mnColumns - 1 - (i / mnRows);

            nY = (i % mnRows);

            break;

        }

        Size aTextSize(rRenderContext.GetTextWidth(aPageText), nTextHeight);

        int nDeltaX = (aSubSize.Width() - aTextSize.Width()) / 2;

        int nDeltaY = (aSubSize.Height() - aTextSize.Height()) / 2;

        rRenderContext.DrawText(Point(nX * aSubSize.Width() + nDeltaX,

                                      nY * aSubSize.Height() + nDeltaY), aPageText);

    }

    DecorationView aDecorationView(&rRenderContext);

    aDecorationView.DrawFrame(tools::Rectangle(Point(0, 0), aOutSize), DrawFrameStyle::Group);

}

Size const & PrintDialog::getJobPageSize()

{

    if( maFirstPageSize.IsEmpty() )

    {

        maFirstPageSize = maNupPortraitSize;

        GDIMetaFile aMtf;

        if( maPController->getPageCountProtected() > 0 )

        {

            PrinterController::PageSize aPageSize = maPController->getPageFile( 0, aMtf, true );

            maFirstPageSize = aPageSize.aSize;

        }

    }

    return maFirstPageSize;

}

PrintDialog::PrintDialog(weld::Window* i_pWindow, std::shared_ptr<PrinterController> i_xController)

    : GenericDialogController(i_pWindow, u"vcl/ui/printdialog.ui"_ustr, u"PrintDialog"_ustr)

    , maPController(std::move( i_xController ))

    , mxTabCtrl(m_xBuilder->weld_notebook(u"tabcontrol"_ustr))

    , mxScrolledWindow(m_xBuilder->weld_scrolled_window(u"scrolledwindow"_ustr))

    , mxPageLayoutFrame(m_xBuilder->weld_frame(u"layoutframe"_ustr))

    , mxPrinters(m_xBuilder->weld_combo_box(u"printersbox"_ustr))

    , mxStatusTxt(m_xBuilder->weld_label(u"status"_ustr))

    , mxSetupButton(m_xBuilder->weld_button(u"setup"_ustr))

    , mxCopyCountField(m_xBuilder->weld_spin_button(u"copycount"_ustr))

    , mxCollateBox(m_xBuilder->weld_check_button(u"collate"_ustr))

    , mxCollateImage(m_xBuilder->weld_image(u"collateimage"_ustr))

    , mxPageRangeEdit(m_xBuilder->weld_entry(u"pagerange"_ustr))

    , mxPageRangesRadioButton(m_xBuilder->weld_radio_button(u"rbRangePages"_ustr))

    , mxPaperSidesBox(m_xBuilder->weld_combo_box(u"sidesbox"_ustr))

    , mxSingleJobsBox(m_xBuilder->weld_check_button(u"singlejobs"_ustr))

    , mxReverseOrderBox(m_xBuilder->weld_check_button(u"reverseorder"_ustr))

    , mxOKButton(m_xBuilder->weld_button(u"ok"_ustr))

    , mxCancelButton(m_xBuilder->weld_button(u"cancel"_ustr))

    , mxBackwardBtn(m_xBuilder->weld_button(u"backward"_ustr))

    , mxForwardBtn(m_xBuilder->weld_button(u"forward"_ustr))

    , mxFirstBtn(m_xBuilder->weld_button(u"btnFirst"_ustr))

    , mxLastBtn(m_xBuilder->weld_button(u"btnLast"_ustr))

    , mxPreviewBox(m_xBuilder->weld_check_button(u"previewbox"_ustr))

    , mxNumPagesText(m_xBuilder->weld_label(u"totalnumpages"_ustr))

    , mxPreview(new PrintPreviewWindow(this))

    , mxPreviewWindow(new weld::CustomWeld(*m_xBuilder, u"preview"_ustr, *mxPreview))

    , mxPageEdit(m_xBuilder->weld_entry(u"pageedit"_ustr))

    , mxPagesBtn(m_xBuilder->weld_radio_button(u"pagespersheetbtn"_ustr))

    , mxBrochureBtn(m_xBuilder->weld_radio_button(u"brochure"_ustr))

    , mxPagesBoxTitleTxt(m_xBuilder->weld_label(u"pagespersheettxt"_ustr))

    , mxNupPagesBox(m_xBuilder->weld_combo_box(u"pagespersheetbox"_ustr))

    , mxNupNumPagesTxt(m_xBuilder->weld_label(u"pagestxt"_ustr))

    , mxNupColEdt(m_xBuilder->weld_spin_button(u"pagecols"_ustr))

    , mxNupTimesTxt(m_xBuilder->weld_label(u"by"_ustr))

    , mxNupRowsEdt(m_xBuilder->weld_spin_button(u"pagerows"_ustr))

    , mxPageMarginTxt1(m_xBuilder->weld_label(u"pagemargintxt1"_ustr))

    , mxPageMarginEdt(m_xBuilder->weld_metric_spin_button(u"pagemarginsb"_ustr, FieldUnit::MM))

    , mxPageMarginTxt2(m_xBuilder->weld_label(u"pagemargintxt2"_ustr))

    , mxSheetMarginTxt1(m_xBuilder->weld_label(u"sheetmargintxt1"_ustr))

    , mxSheetMarginEdt(m_xBuilder->weld_metric_spin_button(u"sheetmarginsb"_ustr, FieldUnit::MM))

    , mxSheetMarginTxt2(m_xBuilder->weld_label(u"sheetmargintxt2"_ustr))

    , mxPaperSizeBox(m_xBuilder->weld_combo_box(u"papersizebox"_ustr))

    , mxOrientationBox(m_xBuilder->weld_combo_box(u"pageorientationbox"_ustr))

    , mxNupOrderTxt(m_xBuilder->weld_label(u"labelorder"_ustr))

    , mxNupOrderBox(m_xBuilder->weld_combo_box(u"orderbox"_ustr))

    , mxNupOrder(new ShowNupOrderWindow)

    , mxNupOrderWin(new weld::CustomWeld(*m_xBuilder, u"orderpreview"_ustr, *mxNupOrder))

    , mxBorderCB(m_xBuilder->weld_check_button(u"bordercb"_ustr))

    , mxRangeExpander(m_xBuilder->weld_expander(u"exRangeExpander"_ustr))

    , mxLayoutExpander(m_xBuilder->weld_expander(u"exLayoutExpander"_ustr))

    , mxCustom(m_xBuilder->weld_widget(u"customcontents"_ustr))

    , maPrintToFileText( VclResId( SV_PRINT_TOFILE_TXT ) )

    , maDefPrtText( VclResId( SV_PRINT_DEFPRT_TXT ) )

    , maNoPageStr( VclResId( SV_PRINT_NOPAGES ) )

    , maNoPreviewStr( VclResId( SV_PRINT_NOPREVIEW ) )

    , mnInitialPage( 0 )

    , mnCurPage( 0 )

    , mnCachedPages( 0 )

    , mbShowLayoutFrame( true )

    , mbHasCustomPaperEntry( false )

    , maUpdatePreviewIdle("Print Dialog Update Preview Idle")

    , maPageRangeUpdateTimer("PageRangeUpdateTimer")

{

    // Retrieve current page, it'll be used later in updatePageRange method

    PropertyValue* pPageRange = maPController->getValue(u"PageRange"_ustr);

    if (pPageRange && pPageRange->Value.hasValue())

    {

        OUString aPageRange;

        pPageRange->Value >>= aPageRange;

        mnInitialPage = aPageRange.toInt32();

    }

    // save printbutton text, gets exchanged occasionally with print to file

    maPrintText = mxOKButton->get_label();

    maPageStr = mxNumPagesText->get_label();

    mxPrinters->append_text(maPrintToFileText);

    // fill printer listbox

    std::vector< OUString > rQueues( Printer::GetPrinterQueues() );

    std::sort( rQueues.begin(), rQueues.end(), lcl_ListBoxCompare );

    for( const auto& rQueue : rQueues )

    {

        mxPrinters->append_text(rQueue);

    }

    // select current printer

    if (mxPrinters->find_text(maPController->getPrinter()->GetName()) != -1)

        mxPrinters->set_active_text(maPController->getPrinter()->GetName());

    else

    {

        // fall back to last printer

        OUString aValue( officecfg::VCL::VCLSettings::PrintDialog::LastPrinter::get() );

        if (mxPrinters->find_text(aValue) != -1)

        {

            mxPrinters->set_active_text(aValue);

            maPController->setPrinter( VclPtrInstance<Printer>( aValue ) );

        }

        else

        {

            // fall back to default printer

            mxPrinters->set_active_text(Printer::GetDefaultPrinterName());

            maPController->setPrinter( VclPtrInstance<Printer>( Printer::GetDefaultPrinterName() ) );

        }

    }

    // not printing to file

    maPController->resetPrinterOptions( false );

    // update the text fields for the printer

    updatePrinterText();

    // setup dependencies

    checkControlDependencies();

    // setup paper sides box

    setupPaperSidesBox();

    // set initial focus to "Printer"

    mxPrinters->grab_focus();

    // setup sizes for N-Up

    Size aNupSize( maPController->getPrinter()->PixelToLogic(

                         maPController->getPrinter()->GetPaperSizePixel(), MapMode( MapUnit::Map100thMM ) ) );

    if( maPController->getPrinter()->GetOrientation() == Orientation::Landscape )

    {

        maNupLandscapeSize = aNupSize;

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

        maNupPortraitSize = Size( aNupSize.Height(), aNupSize.Width() );

    }

    else

    {

        maNupPortraitSize = aNupSize;

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

        maNupLandscapeSize = Size( aNupSize.Height(), aNupSize.Width() );

    }

    maUpdatePreviewIdle.SetPriority(TaskPriority::POST_PAINT);

    maUpdatePreviewIdle.SetInvokeHandler(LINK( this, PrintDialog, updatePreviewIdle));

    maPageRangeUpdateTimer.SetTimeout(EDIT_UPDATEDATA_TIMEOUT);

    maPageRangeUpdateTimer.SetInvokeHandler(LINK(this, PrintDialog, PageRangeUpdateTimerHdl));

    initFromMultiPageSetup( maPController->getMultipage() );

    // setup optional UI options set by application

    setupOptionalUI();

    // hide layout frame if unwanted

    mxPageLayoutFrame->set_visible(mbShowLayoutFrame);

    // restore settings from last run

    readFromSettings();

    // setup click hdl

    mxOKButton->connect_clicked(LINK(this, PrintDialog, ClickOKCancelHdl));

    mxCancelButton->connect_clicked(LINK(this, PrintDialog, ClickOKCancelHdl));

    mxSetupButton->connect_clicked(LINK(this, PrintDialog, ClickSetupHdl));

    mxBackwardBtn->connect_clicked(LINK(this, PrintDialog, ClickBackwardHdl));

    mxForwardBtn->connect_clicked(LINK(this, PrintDialog, ClickForwardHdl));

    mxFirstBtn->connect_clicked(LINK(this, PrintDialog, ClickFirstHdl));

    mxLastBtn->connect_clicked(LINK(this, PrintDialog, ClickLastHdl));

    // setup toggle hdl

    mxReverseOrderBox->connect_toggled(LINK(this, PrintDialog, ToggleReverseOrderHdl));

    mxCollateBox->connect_toggled(LINK(this, PrintDialog, ToggleCollateHdl));

    mxSingleJobsBox->connect_toggled(LINK(this, PrintDialog, ToggleSingleJobsHdl));

    mxBrochureBtn->connect_toggled(LINK(this, PrintDialog, ToggleBrochureHdl));

    mxPreviewBox->connect_toggled(LINK(this, PrintDialog, TogglePreviewHdl));

    mxBorderCB->connect_toggled(LINK(this, PrintDialog, ToggleBorderHdl));

    // setup select hdl

    mxPrinters->connect_changed(LINK(this, PrintDialog, SelectPrinterHdl));

    mxPaperSidesBox->connect_changed(LINK(this, PrintDialog, SelectPaperSidesHdl));

    mxNupPagesBox->connect_changed(LINK(this, PrintDialog, SelectNupPagesHdl));

    mxOrientationBox->connect_changed(LINK(this, PrintDialog, SelectOrientationHdl));

    mxNupOrderBox->connect_changed(LINK(this, PrintDialog, SelectNupOrderHdl));

    mxPaperSizeBox->connect_changed(LINK(this, PrintDialog, SelectPaperSizeHdl));

    // setup modify hdl

    mxPageEdit->connect_activate( LINK( this, PrintDialog, ActivateHdl ) );

    mxPageEdit->connect_focus_out( LINK( this, PrintDialog, FocusOutHdl ) );

    mxCopyCountField->connect_value_changed( LINK( this, PrintDialog, SpinModifyHdl ) );

    mxNupColEdt->connect_value_changed( LINK( this, PrintDialog, SpinModifyHdl ) );

    mxNupRowsEdt->connect_value_changed( LINK( this, PrintDialog, SpinModifyHdl ) );

    mxPageMarginEdt->connect_value_changed( LINK( this, PrintDialog, MetricSpinModifyHdl ) );

    mxSheetMarginEdt->connect_value_changed( LINK( this, PrintDialog, MetricSpinModifyHdl ) );

    updateNupFromPages();

    // tdf#129180 Delay setting the default value in the Paper Size list

    // set paper sizes listbox

    setPaperSizes();

    // Sync selected paper size with the controller for preview.

    if (mxPaperSizeBox->get_sensitive() && mxPaperSizeBox->get_active() != -1)

        SelectPaperSizeHdl(*mxPaperSizeBox);

    mxRangeExpander->set_expanded(

        officecfg::Office::Common::Print::Dialog::RangeSectionExpanded::get());

    mxLayoutExpander->set_expanded(

        officecfg::Office::Common::Print::Dialog::LayoutSectionExpanded::get());

    // lock the dialog height, regardless of later expander state

    mxScrolledWindow->set_size_request(

        mxScrolledWindow->get_preferred_size().Width() + mxScrolledWindow->get_scroll_thickness(),

        450);

    m_xDialog->set_centered_on_parent(true);

}

void PrintDialog::ImplDestroy()

{

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

    officecfg::Office::Common::Print::Dialog::RangeSectionExpanded::set(mxRangeExpander->get_expanded(), batch);

    officecfg::Office::Common::Print::Dialog::LayoutSectionExpanded::set(mxLayoutExpander->get_expanded(), batch);

    batch->commit();

}

PrintDialog::~PrintDialog()

{

    suppress_fun_call_w_exception(ImplDestroy());

}

void PrintDialog::setupPaperSidesBox()

{

    DuplexMode eDuplex = maPController->getPrinter()->GetDuplexMode();

    if ( eDuplex == DuplexMode::Unknown || isPrintToFile() )

    {

        mxPaperSidesBox->set_active( 0 );

        mxPaperSidesBox->set_sensitive( false );

    }

    else

    {

        mxPaperSidesBox->set_active( static_cast<sal_Int32>(eDuplex) - 1 );

        mxPaperSidesBox->set_sensitive( true );

    }

}

void PrintDialog::storeToSettings()

{

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

    officecfg::VCL::VCLSettings::PrintDialog::LastPrinter::set(

                      isPrintToFile() ? Printer::GetDefaultPrinterName()

                                      : mxPrinters->get_active_text(), batch );

    officecfg::VCL::VCLSettings::PrintDialog::LastPage::set(

                     mxTabCtrl->get_tab_label_text(mxTabCtrl->get_current_page_ident()), batch);

    officecfg::VCL::VCLSettings::PrintDialog::WindowState::set(

        m_xDialog->get_window_state(vcl::WindowDataMask::All).toStr(), batch);

    officecfg::VCL::VCLSettings::PrintDialog::Collate::set( mxCollateBox->get_active(), batch );

    officecfg::VCL::VCLSettings::PrintDialog::CollateSingleJobs::set(

                     mxSingleJobsBox->get_active(), batch );

    officecfg::VCL::VCLSettings::PrintDialog::HasPreview::set( hasPreview(), batch);

    batch->commit();

}

void PrintDialog::readFromSettings()

{

    // read last selected tab page; if it exists, activate it

    OUString aValue = officecfg::VCL::VCLSettings::PrintDialog::LastPage::get();

    sal_uInt16 nCount = mxTabCtrl->get_n_pages();

    for (sal_uInt16 i = 0; i < nCount; ++i)

    {

        OUString sPageId = mxTabCtrl->get_page_ident(i);

        if (aValue == mxTabCtrl->get_tab_label_text(sPageId))

        {

            mxTabCtrl->set_current_page(sPageId);

            break;

        }

    }

    // persistent window state

    aValue = officecfg::VCL::VCLSettings::PrintDialog::WindowState::get();

    if (!aValue.isEmpty())

        m_xDialog->set_window_state(vcl::WindowData(aValue));

    // collate

    mxCollateBox->set_sensitive( officecfg::VCL::VCLSettings::PrintDialog::Collate::isReadOnly() );

    mxCollateBox->set_active( officecfg::VCL::VCLSettings::PrintDialog::Collate::get() );

    // collate single jobs

    mxSingleJobsBox->set_active( officecfg::VCL::VCLSettings::PrintDialog::CollateSingleJobs::get() );

    // preview box

    mxPreviewBox->set_active( officecfg::VCL::VCLSettings::PrintDialog::HasPreview::get() );

}

void PrintDialog::setPaperSizes()

{

    mxPaperSizeBox->clear();

    mxPaperSizeBox->set_active(-1);

    mbHasCustomPaperEntry = false;

    VclPtr<Printer> aPrt( maPController->getPrinter() );

    mePaper = aPrt->GetPaper();

    // Related: tdf#159995 allow setting the page size when printing to file

    // On macOS, printing to file just saves to PDF using a native print

    // job just like the native print dialog's PDF > Save as PDF... option.

    // Also, as noted in tdf#163558, the native print dialog could support

    // changing the page size eventually (and already does in Apple's

    // Safari and TextEdit applications) so allow changing of the page

    // size in the non-native print dialog on macOS as well.

#ifndef MACOSX

    if ( isPrintToFile() )

    {

        mxPaperSizeBox->set_sensitive( false );

    }

    else

#endif

    {

        int nExactMatch = -1;

        int nExactRotatedMatch = -1;

        int nSizeMatch = -1;

        int nRotatedSizeMatch = -1;

        Size aSizeOfPaper = aPrt->GetSizeOfPaper();

        PaperInfo aPaperInfo(aSizeOfPaper.getWidth(), aSizeOfPaper.getHeight());

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

        PaperInfo aRotatedPaperInfo(aSizeOfPaper.getHeight(), aSizeOfPaper.getWidth());

        const LocaleDataWrapper& rLocWrap(Application::GetSettings().GetLocaleDataWrapper());

        o3tl::Length eUnit = o3tl::Length::mm;

        int nDigits = 0;

        if( rLocWrap.getMeasurementSystemEnum() == MeasurementSystem::US )

        {

            eUnit = o3tl::Length::in100;

            nDigits = 2;

        }

        // Also match by document page dimensions, not just Paper enum

        // (e.g. a card printer whose paper has no matching enum).

        Size aDocSize = getJobPageSize();

        PaperInfo aDocPaperInfo(aDocSize.getWidth(), aDocSize.getHeight());

        PaperInfo aDocRotatedInfo(aDocSize.getHeight(), aDocSize.getWidth());

        int nDocDimMatch = -1;

        int nDocDimRotatedMatch = -1;

        for (int nPaper = 0; nPaper < aPrt->GetPaperInfoCount(); nPaper++)

        {

            PaperInfo aInfo = aPrt->GetPaperInfo( nPaper );

            aInfo.doSloppyFit(true);

            Paper ePaper = aInfo.getPaper();

            // Use PaperInfo directly (1/100th mm); GetPaperSize() uses

            // PixelToLogic which can return wrong values.

            Size aSize(aInfo.getWidth(), aInfo.getHeight());

            Size aLogicPaperSize( o3tl::convert(aSize, o3tl::Length::mm100, eUnit) );

            OUString aWidth( rLocWrap.getNum( aLogicPaperSize.Width(), nDigits ) );

            OUString aHeight( rLocWrap.getNum( aLogicPaperSize.Height(), nDigits ) );

            OUString aUnit = eUnit == o3tl::Length::mm ? u"mm"_ustr : u"in"_ustr;

            OUString aPaperName;

            // Paper sizes that we don't know of but the system printer driver lists are not "User

            // Defined". Displaying them as such is just confusing.

            if (ePaper != PAPER_USER)

                aPaperName = Printer::GetPaperName( ePaper ) + " ";

            aPaperName += aWidth + aUnit + " x " + aHeight + aUnit;

            mxPaperSizeBox->append_text(aPaperName);

            // For exact match, check that paper orientation also matches

            if (ePaper != PAPER_USER && ePaper == mePaper)

            {

                // Only get the first match, in case there are multiple papers with the same size

                if (nExactMatch == -1 && aInfo.sloppyEqual(aPaperInfo))

                    nExactMatch = nPaper;

                else if (nExactRotatedMatch == -1 && aInfo.sloppyEqual(aRotatedPaperInfo))

                    nExactRotatedMatch = nPaper;

            }

            if (ePaper == PAPER_USER && aInfo.sloppyEqual(aPaperInfo))

                nSizeMatch = nPaper;

            if (ePaper == PAPER_USER && aInfo.sloppyEqual(aRotatedPaperInfo))

                nRotatedSizeMatch = nPaper;

            // Match by document page dimensions

            if (!aDocSize.IsEmpty())

            {

                if (nDocDimMatch == -1 && aInfo.sloppyEqual(aDocPaperInfo))