/* -*- 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 <svx/sdrpagewindow.hxx>

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

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

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

#include <comphelper/lok.hxx>

#include <comphelper/processfactory.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <toolkit/controls/unocontrolcontainer.hxx>

#include <toolkit/controls/unocontrolcontainermodel.hxx>

#include <svx/svdview.hxx>

#include <svx/svdpagv.hxx>

#include <svx/sdrpaintwindow.hxx>

#include <svx/sdr/contact/objectcontactofpageview.hxx>

#include <svx/sdr/contact/displayinfo.hxx>

#include <svx/fmview.hxx>

#include <sfx2/lokhelper.hxx>

#include <svtools/optionsdrawinglayer.hxx>

#include <tools/debug.hxx>

#include <vcl/window.hxx>

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

struct SdrPageWindow::Impl

{

    // #110094# ObjectContact section

    mutable sdr::contact::ObjectContact* mpObjectContact;

    // the SdrPageView this window belongs to

    SdrPageView& mrPageView;

    // the PaintWindow to paint on. Here is access to OutDev etc.

    // #i72752# change to pointer to allow patcing it in DrawLayer() if necessary

    SdrPaintWindow* mpPaintWindow;

    SdrPaintWindow* mpOriginalPaintWindow;

    // UNO stuff for xControls

    rtl::Reference<UnoControlContainer> mxControlContainer;

    Impl( SdrPageView& rPageView, SdrPaintWindow& rPaintWindow ) :

        mpObjectContact(nullptr),

        mrPageView(rPageView),

        mpPaintWindow(&rPaintWindow),

        mpOriginalPaintWindow(nullptr)

    {

    }

};

rtl::Reference<UnoControlContainer> const & SdrPageWindow::GetControlContainer( bool _bCreateIfNecessary ) const

{

    if (!mpImpl->mxControlContainer.is() && _bCreateIfNecessary)

    {

        SdrView& rView = GetPageView().GetView();

        const SdrPaintWindow& rPaintWindow( GetOriginalPaintWindow() ? *GetOriginalPaintWindow() : GetPaintWindow() );

        if ( rPaintWindow.OutputToWindow() && !rView.IsPrintPreview() )

        {

            vcl::Window* pWindow = rPaintWindow.GetOutputDevice().GetOwnerWindow();

            const_cast< SdrPageWindow* >( this )->mpImpl->mxControlContainer = VCLUnoHelper::CreateControlContainer( pWindow );

            // #100394# xC->setVisible triggers window->Show() and this has

            // problems when the view is not completely constructed which may

            // happen when loading. This leads to accessibility broadcasts which

            // throw asserts due to the not finished view. All this chain can be avoided

            // since xC->setVisible is here called only for the side effect in

            // UnoControlContainer::setVisible(...) which calls createPeer(...).

            // This will now be called directly from here.

            if(mpImpl->mxControlContainer.is())

            {

                uno::Reference< uno::XInterface > xContext = mpImpl->mxControlContainer->getContext();

                if(!xContext.is())

                {

                    mpImpl->mxControlContainer->createPeer( uno::Reference<awt::XToolkit>(), uno::Reference<awt::XWindowPeer>() );

                }

            }

        }

        else

        {

            // Printer and VirtualDevice, or rather: no OutDev

            const_cast< SdrPageWindow* >( this )->mpImpl->mxControlContainer = new UnoControlContainer();

            rtl::Reference< UnoControlContainerModel > xModel(new UnoControlContainerModel(comphelper::getProcessComponentContext()));

            mpImpl->mxControlContainer->setModel(xModel);

            OutputDevice& rOutDev = rPaintWindow.GetOutputDevice();

            Point aPosPix = rOutDev.GetMapMode().GetOrigin();

            Size aSizePix = rOutDev.GetOutputSizePixel();

            mpImpl->mxControlContainer->setPosSize(aPosPix.X(), aPosPix.Y(), aSizePix.Width(), aSizePix.Height(), awt::PosSize::POSSIZE);

        }

        FmFormView* pViewAsFormView = dynamic_cast< FmFormView* >( &rView );

        if ( pViewAsFormView )

            pViewAsFormView->InsertControlContainer(mpImpl->mxControlContainer);

    }

    return mpImpl->mxControlContainer;

}

SdrPageWindow::SdrPageWindow(SdrPageView& rPageView, SdrPaintWindow& rPaintWindow) :

    mpImpl(new Impl(rPageView, rPaintWindow))

{

}

SdrPageWindow::~SdrPageWindow()

{

    // #i26631#

    ResetObjectContact();

    if (!mpImpl->mxControlContainer.is())

        return;

    auto & rView = static_cast<SdrPaintView &>(GetPageView().GetView());

    // notify derived views

    FmFormView* pViewAsFormView = dynamic_cast< FmFormView* >( &rView );

    if ( pViewAsFormView )

        pViewAsFormView->RemoveControlContainer(mpImpl->mxControlContainer);

    // dispose the control container

    mpImpl->mxControlContainer->dispose();

}

SdrPageView& SdrPageWindow::GetPageView() const

{

    return mpImpl->mrPageView;

}

SdrPaintWindow& SdrPageWindow::GetPaintWindow() const

{

    return *mpImpl->mpPaintWindow;

}

const SdrPaintWindow* SdrPageWindow::GetOriginalPaintWindow() const

{

    return mpImpl->mpOriginalPaintWindow;

}

// OVERLAY MANAGER

rtl::Reference< sdr::overlay::OverlayManager > const & SdrPageWindow::GetOverlayManager() const

{

    return GetPaintWindow().GetOverlayManager();

}

SdrPaintWindow* SdrPageWindow::patchPaintWindow(SdrPaintWindow& rPaintWindow)

{

    if (!mpImpl)

        return nullptr;

    if (!mpImpl->mpOriginalPaintWindow)

    {

        // first patch

        mpImpl->mpOriginalPaintWindow = mpImpl->mpPaintWindow;

        mpImpl->mpPaintWindow = &rPaintWindow;

        mpImpl->mpOriginalPaintWindow->setPatched(&rPaintWindow);

        return mpImpl->mpOriginalPaintWindow;

    }

    else

    {

        // second or more patch

        auto pPreviousPaintWindow = mpImpl->mpPaintWindow;

        mpImpl->mpPaintWindow = &rPaintWindow;

        mpImpl->mpOriginalPaintWindow->setPatched(&rPaintWindow);

        return pPreviousPaintWindow;

    }

}

void SdrPageWindow::unpatchPaintWindow(SdrPaintWindow* pPreviousPaintWindow)

{

    if (pPreviousPaintWindow == mpImpl->mpOriginalPaintWindow)

    {

        // first patch

        mpImpl->mpPaintWindow = mpImpl->mpOriginalPaintWindow;

        mpImpl->mpOriginalPaintWindow->setPatched(nullptr);

        mpImpl->mpOriginalPaintWindow = nullptr;

    }

    else

    {

        // second or more patch

        mpImpl->mpPaintWindow = pPreviousPaintWindow;

        mpImpl->mpOriginalPaintWindow->setPatched(pPreviousPaintWindow);

    }

}

void SdrPageWindow::PrePaint()

{

    // give OC the chance to do ProcessDisplay preparations

    if(HasObjectContact())

    {

        GetObjectContact().PrepareProcessDisplay();

    }

}

void SdrPageWindow::PrepareRedraw(const vcl::Region& rReg)

{

    // give OC the chance to do ProcessDisplay preparations

    if(HasObjectContact())

    {

        GetObjectContact().PrepareProcessDisplay();

    }

    // if necessary, remember changed RedrawArea at PaintWindow for usage with

    // overlay and PreRenderDevice stuff

    GetPaintWindow().SetRedrawRegion(rReg);

}

// clip test

#ifdef CLIPPER_TEST

#include <svx/svdopath.hxx>

#include <basegfx/numeric/ftools.hxx>

#include <basegfx/polygon/b2dpolygon.hxx>

#include <tools/helpers.hxx>

#include <basegfx/polygon/b2dpolygoncutandtouch.hxx>

#include <basegfx/polygon/b2dpolypolygontools.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <basegfx/polygon/b2dpolygonclipper.hxx>

// for ::std::sort

#include <algorithm>

namespace

{

    void impPaintStrokePolygon(const basegfx::B2DPolygon& rCandidate, OutputDevice& rOutDev, Color aColor)

    {

        basegfx::B2DPolygon aCandidate(rCandidate);

        if(aCandidate.areControlPointsUsed())

        {

            aCandidate = basegfx::utils::adaptiveSubdivideByAngle(rCandidate);

        }

        if(aCandidate.count())

        {

            const sal_uInt32 nLoopCount(aCandidate.isClosed() ? aCandidate.count() : aCandidate.count() - 1);

            rOutDev.SetFillColor();

            rOutDev.SetLineColor(aColor);

            for(sal_uInt32 a(0); a < nLoopCount; a++)

            {

                const basegfx::B2DPoint aBStart(aCandidate.getB2DPoint(a));

                const basegfx::B2DPoint aBEnd(aCandidate.getB2DPoint((a + 1) % aCandidate.count()));

                const Point aStart(basegfx::fround<tools::Long>(aBStart.getX()),

                                   basegfx::fround<tools::Long>(aBStart.getY()));

                const Point aEnd(basegfx::fround<tools::Long>(aBEnd.getX()),

                                 basegfx::fround<tools::Long>(aBEnd.getY()));

                rOutDev.DrawLine(aStart, aEnd);

            }

        }

    }

    void impTryTest(const SdrPageView& rPageView, OutputDevice& rOutDev)

    {

        if(rPageView.GetPage() && rPageView.GetPage()->GetObjCount() >= 2)

        {

            SdrPage* pPage = rPageView.GetPage();

            SdrObject* pObjA = pPage->GetObj(0);

            if(dynamic_cast<const SdrPathObj*>( pObjA))

            {

                basegfx::B2DPolyPolygon aPolyA(pObjA->GetPathPoly());

                aPolyA = basegfx::utils::correctOrientations(aPolyA);

                basegfx::B2DPolyPolygon aPolyB;

                for (const rtl::Reference<SdrObject>& pObjB : *rPageView.GetPage())

                {

                    if(dynamic_cast<const SdrPathObj*>( pObjB.get()))

                    {

                        basegfx::B2DPolyPolygon aCandidate(pObjB->GetPathPoly());

                        aCandidate = basegfx::utils::correctOrientations(aCandidate);

                        aPolyB.append(aCandidate);

                    }

                }

                if(aPolyA.count() && aPolyA.isClosed() && aPolyB.count())

                {

                    // poly A is the clipregion, clip poly b against it. Algo depends on

                    // poly b being closed.

                    basegfx::B2DPolyPolygon aResult(basegfx::utils::clipPolyPolygonOnPolyPolygon(aPolyB, aPolyA));

                    for(auto const& rPolygon : aResult)

                    {

                        int nR = comphelper::rng::uniform_int_distribution(0, 254);

                        int nG = comphelper::rng::uniform_int_distribution(0, 254);

                        int nB = comphelper::rng::uniform_int_distribution(0, 254);

                        Color aColor(nR, nG, nB);

                        impPaintStrokePolygon(rPolygon, rOutDev, aColor);

                    }

                }

            }

        }

    }

} // end of anonymous namespace

#endif // CLIPPER_TEST

void SdrPageWindow::RedrawAll( sdr::contact::ViewObjectContactRedirector* pRedirector )

{

    // set Redirector

    GetObjectContact().SetViewObjectContactRedirector(pRedirector);

    // set PaintingPageView

    const SdrView& rView = mpImpl->mrPageView.GetView();

    SdrModel& rModel = rView.GetModel();

    // get to be processed layers

    const bool bPrinter(GetPaintWindow().OutputToPrinter());

    SdrLayerIDSet aProcessLayers = bPrinter ? mpImpl->mrPageView.GetPrintableLayers() : mpImpl->mrPageView.GetVisibleLayers();

    // create PaintInfoRec; use Rectangle only temporarily

    const vcl::Region& rRegion = GetPaintWindow().GetRedrawRegion();

    // create processing data

    sdr::contact::DisplayInfo aDisplayInfo;

    // Draw all layers. do NOT draw form layer from CompleteRedraw, this is done separately

    // as a single layer paint

    const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin();

    const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName());

    aProcessLayers.Clear(nControlLayerId);

    // still something to paint?

    if(!aProcessLayers.IsEmpty())

    {

        aDisplayInfo.SetProcessLayers(aProcessLayers);

        // Set region as redraw area

        aDisplayInfo.SetRedrawArea(rRegion);

        // paint page

        GetObjectContact().ProcessDisplay(aDisplayInfo);

    }

    // reset redirector

    GetObjectContact().SetViewObjectContactRedirector(nullptr);

    // LineClip test

#ifdef CLIPPER_TEST

    if(true)

    {

        impTryTest(GetPageView(), GetPaintWindow().GetOutputDevice());

    }

#endif // CLIPPER_TEST

}

void SdrPageWindow::RedrawLayer(const SdrLayerID* pId,

        sdr::contact::ViewObjectContactRedirector* pRedirector,

        basegfx::B2IRectangle const*const pPageFrame)

{

    // set redirector

    GetObjectContact().SetViewObjectContactRedirector(pRedirector);

    // set PaintingPageView

    const SdrView& rView = mpImpl->mrPageView.GetView();

    SdrModel& rModel = rView.GetModel();

    // get the layers to process

    const bool bPrinter(GetPaintWindow().OutputToPrinter());

    SdrLayerIDSet aProcessLayers = bPrinter ? mpImpl->mrPageView.GetPrintableLayers() : mpImpl->mrPageView.GetVisibleLayers();

    // is the given layer visible at all?

    if(aProcessLayers.IsSet(*pId))

    {

        // find out if we are painting the ControlLayer

        const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin();

        const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName());

        const bool bControlLayerProcessingActive(nControlLayerId == *pId);

        // create PaintInfoRec, use Rectangle only temporarily

        const vcl::Region& rRegion = GetPaintWindow().GetRedrawRegion();

        // create processing data

        sdr::contact::DisplayInfo aDisplayInfo;

        // is it the control layer? If Yes, set flag

        aDisplayInfo.SetControlLayerProcessingActive(bControlLayerProcessingActive);

        // Draw just the one given layer

        aProcessLayers.ClearAll();

        aProcessLayers.Set(*pId);

        aDisplayInfo.SetProcessLayers(aProcessLayers);

        // Set region as redraw area

        aDisplayInfo.SetRedrawArea(rRegion);

        // Writer or calc, coming from original RedrawOneLayer.

        // #i72889# no page painting or MasterPage painting for layer painting

        const bool bOldPageDecorationAllowed(GetPageView().GetView().IsPageDecorationAllowed());

        const bool bOldMasterPageVisualizationAllowed(GetPageView().GetView().IsMasterPageVisualizationAllowed());

        GetPageView().GetView().SetPageDecorationAllowed(false);

        GetPageView().GetView().SetMasterPageVisualizationAllowed(false);

        if (pPageFrame) // Writer page frame for anchor based clipping

        {

            aDisplayInfo.SetWriterPageFrame(*pPageFrame);

        }

        // paint page

        GetObjectContact().ProcessDisplay(aDisplayInfo);

        // reset temporarily changed flags

        GetPageView().GetView().SetPageDecorationAllowed(bOldPageDecorationAllowed);

        GetPageView().GetView().SetMasterPageVisualizationAllowed(bOldMasterPageVisualizationAllowed);

    }

    // reset redirector

    GetObjectContact().SetViewObjectContactRedirector(nullptr);

}

// Invalidate call, used from ObjectContact(OfPageView) in InvalidatePartOfView(...)

void SdrPageWindow::InvalidatePageWindow(const basegfx::B2DRange& rRange)

{

    if (GetPageView().IsVisible() && GetPaintWindow().OutputToWindow())

    {

        OutputDevice& rWindow(GetPaintWindow().GetOutputDevice());

        basegfx::B2DRange aDiscreteRange(rRange);

        aDiscreteRange.transform(rWindow.GetViewTransformation());

        if (SvtOptionsDrawinglayer::IsAntiAliasing())

        {

            // invalidate one discrete unit more under the assumption that AA

            // needs one pixel more

            aDiscreteRange.grow(1.0);

        }

        // If the shapes use negative X coordinates, make them positive before sending

        // the invalidation rectangle.

        bool bNegativeX = mpImpl->mrPageView.GetView().IsNegativeX();

        const tools::Rectangle aVCLDiscreteRectangle(

            static_cast<tools::Long>(bNegativeX ? std::max(0.0, ceil(-aDiscreteRange.getMaxX())) : floor(aDiscreteRange.getMinX())),

            static_cast<tools::Long>(floor(aDiscreteRange.getMinY())),

            static_cast<tools::Long>(bNegativeX ? std::max(0.0, floor(-aDiscreteRange.getMinX())) : ceil(aDiscreteRange.getMaxX())),

            static_cast<tools::Long>(ceil(aDiscreteRange.getMaxY())));

        const bool bWasMapModeEnabled(rWindow.IsMapModeEnabled());

        rWindow.EnableMapMode(false);

        GetPageView().GetView().InvalidateOneWin(rWindow, aVCLDiscreteRectangle);

        rWindow.EnableMapMode(bWasMapModeEnabled);

    }

    else if (comphelper::LibreOfficeKit::isActive())

    {

        // we don't really have to have a paint window with LOK; OTOH we know

        // that the drawinglayer units are 100ths of mm, so they are easy to

        // convert to twips

        // If the shapes use negative X coordinates, make them positive before sending

        // the invalidation rectangle.

        bool bNegativeX = mpImpl->mrPageView.GetView().IsNegativeX();

        const tools::Rectangle aRect100thMM(

            static_cast<tools::Long>(bNegativeX ? std::max(0.0, ceil(-rRange.getMaxX())) : floor(rRange.getMinX())),

            static_cast<tools::Long>(floor(rRange.getMinY())),

            static_cast<tools::Long>(bNegativeX ? std::max(0.0, floor(-rRange.getMinX())) : ceil(rRange.getMaxX())),

            static_cast<tools::Long>(ceil(rRange.getMaxY())));

        const tools::Rectangle aRectTwips = o3tl::convert(aRect100thMM, o3tl::Length::mm100, o3tl::Length::twip);

        if (SfxViewShell* pViewShell = SfxViewShell::Current())

            SfxLokHelper::notifyInvalidation(pViewShell, &aRectTwips);

    }

}

// ObjectContact section

const sdr::contact::ObjectContact& SdrPageWindow::GetObjectContact() const

{

    if (!mpImpl->mpObjectContact)

    {

        mpImpl->mpObjectContact = GetPageView().GetView().createViewSpecificObjectContact(

            const_cast<SdrPageWindow&>(*this),

            "svx::svdraw::SdrPageWindow mpObjectContact");

    }

    return *mpImpl->mpObjectContact;

}

sdr::contact::ObjectContact& SdrPageWindow::GetObjectContact()

{

    if (!mpImpl->mpObjectContact)

    {

        mpImpl->mpObjectContact = GetPageView().GetView().createViewSpecificObjectContact(

             *this,

             "svx::svdraw::SdrPageWindow mpObjectContact" );

    }

    return *mpImpl->mpObjectContact;

}

bool SdrPageWindow::HasObjectContact() const

{

    return mpImpl->mpObjectContact != nullptr;

}

// #i26631#

void SdrPageWindow::ResetObjectContact()

{

    if (mpImpl->mpObjectContact)

    {

        delete mpImpl->mpObjectContact;

        mpImpl->mpObjectContact = nullptr;

    }

}

void SdrPageWindow::SetDesignMode( bool _bDesignMode ) const

{

    const sdr::contact::ObjectContactOfPageView* pOC = dynamic_cast< const sdr::contact::ObjectContactOfPageView* >( &GetObjectContact() );

    DBG_ASSERT( pOC, "SdrPageWindow::SetDesignMode: invalid object contact!" );

    if ( pOC )

        pOC->SetUNOControlsDesignMode( _bDesignMode );

}

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