/* -*- 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/config.h>

#include <utility>

#include "MasterPagesSelector.hxx"

#include "MasterPageContainer.hxx"

#include "DocumentHelper.hxx"

#include <pres.hxx>

#include <drawdoc.hxx>

#include <sdpage.hxx>

#include <app.hrc>

#include <DrawController.hxx>

#include <SlideSorterViewShell.hxx>

#include <vcl/commandevent.hxx>

#include <vcl/vclptr.hxx>

#include <ViewShellBase.hxx>

#include <o3tl/safeint.hxx>

#include <vcl/image.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/viewfrm.hxx>

#include <sfx2/sidebar/Theme.hxx>

#include <memory>

#include <vcl/svapp.hxx>

#include <vcl/virdev.hxx>

#include <vcl/weld/Builder.hxx>

#include <com/sun/star/ui/LayoutSize.hpp>

namespace sd::sidebar {

    /** menu entry that is executed as default action when the left mouse button is

        clicked over a master page.

    */

constexpr OUStringLiteral gsDefaultClickAction = u"applyselect";

// Sidebar

MasterPagesSelector::MasterPagesSelector(weld::Widget* pParent, SdDrawDocument& rDocument,

                                         ViewShellBase& rBase,

                                         std::shared_ptr<MasterPageContainer> pContainer,

                                         css::uno::Reference<css::ui::XSidebar> xSidebar,

                                         const OUString& rUIFileName, const OUString& rIconViewId)

    : PanelLayout(pParent, u"MasterPagePanel"_ustr, rUIFileName)

    , mpContainer(std::move(pContainer))

    , mxPreviewIconView(m_xBuilder->weld_icon_view(rIconViewId))

    , mrDocument(rDocument)

    , mrBase(rBase)

    , mxSidebar(std::move(xSidebar))

    , maUpdateTask(*this)

{

    mxPreviewIconView->connect_item_activated(LINK(this, MasterPagesSelector, MasterPageSelected));

    mxPreviewIconView->connect_command(LINK(this, MasterPagesSelector, CommandHdl));

    mxPreviewIconView->connect_query_tooltip(LINK(this, MasterPagesSelector, QueryTooltipHdl));

    Link<MasterPageContainerChangeEvent&,void> aChangeListener (LINK(this,MasterPagesSelector,ContainerChangeListener));

    mpContainer->AddChangeListener(aChangeListener);

    maUpdateTask.Start();

}

// Notebookbar

MasterPagesSelector::MasterPagesSelector(weld::Widget* pParent, SdDrawDocument& rDocument,

                                         ViewShellBase& rBase,

                                         std::shared_ptr<MasterPageContainer> pContainer,

                                         const OUString& rUIFileName, const OUString& rIconViewId)

    : PanelLayout(pParent, u"MasterPagePanel"_ustr, rUIFileName)

    , mpContainer(std::move(pContainer))

    , mxPreviewIconView(m_xBuilder->weld_icon_view(rIconViewId))

    , mrDocument(rDocument)

    , mrBase(rBase)

    , maUpdateTask(*this)

{

    mxPreviewIconView->connect_item_activated(LINK(this, MasterPagesSelector, MasterPageSelected));

    mxPreviewIconView->connect_command(LINK(this, MasterPagesSelector, CommandHdl));

    mxPreviewIconView->connect_query_tooltip(LINK(this, MasterPagesSelector, QueryTooltipHdl));

    Link<MasterPageContainerChangeEvent&,void> aChangeListener (LINK(this,MasterPagesSelector,ContainerChangeListener));

    mpContainer->AddChangeListener(aChangeListener);

    maUpdateTask.Start();

}

MasterPagesSelector::~MasterPagesSelector()

{

    Clear();

    UpdateLocks(ItemList());

    Link<MasterPageContainerChangeEvent&,void> aChangeListener (LINK(this,MasterPagesSelector,ContainerChangeListener));

    mpContainer->RemoveChangeListener(aChangeListener);

    mpContainer.reset();

    mxPreviewIconView.reset();

}

void MasterPagesSelector::LateInit()

{

    Fill();

}

void MasterPagesSelector::UpdateLocks (const ItemList& rItemList)

{

    ItemList aNewLockList;

    // In here we first lock the master pages in the given list and then

    // release the locks acquired in a previous call to this method.  When

    // this were done the other way round the lock count of some master

    // pages might drop temporarily to 0 and would lead to unnecessary

    // deletion and re-creation of MasterPageDescriptor objects.

    // Lock the master pages in the given list.

    for (const auto& rItem : rItemList)

    {

        mpContainer->AcquireToken(rItem);

        aNewLockList.push_back(rItem);

    }

    // Release the previously locked master pages.

    for (const auto& rPage : maLockedMasterPages)

        mpContainer->ReleaseToken(rPage);

    maLockedMasterPages.swap(aNewLockList);

}

void MasterPagesSelector::Fill()

{

    ::std::unique_ptr<ItemList> pItemList (new ItemList);

    Fill(*pItemList);

    UpdateLocks(*pItemList);

    UpdateItemList(std::move(pItemList));

}

OUString MasterPagesSelector::GetContextMenuUIFile() const

{

    return u"modules/simpress/ui/mastermenu.ui"_ustr;

}

IMPL_LINK_NOARG(MasterPagesSelector, MasterPageSelected, const weld::TreeIter&, bool)

{

    ExecuteCommand(gsDefaultClickAction);

    return true;

}

IMPL_LINK(MasterPagesSelector, CommandHdl, const CommandEvent&, rEvent, bool)

{

    if (rEvent.GetCommand() != CommandEventId::ContextMenu)

        return false;

    Point aPos;

    if (rEvent.IsMouseEvent())

    {

        aPos = rEvent.GetMousePosPixel();

        std::unique_ptr<weld::TreeIter> pIter = mxPreviewIconView->get_item_at_pos(aPos);

        if (!pIter)

            return false;

        mxPreviewIconView->select(*pIter);

    }

    else

    {

        std::unique_ptr<weld::TreeIter> pSelected = mxPreviewIconView->get_selected();

        if (!pSelected)

            return false;

        aPos = mxPreviewIconView->get_rect(*pSelected).Center();

    }

    ShowContextMenu(aPos);

    return true;

}

IMPL_LINK(MasterPagesSelector, QueryTooltipHdl, const weld::TreeIter&, iter, OUString)

{

    const OUString sId = mxPreviewIconView->get_id(iter);

    if (!sId.isEmpty())

        return mpContainer->GetPageNameForToken(sId.toUInt32());

    return OUString();

}

void MasterPagesSelector::ShowContextMenu(const Point& pPos)

{

    // Setup the menu.

    ::tools::Rectangle aRect(pPos, Size(1, 1));

    std::unique_ptr<weld::Builder> xBuilder(

        Application::CreateBuilder(mxPreviewIconView.get(), GetContextMenuUIFile()));

    std::unique_ptr<weld::Menu> xMenu(xBuilder->weld_menu(u"menu"_ustr));

    ProcessPopupMenu(*xMenu);

    // Show the menu.

    ExecuteCommand(xMenu->popup_at_rect(mxPreviewIconView.get(), aRect));

}

void MasterPagesSelector::ProcessPopupMenu(weld::Menu& rMenu)

{

    // Disable some entries.

    if (mpContainer->GetPreviewSize() == MasterPageContainer::SMALL)

        rMenu.set_sensitive(u"small"_ustr, false);

    else

        rMenu.set_sensitive(u"large"_ustr, false);

}

void MasterPagesSelector::ExecuteCommand(const OUString &rIdent)

{

    if (rIdent == "applyall")

    {

        mrBase.SetBusyState (true);

        AssignMasterPageToAllSlides (GetSelectedMasterPage());

        mrBase.SetBusyState (false);

    }

    else if (rIdent == "applyselect")

    {

        mrBase.SetBusyState (true);

        AssignMasterPageToSelectedSlides (GetSelectedMasterPage());

        mrBase.SetBusyState (false);

    }

    else if (rIdent == "large")

    {

        mrBase.SetBusyState (true);

        mpContainer->SetPreviewSize(MasterPageContainer::LARGE);

        mrBase.SetBusyState (false);

        if (mxSidebar.is())

            mxSidebar->requestLayout();

    }

    else if (rIdent == "small")

    {

        mrBase.SetBusyState (true);

        mpContainer->SetPreviewSize(MasterPageContainer::SMALL);

        mrBase.SetBusyState (false);

        if (mxSidebar.is())

            mxSidebar->requestLayout();

    }

    else if (rIdent == "edit")

    {

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

        uno::Reference<drawing::XDrawPage> xSelectedMaster;

        SdPage* pMasterPage = GetSelectedMasterPage();

        assert(pMasterPage); //rhbz#902884

        if (pMasterPage)

            xSelectedMaster.set(pMasterPage->getUnoPage(), uno::UNO_QUERY);

        SfxViewFrame& rViewFrame = mrBase.GetViewFrame();

        if (xSelectedMaster.is())

        {

            SfxDispatcher* pDispatcher = rViewFrame.GetDispatcher();

            if (pDispatcher != nullptr)

            {

                pDispatcher->Execute(SID_MASTERPAGE, SfxCallMode::SYNCHRON);

                mrBase.GetDrawController()->setCurrentPage(xSelectedMaster);

            }

        }

    }

    mxPreviewIconView->unselect_all();

}

IMPL_LINK(MasterPagesSelector, ContainerChangeListener, MasterPageContainerChangeEvent&, rEvent, void)

{

    NotifyContainerChangeEvent(rEvent);

}

SdPage* MasterPagesSelector::GetSelectedMasterPage()

{

    const ::osl::MutexGuard aGuard (maMutex);

    SdPage* pMasterPage = nullptr;

    OUString sSelectedId = mxPreviewIconView->get_selected_id();

    if (!sSelectedId.isEmpty())

    {

        const MasterPageContainer::Token aToken

            = static_cast<MasterPageContainer::Token>(sSelectedId.toInt32());

        pMasterPage = mpContainer->GetPageObjectForToken(aToken, true);

    }

    return pMasterPage;

}

/** Assemble a list of all slides of the document and pass it to

    AssignMasterPageToPageList().

*/

void MasterPagesSelector::AssignMasterPageToAllSlides (SdPage* pMasterPage)

{

    if (pMasterPage == nullptr)

        return;

    sal_uInt16 nPageCount = mrDocument.GetSdPageCount(PageKind::Standard);

    if (nPageCount == 0)

        return;

    // Get a list of all pages.  As a little optimization we only

    // include pages that do not already have the given master page

    // assigned.

    OUString sFullLayoutName(pMasterPage->GetLayoutName());

    ::sd::slidesorter::SharedPageSelection pPageList =

        std::make_shared<::sd::slidesorter::SlideSorterViewShell::PageSelection>();

    for (sal_uInt16 nPageIndex=0; nPageIndex<nPageCount; nPageIndex++)

    {

        SdPage* pPage = mrDocument.GetSdPage (nPageIndex, PageKind::Standard);

        if (pPage != nullptr && pPage->GetLayoutName() != sFullLayoutName)

        {

            pPageList->push_back (pPage);

        }

    }

    AssignMasterPageToPageList(pMasterPage, pPageList);

}

/** Assemble a list of the currently selected slides (selected in a visible

    slide sorter) and pass it to AssignMasterPageToPageList().

*/

void MasterPagesSelector::AssignMasterPageToSelectedSlides (

    SdPage* pMasterPage)

{

    using namespace ::sd::slidesorter;

    using namespace ::sd::slidesorter::controller;

    if (pMasterPage == nullptr)

        return;

    // Find a visible slide sorter.

    SlideSorterViewShell* pSlideSorter = SlideSorterViewShell::GetSlideSorter(mrBase);

    if (pSlideSorter == nullptr)

        return;

    // Get a list of selected pages.

    SharedPageSelection pPageSelection = pSlideSorter->GetPageSelection();

    if (pPageSelection->empty())

        return;

    AssignMasterPageToPageList(pMasterPage, pPageSelection);

    // Restore the previous selection.

    pSlideSorter->SetPageSelection(pPageSelection);

}

void MasterPagesSelector::AssignMasterPageToPageList (

    SdPage* pMasterPage,

    const std::shared_ptr<std::vector<SdPage*>>& rPageList)

{

    DocumentHelper::AssignMasterPageToPageList(mrDocument, pMasterPage, rPageList);

}

void MasterPagesSelector::NotifyContainerChangeEvent (const MasterPageContainerChangeEvent& rEvent)

{

    const ::osl::MutexGuard aGuard (maMutex);

    switch (rEvent.meEventType)

    {

        case MasterPageContainerChangeEvent::EventType::SIZE_CHANGED:

            UpdateAllPreviews();

            break;

        case MasterPageContainerChangeEvent::EventType::PREVIEW_CHANGED:

        {

            int nIndex (GetIndexForToken(rEvent.maChildToken));

            if (nIndex >= 0)

            {

                Image aPreview(mpContainer->GetPreviewForToken(rEvent.maChildToken));

                if (aPreview.GetSizePixel().Width() > 0)

                {

                    mxPreviewIconView->set_image(nIndex, *GetVirtualDevice(aPreview));

                }

            }

        }

        break;

        case MasterPageContainerChangeEvent::EventType::DATA_CHANGED:

        {

            InvalidateItem(rEvent.maChildToken);

            Fill();

        }

        break;

        case MasterPageContainerChangeEvent::EventType::CHILD_REMOVED:

        {

            int nIndex (GetIndexForToken(rEvent.maChildToken));

            SetItem(nIndex, MasterPageContainer::NIL_TOKEN);

            break;

        }

        default:

            break;

   }

}

std::unique_ptr<MasterPagesSelector::UserData> MasterPagesSelector::GetUserData(int nIndex) const

{

    const ::osl::MutexGuard aGuard(maMutex);

    if (nIndex >= 0 && nIndex < mxPreviewIconView->n_children())

    {

        const MasterPageContainer::Token aToken

            = static_cast<MasterPageContainer::Token>(mxPreviewIconView->get_id(nIndex).toInt32());

        return std::make_unique<UserData>(std::make_pair(nIndex, aToken));

    }

    else

        return nullptr;

}

void MasterPagesSelector::SetItem (

    sal_uInt16 nIndex,

    MasterPageContainer::Token aToken)

{

    const ::osl::MutexGuard aGuard (maMutex);

    RemoveTokenToIndexEntry(nIndex, aToken);

    mxPreviewIconView->freeze();

    if (aToken != MasterPageContainer::NIL_TOKEN)

    {

        Image aPreview (mpContainer->GetPreviewForToken(aToken));

        MasterPageContainer::PreviewState eState (mpContainer->GetPreviewState(aToken));

        if (aPreview.GetSizePixel().Width() > 0)

        {

            if (!mxPreviewIconView->get_id(nIndex).isEmpty())

            {

                mxPreviewIconView->set_image(nIndex, *GetVirtualDevice(aPreview));

                mxPreviewIconView->set_id(nIndex, OUString::number(aToken));

            }

            else

            {

                Bitmap aPreviewBitmap = GetPreviewAsBitmap(aPreview);

                OUString sId = OUString::number(aToken);

                mxPreviewIconView->insert(nIndex, nullptr, &sId, &aPreviewBitmap, nullptr);

                mxPreviewIconView->set_item_accessible_name(

                    nIndex, mpContainer->GetPageNameForToken(aToken));

            }

            AddTokenToIndexEntry(nIndex, aToken);

        }

        if (eState == MasterPageContainer::PS_CREATABLE)

            mpContainer->RequestPreview(aToken);

    }

    else

    {

        mxPreviewIconView->remove(nIndex);

    }

    mxPreviewIconView->thaw();

}

void MasterPagesSelector::AddTokenToIndexEntry (

    sal_uInt16 nIndex,

    MasterPageContainer::Token aToken)

{

    const ::osl::MutexGuard aGuard (maMutex);

    maTokenToValueSetIndex[aToken] = nIndex;

}

void MasterPagesSelector::RemoveTokenToIndexEntry (

    sal_uInt16 nIndex,

    MasterPageContainer::Token aNewToken)

{

    const ::osl::MutexGuard aGuard (maMutex);

    std::unique_ptr<UserData> pData = GetUserData(nIndex);

    if (pData != nullptr)

    {

        // Get the token that the index pointed to previously.

        MasterPageContainer::Token aOldToken (pData->second);

        if (aNewToken != aOldToken

            && nIndex == GetIndexForToken(aOldToken))

        {

            maTokenToValueSetIndex[aOldToken] = -1;

        }

    }

}

void MasterPagesSelector::InvalidatePreview (const SdPage* pPage)

{

    const ::osl::MutexGuard aGuard (maMutex);

    for (int nIndex = 0; nIndex < mxPreviewIconView->n_children(); nIndex++)

    {

        std::unique_ptr<UserData> pData = GetUserData(nIndex);

        if (pData != nullptr)

        {

            MasterPageContainer::Token aToken (pData->second);

            if (pPage == mpContainer->GetPageObjectForToken(aToken,false))

            {

                mpContainer->InvalidatePreview(aToken);

                mpContainer->RequestPreview(aToken);

                break;

            }

        }

    }

}

ScopedVclPtr<VirtualDevice> MasterPagesSelector::GetVirtualDevice(const Image& rImage)

{

    Bitmap aPreviewBitmap = rImage.GetBitmap();

    VclPtr<VirtualDevice> pVDev = VclPtr<VirtualDevice>::Create();

    const Point aNull(0, 0);

    if (pVDev->GetDPIScaleFactor() > 1)

        aPreviewBitmap.Scale(pVDev->GetDPIScaleFactor(), pVDev->GetDPIScaleFactor());

    const Size aSize(aPreviewBitmap.GetSizePixel());

    pVDev->SetOutputSizePixel(aSize);

    pVDev->DrawBitmap(aNull, aPreviewBitmap);

    return pVDev;

}

Bitmap MasterPagesSelector::GetPreviewAsBitmap(const Image& rImage)

{

    Bitmap aPreviewBitmap(rImage.GetBitmap());

    ScopedVclPtr<VirtualDevice> pVDev = VclPtr<VirtualDevice>::Create();

    if (pVDev->GetDPIScaleFactor() > 1)

        aPreviewBitmap.Scale(pVDev->GetDPIScaleFactor(), pVDev->GetDPIScaleFactor());

    return aPreviewBitmap;

}

void MasterPagesSelector::UpdateAllPreviews()

{

    const ::osl::MutexGuard aGuard (maMutex);

    mxPreviewIconView->freeze();

    for (int aIndex = 0; aIndex < mxPreviewIconView->n_children(); aIndex++)

    {

        const MasterPageContainer::Token aToken

            = static_cast<MasterPageContainer::Token>(mxPreviewIconView->get_id(aIndex).toInt32());

        Image aPreview(mpContainer->GetPreviewForToken(aToken));

        if (aPreview.GetSizePixel().Width() > 0)

        {

            mxPreviewIconView->set_image(aIndex, *GetVirtualDevice(aPreview));

        }

        else if (mpContainer->GetPreviewState(aToken) == MasterPageContainer::PS_CREATABLE)

        {

            mpContainer->RequestPreview(aToken);

        }

    }

    mxPreviewIconView->thaw();

}

void MasterPagesSelector::ClearPageSet()

{

    const ::osl::MutexGuard aGuard (maMutex);

    mxPreviewIconView->clear();

}

void MasterPagesSelector::SetHelpId( const OUString& aId )

{

    const ::osl::MutexGuard aGuard (maMutex);

    mxPreviewIconView->set_help_id(aId);

}

sal_Int32 MasterPagesSelector::GetIndexForToken (MasterPageContainer::Token aToken) const

{

    const ::osl::MutexGuard aGuard (maMutex);

    TokenToValueSetIndex::const_iterator iIndex (maTokenToValueSetIndex.find(aToken));

    if (iIndex != maTokenToValueSetIndex.end())

        return iIndex->second;

    else

        return -1;

}

void MasterPagesSelector::Clear()

{

    const ::osl::MutexGuard aGuard (maMutex);

    ClearPageSet();

}

void MasterPagesSelector::InvalidateItem (MasterPageContainer::Token aToken)

{

    const ::osl::MutexGuard aGuard (maMutex);

    auto iItem = std::find(maCurrentItemList.begin(), maCurrentItemList.end(), aToken);

    if (iItem != maCurrentItemList.end())

        *iItem = MasterPageContainer::NIL_TOKEN;

}

void MasterPagesSelector::UpdateItemList (::std::unique_ptr<ItemList> && pNewItemList)

{

    const ::osl::MutexGuard aGuard (maMutex);

    ItemList::const_iterator iNewItem (pNewItemList->begin());

    ItemList::const_iterator iCurrentItem (maCurrentItemList.begin());

    ItemList::const_iterator iNewEnd (pNewItemList->end());

    ItemList::const_iterator iCurrentEnd (maCurrentItemList.end());

    sal_uInt16 nIndex(0);

    // Update existing items.

    for ( ; iNewItem!=iNewEnd && iCurrentItem!=iCurrentEnd; ++iNewItem, ++iCurrentItem,++nIndex)

    {

        if (*iNewItem != *iCurrentItem)

        {

            SetItem(nIndex,*iNewItem);

        }

    }

    // Append new items.

    for ( ; iNewItem!=iNewEnd; ++iNewItem,++nIndex)

    {

        SetItem(nIndex,*iNewItem);

    }

    // Remove trailing items.

    for ( ; iCurrentItem!=iCurrentEnd; ++iCurrentItem,++nIndex)

    {

        SetItem(nIndex,MasterPageContainer::NIL_TOKEN);

    }

    maCurrentItemList.swap(*pNewItemList);

    if (mxSidebar.is())

        mxSidebar->requestLayout();

}

css::ui::LayoutSize MasterPagesSelector::GetHeightForWidth(const sal_Int32 nWidth)

{

    // there is no way to get margin of item programmatically, we use value provided in ui file.

    const int nMargin = 6;

    const Size& previewSize = mpContainer->GetPreviewSizePixel();

    sal_Int32 nColumnCount = nWidth / (previewSize.Width() + (2 * nMargin));

    if (nColumnCount < 1)

        nColumnCount = 1;

    sal_Int32 nTotalItems = mxPreviewIconView->n_children();

    sal_Int32 nRowCount = (nTotalItems + nColumnCount - 1) / nColumnCount;

    if (nRowCount < 1)

        nRowCount = 1;

    sal_Int32 nPreferedHeight = nRowCount * (previewSize.getHeight() + (4 * nMargin));

    return css::ui::LayoutSize(nPreferedHeight, nPreferedHeight, nPreferedHeight);

}

} // end of namespace sd::sidebar

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