/* -*- 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 "moduldlg.hxx"
#include <basidesh.hxx>
#include <strings.hrc>
#include <bitmaps.hlst>
#include <iderdll.hxx>
#include "iderdll2.hxx"
#include <iderid.hxx>
#include <basobj.hxx>
#include <svx/passwd.hxx>
#include <ucbhelper/content.hxx>
#include <rtl/uri.hxx>
#include <sfx2/app.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/filedlghelper.hxx>
#include <sfx2/request.hxx>
#include <sfx2/sfxsids.hrc>
#include <sfx2/viewfrm.hxx>
#include <svl/stritem.hxx>
#include <tools/debug.hxx>
#include <tools/urlobj.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <vcl/svapp.hxx>
#include <vcl/weld.hxx>

#include <com/sun/star/io/Pipe.hpp>
#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
#include <com/sun/star/ui/dialogs/XFolderPicker2.hpp>
#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
#include <com/sun/star/script/DocumentScriptLibraryContainer.hpp>
#include <com/sun/star/script/DocumentDialogLibraryContainer.hpp>
#include <com/sun/star/script/XLibraryContainerPassword.hpp>
#include <com/sun/star/script/XLibraryContainerExport.hpp>
#include <com/sun/star/task/InteractionHandler.hpp>
#include <com/sun/star/ucb/SimpleFileAccess.hpp>
#include <com/sun/star/ucb/XCommandEnvironment.hpp>
#include <com/sun/star/ucb/NameClash.hpp>
#include <com/sun/star/packages/manifest/ManifestWriter.hpp>
#include <unotools/pathoptions.hxx>

#include <com/sun/star/util/VetoException.hpp>
#include <com/sun/star/script/ModuleSizeExceededRequest.hpp>

#include <comphelper/processfactory.hxx>
#include <comphelper/propertysequence.hxx>
#include <cppuhelper/implbase.hxx>
#include <o3tl/string_view.hxx>

#include <cassert>

namespace basctl
{

using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::ucb;
using namespace ::com::sun::star::ui::dialogs;

namespace
{

class DummyInteractionHandler  : public ::cppu::WeakImplHelper< task::XInteractionHandler >
{
    Reference< task::XInteractionHandler2 > m_xHandler;
public:
    explicit DummyInteractionHandler(const Reference<task::XInteractionHandler2>& xHandler)
        : m_xHandler(xHandler)
    {
    }

    virtual void SAL_CALL handle( const Reference< task::XInteractionRequest >& rRequest ) override
    {
        if ( m_xHandler.is() )
        {
            script::ModuleSizeExceededRequest aModSizeException;
            if ( rRequest->getRequest() >>= aModSizeException )
                m_xHandler->handle( rRequest );
        }
    }
};

} // namespace

namespace
{
    int FindEntry(const weld::TreeView& rBox, std::u16string_view rName)
    {
        int nCount = rBox.n_children();
        for (int i = 0; i < nCount; ++i)
        {
            if (o3tl::equalsIgnoreAsciiCase(rName, rBox.get_text(i, 0)))
                return i;
        }
        return -1;
    }
}

// NewObjectDialog
IMPL_LINK_NOARG(NewObjectDialog, OkButtonHandler, weld::Button&, void)
{
    if (!m_bCheckName || IsValidSbxName(m_xEdit->get_text()))
        m_xDialog->response(RET_OK);
    else
    {
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_xDialog.get(),
                                                       VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_BADSBXNAME)));
        xErrorBox->run();
        m_xEdit->grab_focus();
    }
}

NewObjectDialog::NewObjectDialog(weld::Window * pParent, ObjectMode eMode, bool bCheckName)
    : GenericDialogController(pParent, u"modules/BasicIDE/ui/newlibdialog.ui"_ustr, u"NewLibDialog"_ustr)
    , m_xEdit(m_xBuilder->weld_entry(u"entry"_ustr))
    , m_xOKButton(m_xBuilder->weld_button(u"ok"_ustr))
    , m_bCheckName(bCheckName)
{
    switch (eMode)
    {
        case ObjectMode::Library:
            m_xDialog->set_title(IDEResId(RID_STR_NEWLIB));
            break;
        case ObjectMode::Module:
            m_xDialog->set_title(IDEResId(RID_STR_NEWMOD));
            break;
        case ObjectMode::Dialog:
            m_xDialog->set_title(IDEResId(RID_STR_NEWDLG));
            break;
        default:
            assert(false);
    }
    m_xOKButton->connect_clicked(LINK(this, NewObjectDialog, OkButtonHandler));
}

// GotoLineDialog
GotoLineDialog::GotoLineDialog(weld::Window* pParent, sal_uInt32 nCurLine, sal_uInt32 nLineCount)
    : GenericDialogController(pParent, u"modules/BasicIDE/ui/gotolinedialog.ui"_ustr, u"GotoLineDialog"_ustr)
    , m_xSpinButton(m_xBuilder->weld_spin_button(u"spin"_ustr))
    , m_xLineCount(m_xBuilder->weld_label(u"line_count"_ustr))
    , m_xOKButton(m_xBuilder->weld_button(u"ok"_ustr))
    , m_nCurLine(nCurLine)
    , m_nLineCount(nLineCount)
{
    // Adjust line count label
    OUString sLabel = m_xLineCount->get_label();
    m_xLineCount->set_label(sLabel.replaceFirst("$1", OUString::number(m_nLineCount)));

    // Initialize the spin button
    m_xSpinButton->set_text(OUString::number(m_nCurLine));
    m_xSpinButton->set_range(1, m_nLineCount);
    m_xSpinButton->grab_focus();
    m_xSpinButton->select_region(0, -1);

    m_xOKButton->connect_clicked(LINK(this, GotoLineDialog, OkButtonHandler));
}

GotoLineDialog::~GotoLineDialog()
{
}

sal_Int32 GotoLineDialog::GetLineNumber() const
{
    return m_xSpinButton->get_text().toInt32();
}

IMPL_LINK_NOARG(GotoLineDialog, OkButtonHandler, weld::Button&, void)
{
    // The number must be in the range between 1 and the number of lines in the module
    sal_Int32 nNumber = GetLineNumber();
    if (nNumber && nNumber >= 1 && nNumber <= static_cast<sal_Int32>(m_nLineCount))
    {
        m_xDialog->response(RET_OK);
    }
    else
    {
        m_xSpinButton->set_text(OUString::number(m_nCurLine));
        m_xSpinButton->select_region(0, -1);
    }
}

// ExportDialog
IMPL_LINK_NOARG(ExportDialog, OkButtonHandler, weld::Button&, void)
{
    m_bExportAsPackage = m_xExportAsPackageButton->get_active();
    m_xDialog->response(RET_OK);
}

ExportDialog::ExportDialog(weld::Window * pParent)
    : GenericDialogController(pParent, u"modules/BasicIDE/ui/exportdialog.ui"_ustr, u"ExportDialog"_ustr)
    , m_bExportAsPackage(false)
    , m_xExportAsPackageButton(m_xBuilder->weld_radio_button(u"extension"_ustr))
    , m_xOKButton(m_xBuilder->weld_button(u"ok"_ustr))
{
    m_xExportAsPackageButton->set_active(true);
    m_xOKButton->connect_clicked(LINK(this, ExportDialog, OkButtonHandler));
}

ExportDialog::~ExportDialog()
{
}

// LibPage
LibPage::LibPage(weld::Container* pParent, OrganizeDialog* pDialog)
    : OrganizePage(pParent, u"modules/BasicIDE/ui/libpage.ui"_ustr, u"LibPage"_ustr, pDialog)
    , m_xBasicsBox(m_xBuilder->weld_combo_box(u"location"_ustr))
    , m_xLibBox(m_xBuilder->weld_tree_view(u"library"_ustr))
    , m_xEditButton(m_xBuilder->weld_button(u"edit"_ustr))
    , m_xPasswordButton(m_xBuilder->weld_button(u"password"_ustr))
    , m_xNewLibButton(m_xBuilder->weld_button(u"new"_ustr))
    , m_xInsertLibButton(m_xBuilder->weld_button(u"import"_ustr))
    , m_xExportButton(m_xBuilder->weld_button(u"export"_ustr))
    , m_xDelButton(m_xBuilder->weld_button(u"delete"_ustr))
    , m_aCurDocument(ScriptDocument::getApplicationScriptDocument())
    , m_eCurLocation(LIBRARY_LOCATION_UNKNOWN)
{
    Size aSize(m_xLibBox->get_approximate_digit_width() * 40,
               m_xLibBox->get_height_rows(10));
    m_xLibBox->set_size_request(aSize.Width(), aSize.Height());

    // tdf#93476 The libraries should be listed alphabetically
    m_xLibBox->make_sorted();

    m_xEditButton->connect_clicked( LINK( this, LibPage, ButtonHdl ) );
    m_xNewLibButton->connect_clicked( LINK( this, LibPage, ButtonHdl ) );
    m_xPasswordButton->connect_clicked( LINK( this, LibPage, ButtonHdl ) );
    m_xExportButton->connect_clicked( LINK( this, LibPage, ButtonHdl ) );
    m_xInsertLibButton->connect_clicked( LINK( this, LibPage, ButtonHdl ) );
    m_xDelButton->connect_clicked( LINK( this, LibPage, ButtonHdl ) );
    m_xLibBox->connect_selection_changed(LINK(this, LibPage, TreeListHighlightHdl));

    m_xBasicsBox->connect_changed( LINK( this, LibPage, BasicSelectHdl ) );

    m_xLibBox->connect_editing(LINK(this, LibPage, EditingEntryHdl),
                               LINK(this, LibPage, EditedEntryHdl));

    FillListBox();
    m_xBasicsBox->set_active(0);
    SetCurLib();

    CheckButtons();
}

IMPL_LINK(LibPage, EditingEntryHdl, const weld::TreeIter&, rIter, bool)
{
    // check, if Standard library
    OUString aLibName = m_xLibBox->get_text(rIter, 0);

    if ( aLibName.equalsIgnoreAsciiCase( "Standard" ) )
    {
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_pDialog->getDialog(),
                                                       VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_CANNOTCHANGENAMESTDLIB)));
        xErrorBox->run();
        return false;
    }

    // check, if library is readonly
    Reference< script::XLibraryContainer2 > xModLibContainer( m_aCurDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
    Reference< script::XLibraryContainer2 > xDlgLibContainer( m_aCurDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY );
    if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && xModLibContainer->isLibraryReadOnly( aLibName ) && !xModLibContainer->isLibraryLink( aLibName ) ) ||
         ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) && xDlgLibContainer->isLibraryReadOnly( aLibName ) && !xDlgLibContainer->isLibraryLink( aLibName ) ) )
    {
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_pDialog->getDialog(),
                                                       VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_LIBISREADONLY)));
        xErrorBox->run();
        return false;
    }

    // i24094: Password verification necessary for renaming
    if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && !xModLibContainer->isLibraryLoaded( aLibName ) )
    {
        bool bOK = true;
        // check password
        Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
        if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aLibName ) && !xPasswd->isLibraryPasswordVerified( aLibName ) )
        {
            OUString aPassword;
            bOK = QueryPassword(m_pDialog->getDialog(), xModLibContainer, aLibName, aPassword);
        }
        if ( !bOK )
            return false;
    }

    // TODO: check if library is reference/link

    return true;
}

IMPL_LINK(LibPage, EditedEntryHdl, const IterString&, rIterString, bool)
{
    const weld::TreeIter& rIter = rIterString.first;
    OUString sNewName = rIterString.second;

    bool bValid = sNewName.getLength() <= 30 && IsValidSbxName(sNewName);
    OUString aOldName(m_xLibBox->get_text(rIter, 0));

    if (bValid && aOldName != sNewName)
    {
        try
        {
            Reference< script::XLibraryContainer2 > xModLibContainer( m_aCurDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
            if ( xModLibContainer.is() )
                xModLibContainer->renameLibrary( aOldName, sNewName );

            Reference< script::XLibraryContainer2 > xDlgLibContainer( m_aCurDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY );
            if ( xDlgLibContainer.is() )
                xDlgLibContainer->renameLibrary( aOldName, sNewName );

            MarkDocumentModified( m_aCurDocument );
            if (SfxBindings* pBindings = GetBindingsPtr())
            {
                pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR );
                pBindings->Update( SID_BASICIDE_LIBSELECTOR );
            }
        }
        catch (const container::ElementExistException& )
        {
            std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_pDialog->getDialog(),
                                                           VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_SBXNAMEALLREADYUSED)));
            xErrorBox->run();
            return false;
        }
        catch (const container::NoSuchElementException& )
        {
            DBG_UNHANDLED_EXCEPTION("basctl.basicide");
            return false;
        }
    }

    if ( !bValid )
    {
        OUString sWarning(sNewName.getLength() > 30 ? IDEResId(RID_STR_LIBNAMETOLONG) : IDEResId(RID_STR_BADSBXNAME));
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_pDialog->getDialog(),
                                                       VclMessageType::Warning, VclButtonsType::Ok, sWarning));
        xErrorBox->run();

    }

    return bValid;
}

LibPage::~LibPage()
{
    if (m_xBasicsBox)
    {
        const sal_Int32 nCount = m_xBasicsBox->get_count();
        for (sal_Int32 i = 0; i < nCount; ++i)
        {
            DocumentEntry* pEntry = weld::fromId<DocumentEntry*>(m_xBasicsBox->get_id(i));
            delete pEntry;
        }
    }
}

void LibPage::CheckButtons()
{
    std::unique_ptr<weld::TreeIter> xCur(m_xLibBox->make_iterator());
    if (!m_xLibBox->get_cursor(xCur.get()))
        return;

    OUString aLibName = m_xLibBox->get_text(*xCur, 0);
    Reference< script::XLibraryContainer2 > xModLibContainer( m_aCurDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
    Reference< script::XLibraryContainer2 > xDlgLibContainer( m_aCurDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY );

    if ( m_eCurLocation == LIBRARY_LOCATION_SHARE )
    {
        m_xPasswordButton->set_sensitive(false);
        m_xNewLibButton->set_sensitive(false);
        m_xInsertLibButton->set_sensitive(false);
        m_xDelButton->set_sensitive(false);
    }
    else if ( aLibName.equalsIgnoreAsciiCase( "Standard" ) )
    {
        m_xPasswordButton->set_sensitive(false);
        m_xNewLibButton->set_sensitive(true);
        m_xInsertLibButton->set_sensitive(true);
        m_xExportButton->set_sensitive(false);
        m_xDelButton->set_sensitive(false);
    }
    else if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && xModLibContainer->isLibraryReadOnly( aLibName ) ) ||
              ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) && xDlgLibContainer->isLibraryReadOnly( aLibName ) ) )
    {
        m_xPasswordButton->set_sensitive(false);
        m_xNewLibButton->set_sensitive(true);
        m_xInsertLibButton->set_sensitive(true);
        if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && xModLibContainer->isLibraryReadOnly( aLibName ) && !xModLibContainer->isLibraryLink( aLibName ) ) ||
             ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) && xDlgLibContainer->isLibraryReadOnly( aLibName ) && !xDlgLibContainer->isLibraryLink( aLibName ) ) )
            m_xDelButton->set_sensitive(false);
        else
            m_xDelButton->set_sensitive(true);
    }
    else
    {
        if ( xModLibContainer.is() && !xModLibContainer->hasByName( aLibName ) )
            m_xPasswordButton->set_sensitive(false);
        else
            m_xPasswordButton->set_sensitive(true);

        m_xNewLibButton->set_sensitive(true);
        m_xInsertLibButton->set_sensitive(true);
        m_xExportButton->set_sensitive(true);
        m_xDelButton->set_sensitive(true);
    }
}

void LibPage::ActivatePage()
{
    SetCurLib();
}

IMPL_LINK_NOARG(LibPage, TreeListHighlightHdl, weld::TreeView&, void)
{
    CheckButtons();
}

IMPL_LINK_NOARG( LibPage, BasicSelectHdl, weld::ComboBox&, void )
{
    SetCurLib();
    CheckButtons();
}

IMPL_LINK( LibPage, ButtonHdl, weld::Button&, rButton, void )
{
    if (&rButton == m_xEditButton.get())
    {
        SfxAllItemSet aArgs( SfxGetpApp()->GetPool() );
        SfxRequest aRequest( SID_BASICIDE_APPEAR, SfxCallMode::SYNCHRON, aArgs );
        SfxGetpApp()->ExecuteSlot( aRequest );

        SfxUnoAnyItem aDocItem( SID_BASICIDE_ARG_DOCUMENT_MODEL, Any( m_aCurDocument.getDocumentOrNull() ) );

        std::unique_ptr<weld::TreeIter> xCurEntry(m_xLibBox->make_iterator());
        if (!m_xLibBox->get_cursor(xCurEntry.get()))
            return;
        OUString aLibName(m_xLibBox->get_text(*xCurEntry, 0));
        SfxStringItem aLibNameItem( SID_BASICIDE_ARG_LIBNAME, aLibName );
        if (SfxDispatcher* pDispatcher = GetDispatcher())
            pDispatcher->ExecuteList( SID_BASICIDE_LIBSELECTED,
                SfxCallMode::ASYNCHRON, { &aDocItem, &aLibNameItem });
        EndTabDialog();
        return;
    }
    else if (&rButton == m_xNewLibButton.get())
        NewLib();
    else if (&rButton == m_xInsertLibButton.get())
        InsertLib();
    else if (&rButton == m_xExportButton.get())
    {
        std::unique_ptr<weld::TreeIter> xCurEntry(m_xLibBox->make_iterator());
        if (!m_xLibBox->get_cursor(xCurEntry.get()))
            return;
        OUString aLibName(m_xLibBox->get_text(*xCurEntry, 0));
        Export(m_aCurDocument, aLibName, m_pDialog->getDialog());
    }
    else if (&rButton == m_xDelButton.get())
        DeleteCurrent();
    else if (&rButton == m_xPasswordButton.get())
    {
        std::unique_ptr<weld::TreeIter> xCurEntry(m_xLibBox->make_iterator());
        if (!m_xLibBox->get_cursor(xCurEntry.get()))
            return;
        OUString aLibName(m_xLibBox->get_text(*xCurEntry, 0));

        // load module library (if not loaded)
        Reference< script::XLibraryContainer > xModLibContainer = m_aCurDocument.getLibraryContainer( E_SCRIPTS );
        if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && !xModLibContainer->isLibraryLoaded( aLibName ) )
        {
            Shell* pShell = GetShell();
            if (pShell)
                pShell->GetViewFrame().GetWindow().EnterWait();
            xModLibContainer->loadLibrary( aLibName );
            if (pShell)
                pShell->GetViewFrame().GetWindow().LeaveWait();
        }

        // load dialog library (if not loaded)
        Reference< script::XLibraryContainer > xDlgLibContainer = m_aCurDocument.getLibraryContainer( E_DIALOGS );
        if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) && !xDlgLibContainer->isLibraryLoaded( aLibName ) )
        {
            Shell* pShell = GetShell();
            if (pShell)
                pShell->GetViewFrame().GetWindow().EnterWait();
            xDlgLibContainer->loadLibrary( aLibName );
            if (pShell)
                pShell->GetViewFrame().GetWindow().LeaveWait();
        }

        // check, if library is password protected
        if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
        {
            Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
            if ( xPasswd.is() )
            {
                bool const bProtected = xPasswd->isLibraryPasswordProtected( aLibName );

                // change password dialog
                SvxPasswordDialog aDlg(m_pDialog->getDialog(), !bProtected);
                aDlg.SetCheckPasswordHdl(LINK(this, LibPage, CheckPasswordHdl));

                if (aDlg.run() == RET_OK)
                {
                    bool const bNewProtected = xPasswd->isLibraryPasswordProtected( aLibName );

                    if ( bNewProtected != bProtected )
                    {
                        int nPos = m_xLibBox->get_iter_index_in_parent(*xCurEntry);
                        m_xLibBox->remove(*xCurEntry);
                        ImpInsertLibEntry(aLibName, nPos);
                        m_xLibBox->set_cursor(nPos);
                    }

                    MarkDocumentModified( m_aCurDocument );
                }
            }
        }
    }
    CheckButtons();
}

IMPL_LINK( LibPage, CheckPasswordHdl, SvxPasswordDialog *, pDlg, bool )
{
    bool bRet = false;

    std::unique_ptr<weld::TreeIter> xCurEntry(m_xLibBox->make_iterator());
    if (!m_xLibBox->get_cursor(xCurEntry.get()))
        return bRet;

    OUString aLibName(m_xLibBox->get_text(*xCurEntry, 0));
    Reference< script::XLibraryContainerPassword > xPasswd( m_aCurDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );

    if ( xPasswd.is() )
    {
        try
        {
            OUString aOldPassword( pDlg->GetOldPassword() );
            OUString aNewPassword( pDlg->GetNewPassword() );
            xPasswd->changeLibraryPassword( aLibName, aOldPassword, aNewPassword );
            bRet = true;
        }
        catch (...)
        {
        }
    }

    return bRet;
}

void LibPage::NewLib()
{
    createLibImpl(m_pDialog->getDialog(), m_aCurDocument, m_xLibBox.get(), nullptr);
}

void LibPage::InsertLib()
{
    auto remove_entry = [this](OUString& rLibName) { // remove listbox entry
        int nEntry = FindEntry(*m_xLibBox, rLibName);
        if (nEntry != -1)
            m_xLibBox->remove(nEntry);
    };

    auto insert_entry = [this](OUString& rLibName) { // insert listbox entry
        m_xLibBox->make_unsorted();
        ImpInsertLibEntry(rLibName, m_xLibBox->n_children());
        m_xLibBox->make_sorted();
        m_xLibBox->set_cursor(m_xLibBox->find_text(rLibName));
    };

    ImportLib(m_aCurDocument, m_pDialog->getDialog(), remove_entry, insert_entry, {});
}

void ImportLib(const ScriptDocument& rDocument, weld::Dialog* pDialog,
               const std::function<void(OUString& rLibName)>& func_remove_entry,
               const std::function<void(OUString& rLibName)>& func_insert_entry,
               const std::function<void()>& func_insert_entries)
{
    basctl::EnsureIde();

    const Reference< uno::XComponentContext >& xContext( ::comphelper::getProcessComponentContext() );
    // file open dialog
    sfx2::FileDialogHelper aDlg(ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, FileDialogFlags::NONE, pDialog);
    aDlg.SetContext(sfx2::FileDialogHelper::BasicInsertLib);
    const Reference <XFilePicker3>& xFP = aDlg.GetFilePicker();

    xFP->setTitle(IDEResId(RID_STR_APPENDLIBS));

    // filter
    OUString aTitle(IDEResId(RID_STR_BASIC));
    xFP->appendFilter( aTitle, u"*.sbl;*.xlc;*.xlb"        // library files
              ";*.sdw;*.sxw;*.odt"       // text
              ";*.vor;*.stw;*.ott"       // text template
              ";*.sgl;*.sxg;*.odm"       // master document
              ";*.oth"                   // html document template
              ";*.sdc;*.sxc;*.ods"       // spreadsheet
              ";*.stc;*.ots"             // spreadsheet template
              ";*.sda;*.sxd;*.odg"       // drawing
              ";*.std;*.otg"             // drawing template
              ";*.sdd;*.sxi;*.odp"       // presentation
              ";*.sti;*.otp"             // presentation template
              ";*.sxm;*.odf"_ustr );          // formula

    OUString aLastFilter(GetExtraData()->GetAddLibFilter());
    if ( !aLastFilter.isEmpty() )
        xFP->setCurrentFilter( aLastFilter );
    else
        xFP->setCurrentFilter( IDEResId(RID_STR_BASIC) );

    if ( xFP->execute() != RET_OK )
            return;

    GetExtraData()->SetAddLibPath( xFP->getDisplayDirectory() );
    GetExtraData()->SetAddLibFilter( xFP->getCurrentFilter() );

    // library containers for import
    Reference< script::XLibraryContainer2 > xModLibContImport;
    Reference< script::XLibraryContainer2 > xDlgLibContImport;

    // file URLs
    Sequence< OUString > aFiles = xFP->getSelectedFiles();
    INetURLObject aURLObj( aFiles[0] );
    auto xModURLObj = std::make_shared<INetURLObject>(aURLObj);
    auto xDlgURLObj = std::make_shared<INetURLObject>(aURLObj);

    OUString aBase = aURLObj.getBase();
    OUString aModBase( u"script"_ustr );
    OUString aDlgBase( u"dialog"_ustr );

    if ( aBase == aModBase || aBase == aDlgBase )
    {
        xModURLObj->setBase( aModBase );
        xDlgURLObj->setBase( aDlgBase );
    }

    Reference< XSimpleFileAccess3 > xSFA( SimpleFileAccess::create(comphelper::getProcessComponentContext()) );

    OUString aModURL( xModURLObj->GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
    if ( xSFA->exists( aModURL ) )
    {
        xModLibContImport = script::DocumentScriptLibraryContainer::createWithURL(xContext, aModURL);
    }

    OUString aDlgURL( xDlgURLObj->GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
    if ( xSFA->exists( aDlgURL ) )
    {
        xDlgLibContImport = script::DocumentDialogLibraryContainer::createWithURL(xContext, aDlgURL);
    }

    if ( !xModLibContImport.is() && !xDlgLibContImport.is() )
        return;

    std::shared_ptr<LibDialog> xLibDlg;

    Sequence< OUString > aLibNames = GetMergedLibraryNames( xModLibContImport, xDlgLibContImport );
    if (aLibNames.hasElements())
    {
        // library import dialog
        xLibDlg = std::make_shared<LibDialog>(pDialog);
        xLibDlg->SetStorageName(aURLObj.getName());
        weld::TreeView& rView = xLibDlg->GetLibBox();
        rView.make_unsorted();
        rView.freeze();

        for (auto& aLibName : aLibNames)
        {
            // libbox entries
            if ( !( ( xModLibContImport.is() && xModLibContImport->hasByName( aLibName ) && xModLibContImport->isLibraryLink( aLibName ) ) ||
                    ( xDlgLibContImport.is() && xDlgLibContImport->hasByName( aLibName ) && xDlgLibContImport->isLibraryLink( aLibName ) ) ) )
            {
                rView.append();
                const int nRow = rView.n_children() - 1;
                rView.set_toggle(nRow, TRISTATE_TRUE);
                rView.set_text(nRow, aLibName, 0);
            }
        }

        rView.thaw();
        rView.make_sorted();

        if (rView.n_children())
            rView.set_cursor(0);
    }

    if (!xLibDlg)
    {
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(pDialog,
                                                       VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_NOLIBINSTORAGE)));
        xErrorBox->run();
        return;
    }

    OUString aExtension( aURLObj.getExtension() );
    OUString aLibExtension( u"xlb"_ustr );
    OUString aContExtension( u"xlc"_ustr );

    // disable reference checkbox for documents and sbls
    if ( aExtension != aLibExtension && aExtension != aContExtension )
        xLibDlg->EnableReference(false);

    weld::DialogController::runAsync(
        xLibDlg,
        [aContExtension, xDlgURLObj = std::move(xDlgURLObj), aExtension, aLibExtension,
         xModURLObj = std::move(xModURLObj), xLibDlg, xDlgLibContImport, xModLibContImport,
         rDocument, pDialog, func_remove_entry, func_insert_entry,
         func_insert_entries](sal_Int32 nResult)
        {
            if (!nResult )
                return;

            bool bChanges = false;
            bool bRemove = false;
            bool bReplace = xLibDlg->IsReplace();
            bool bReference = xLibDlg->IsReference();
            weld::TreeView& rView = xLibDlg->GetLibBox();
            for (int nLib = 0, nChildren = rView.n_children(); nLib < nChildren; ++nLib)
            {
                if (rView.get_toggle(nLib) == TRISTATE_TRUE)
                {
                    OUString aLibName(rView.get_text(nLib));
                    Reference<script::XLibraryContainer2> xModLibContainer(
                        rDocument.getLibraryContainer(E_SCRIPTS), UNO_QUERY);
                    Reference<script::XLibraryContainer2> xDlgLibContainer(
                        rDocument.getLibraryContainer(E_DIALOGS), UNO_QUERY);

                    // check, if the library is already existing
                    if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) ) ||
                         ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) ) )
                    {
                        if ( bReplace )
                        {
                            // check, if the library is the Standard library
                            if ( aLibName == "Standard" )
                            {
                                std::unique_ptr<weld::MessageDialog> xErrorBox(
                                    Application::CreateMessageDialog(
                                        pDialog, VclMessageType::Warning, VclButtonsType::Ok,
                                        IDEResId(RID_STR_REPLACESTDLIB)));
                                xErrorBox->run();
                                continue;
                            }

                            // check, if the library is readonly and not a link
                            if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && xModLibContainer->isLibraryReadOnly( aLibName ) && !xModLibContainer->isLibraryLink( aLibName ) ) ||
                                 ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) && xDlgLibContainer->isLibraryReadOnly( aLibName ) && !xDlgLibContainer->isLibraryLink( aLibName ) ) )
                            {
                                OUString aErrStr( IDEResId(RID_STR_REPLACELIB) );
                                aErrStr = aErrStr.replaceAll("XX", aLibName) + "\n" + IDEResId(RID_STR_LIBISREADONLY);
                                std::unique_ptr<weld::MessageDialog> xErrorBox(
                                    Application::CreateMessageDialog(pDialog,
                                                                     VclMessageType::Warning,
                                                                     VclButtonsType::Ok, aErrStr));
                                xErrorBox->run();
                                continue;
                            }

                            // remove existing libraries
                            bRemove = true;
                        }
                        else
                        {
                            OUString aErrStr;
                            if ( bReference )
                                aErrStr = IDEResId(RID_STR_REFNOTPOSSIBLE);
                            else
                                aErrStr = IDEResId(RID_STR_IMPORTNOTPOSSIBLE);
                            aErrStr = aErrStr.replaceAll("XX", aLibName) + "\n" +IDEResId(RID_STR_SBXNAMEALLREADYUSED);
                            std::unique_ptr<weld::MessageDialog> xErrorBox(
                                Application::CreateMessageDialog(pDialog, VclMessageType::Warning,
                                                                 VclButtonsType::Ok, aErrStr));
                            xErrorBox->run();
                            continue;
                        }
                    }

                    // check, if the library is password protected
                    bool bOK = false;
                    OUString aPassword;
                    if ( xModLibContImport.is() && xModLibContImport->hasByName( aLibName ) )
                    {
                        Reference< script::XLibraryContainerPassword > xPasswd( xModLibContImport, UNO_QUERY );
                        if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aLibName ) && !xPasswd->isLibraryPasswordVerified( aLibName ) && !bReference )
                        {
                            bOK = QueryPassword(pDialog, xModLibContImport, aLibName, aPassword,
                                                true, true);

                            if ( !bOK )
                            {
                                OUString aErrStr( IDEResId(RID_STR_NOIMPORT) );
                                aErrStr = aErrStr.replaceAll("XX", aLibName);
                                std::unique_ptr<weld::MessageDialog> xErrorBox(
                                    Application::CreateMessageDialog(pDialog,
                                                                     VclMessageType::Warning,
                                                                     VclButtonsType::Ok, aErrStr));
                                xErrorBox->run();
                                continue;
                            }
                        }
                    }

                    // remove existing libraries
                    if ( bRemove )
                    {
                        if (func_remove_entry)
                            func_remove_entry(aLibName); // LibPage::InsertLib

                        // remove module library
                        if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
                            xModLibContainer->removeLibrary( aLibName );

                        // remove dialog library
                        if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) )
                            xDlgLibContainer->removeLibrary( aLibName );
                    }

                    // copy module library
                    if ( xModLibContImport.is() && xModLibContImport->hasByName( aLibName ) && xModLibContainer.is() && !xModLibContainer->hasByName( aLibName ) )
                    {
                        Reference< container::XNameContainer > xModLib;
                        if ( bReference )
                        {
                            // storage URL
                            INetURLObject aModStorageURLObj(*xModURLObj);
                            if ( aExtension == aContExtension )
                            {
                                sal_Int32 nCount = aModStorageURLObj.getSegmentCount();
                                aModStorageURLObj.insertName( aLibName, false, nCount-1 );
                                aModStorageURLObj.setExtension( aLibExtension );
                                aModStorageURLObj.setFinalSlash();
                            }
                            OUString aModStorageURL( aModStorageURLObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );

                            // create library link
                            xModLib.set( xModLibContainer->createLibraryLink( aLibName, aModStorageURL, true ), UNO_QUERY);
                        }
                        else
                        {
                            // create library
                            xModLib = xModLibContainer->createLibrary( aLibName );
                            if ( xModLib.is() )
                            {
                                // get import library
                                Reference< container::XNameContainer > xModLibImport;
                                Any aElement = xModLibContImport->getByName( aLibName );
                                aElement >>= xModLibImport;

                                if ( xModLibImport.is() )
                                {
                                    // load library
                                    if ( !xModLibContImport->isLibraryLoaded( aLibName ) )
                                        xModLibContImport->loadLibrary( aLibName );

                                    // copy all modules
                                    for (auto& aModName : xModLibImport->getElementNames())
                                    {
                                        Any aElement_ = xModLibImport->getByName( aModName );
                                        xModLib->insertByName( aModName, aElement_ );
                                    }

                                    // set password
                                    if ( bOK )
                                    {
                                        Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
                                        if ( xPasswd.is() )
                                        {
                                            try
                                            {
                                                xPasswd->changeLibraryPassword( aLibName, OUString(), aPassword );
                                            }
                                            catch (...)
                                            {
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    // copy dialog library
                    if ( xDlgLibContImport.is() && xDlgLibContImport->hasByName( aLibName ) && xDlgLibContainer.is() && !xDlgLibContainer->hasByName( aLibName ) )
                    {
                        Reference< container::XNameContainer > xDlgLib;
                        if ( bReference )
                        {
                            // storage URL
                            INetURLObject aDlgStorageURLObj( *xDlgURLObj );
                            if ( aExtension == aContExtension )
                            {
                                sal_Int32 nCount = aDlgStorageURLObj.getSegmentCount();
                                aDlgStorageURLObj.insertName( aLibName, false, nCount - 1 );
                                aDlgStorageURLObj.setExtension( aLibExtension );
                                aDlgStorageURLObj.setFinalSlash();
                            }
                            OUString aDlgStorageURL( aDlgStorageURLObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );

                            // create library link
                            xDlgLib.set( xDlgLibContainer->createLibraryLink( aLibName, aDlgStorageURL, true ), UNO_QUERY);
                        }
                        else
                        {
                            // create library
                            xDlgLib = xDlgLibContainer->createLibrary( aLibName );
                            if ( xDlgLib.is() )
                            {
                                // get import library
                                Reference< container::XNameContainer > xDlgLibImport;
                                Any aElement = xDlgLibContImport->getByName( aLibName );
                                aElement >>= xDlgLibImport;

                                if ( xDlgLibImport.is() )
                                {
                                    // load library
                                    if ( !xDlgLibContImport->isLibraryLoaded( aLibName ) )
                                        xDlgLibContImport->loadLibrary( aLibName );

                                    // copy all dialogs
                                    for (auto& aDlgName : xDlgLibImport->getElementNames())
                                    {
                                        Any aElement_ = xDlgLibImport->getByName( aDlgName );
                                        xDlgLib->insertByName( aDlgName, aElement_ );
                                    }
                                }
                            }
                        }
                    }
                    if (func_insert_entry)
                        func_insert_entry(aLibName); // LibPage::InsertLib
                    bChanges = true;
                }
            }

            if (bChanges)
            {
                if (func_insert_entries)
                    func_insert_entries(); // MacroManager
                MarkDocumentModified(rDocument);
            }
        });
}

void Export(const ScriptDocument& rDocument, const OUString& aLibName, weld::Dialog* pDialog)
{
    // Password verification
    Reference<script::XLibraryContainer2> xModLibContainer(rDocument.getLibraryContainer(E_SCRIPTS),
                                                           UNO_QUERY);

    if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && !xModLibContainer->isLibraryLoaded( aLibName ) )
    {
        bool bOK = true;

        // check password
        Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
        if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aLibName ) && !xPasswd->isLibraryPasswordVerified( aLibName ) )
        {
            OUString aPassword;
            bOK = QueryPassword(pDialog, xModLibContainer, aLibName, aPassword);
        }
        if ( !bOK )
            return;
    }

    std::unique_ptr<ExportDialog> xNewDlg(new ExportDialog(pDialog));
    if (xNewDlg->run() != RET_OK)
        return;

    try
    {
        bool bExportAsPackage = xNewDlg->isExportAsPackage();
        //tdf#112063 ensure closing xNewDlg is not selected as
        //parent of file dialog from ExportAs...
        xNewDlg.reset();
        if (bExportAsPackage)
            ExportAsPackage(rDocument, aLibName, pDialog);
        else
            ExportAsBasic(rDocument, aLibName, pDialog);
    }
    catch(const util::VetoException& ) // user canceled operation
    {
    }
}

void implExportLib(const ScriptDocument& rScriptDocument, const OUString& aLibName,
                   const OUString& aTargetURL, const Reference<task::XInteractionHandler>& Handler)
{
    Reference<script::XLibraryContainerExport> xModLibContainerExport(
        rScriptDocument.getLibraryContainer(E_SCRIPTS), UNO_QUERY);
    Reference<script::XLibraryContainerExport> xDlgLibContainerExport(
        rScriptDocument.getLibraryContainer(E_DIALOGS), UNO_QUERY);
    if ( xModLibContainerExport.is() )
        xModLibContainerExport->exportLibrary(aLibName, aTargetURL, Handler);

    if (!xDlgLibContainerExport.is())
        return;
    Reference<container::XNameAccess> xNameAcc(xDlgLibContainerExport, UNO_QUERY);
    if (!xNameAcc.is())
        return;
    if (!xNameAcc->hasByName(aLibName))
        return;
    xDlgLibContainerExport->exportLibrary(aLibName, aTargetURL, Handler);
}

// Implementation XCommandEnvironment

namespace {

class OLibCommandEnvironment : public cppu::WeakImplHelper< XCommandEnvironment >
{
    Reference< task::XInteractionHandler > mxInteraction;

public:
    explicit OLibCommandEnvironment(const Reference<task::XInteractionHandler>& xInteraction)
        : mxInteraction( xInteraction )
    {}

    // Methods
    virtual Reference< task::XInteractionHandler > SAL_CALL getInteractionHandler() override;
    virtual Reference< XProgressHandler > SAL_CALL getProgressHandler() override;
};

}

Reference< task::XInteractionHandler > OLibCommandEnvironment::getInteractionHandler()
{
    return mxInteraction;
}

Reference< XProgressHandler > OLibCommandEnvironment::getProgressHandler()
{
    Reference< XProgressHandler > xRet;
    return xRet;
}

void ExportAsPackage(const ScriptDocument& rScriptDocument, const OUString& aLibName,
                     weld::Dialog* pDialog)
{
    EnsureIde();
    // file open dialog
    sfx2::FileDialogHelper aDlg(ui::dialogs::TemplateDescription::FILESAVE_SIMPLE,
                                FileDialogFlags::NONE, pDialog);
    aDlg.SetContext(sfx2::FileDialogHelper::BasicExportPackage);
    const Reference <XFilePicker3>& xFP = aDlg.GetFilePicker();

    const Reference< uno::XComponentContext >& xContext( ::comphelper::getProcessComponentContext() );
    Reference< task::XInteractionHandler2 > xHandler( task::InteractionHandler::createWithParent(xContext, nullptr) );
    Reference< XSimpleFileAccess3 > xSFA = SimpleFileAccess::create(xContext);

    xFP->setTitle(IDEResId(RID_STR_EXPORTPACKAGE));

    // filter
    OUString aTitle(IDEResId(RID_STR_PACKAGE_BUNDLE));
    xFP->appendFilter( aTitle, u"*.oxt"_ustr ); // library files

    xFP->setCurrentFilter( aTitle );

    if ( xFP->execute() != RET_OK )
        return;

    GetExtraData()->SetAddLibPath(xFP->getDisplayDirectory());

    Sequence< OUString > aFiles = xFP->getSelectedFiles();
    INetURLObject aURL( aFiles[0] );
    if( aURL.getExtension().isEmpty() )
        aURL.setExtension( u"oxt" );

    OUString aPackageURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );

    OUString aTmpPath = SvtPathOptions().GetTempPath();
    INetURLObject aInetObj( aTmpPath );
    aInetObj.insertName( aLibName, true, INetURLObject::LAST_SEGMENT, INetURLObject::EncodeMechanism::All );
    OUString aSourcePath = aInetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
    if( xSFA->exists( aSourcePath ) )
        xSFA->kill( aSourcePath );
    Reference< task::XInteractionHandler > xDummyHandler( new DummyInteractionHandler( xHandler ) );
    implExportLib(rScriptDocument, aLibName, aTmpPath, xDummyHandler);

    Reference< XCommandEnvironment > xCmdEnv = new OLibCommandEnvironment(xHandler);

    ::ucbhelper::Content sourceContent( aSourcePath, xCmdEnv, comphelper::getProcessComponentContext() );

    OUString destFolder = "vnd.sun.star.zip://" +
                          ::rtl::Uri::encode( aPackageURL,
                                              rtl_UriCharClassRegName,
                                              rtl_UriEncodeIgnoreEscapes,
                                              RTL_TEXTENCODING_UTF8 ) +
                          "/";

    if( xSFA->exists( aPackageURL ) )
        xSFA->kill( aPackageURL );

    ::ucbhelper::Content destFolderContent( destFolder, xCmdEnv, comphelper::getProcessComponentContext() );
    destFolderContent.transferContent(
        sourceContent, ::ucbhelper::InsertOperation::Copy,
        OUString(), NameClash::OVERWRITE );

    INetURLObject aMetaInfInetObj( aTmpPath );
    aMetaInfInetObj.insertName( u"META-INF",
        true, INetURLObject::LAST_SEGMENT, INetURLObject::EncodeMechanism::All );
    OUString aMetaInfFolder = aMetaInfInetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
    if( xSFA->exists( aMetaInfFolder ) )
        xSFA->kill( aMetaInfFolder );
    xSFA->createFolder( aMetaInfFolder );

    std::vector< Sequence<beans::PropertyValue> > manifest;

    OUString fullPath = aLibName
                      + "/" ;
    auto attribs(::comphelper::InitPropertySequence({
        { "FullPath", Any(fullPath) },
        { "MediaType", Any(u"application/vnd.sun.star.basic-library"_ustr) }
    }));
    manifest.push_back( attribs );

    // write into pipe:
    Reference<packages::manifest::XManifestWriter> xManifestWriter = packages::manifest::ManifestWriter::create( xContext );
    Reference<io::XOutputStream> xPipe( io::Pipe::create( xContext ), UNO_QUERY_THROW );
    xManifestWriter->writeManifestSequence(
        xPipe, Sequence< Sequence<beans::PropertyValue> >(
            manifest.data(), manifest.size() ) );

    aMetaInfInetObj.insertName( u"manifest.xml",
        true, INetURLObject::LAST_SEGMENT, INetURLObject::EncodeMechanism::All );

    // write buffered pipe data to content:
    ::ucbhelper::Content manifestContent( aMetaInfInetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xCmdEnv, comphelper::getProcessComponentContext() );
    manifestContent.writeStream( Reference<io::XInputStream>( xPipe, UNO_QUERY_THROW ), true );

    ::ucbhelper::Content MetaInfContent( aMetaInfFolder, xCmdEnv, comphelper::getProcessComponentContext() );
    destFolderContent.transferContent(
        MetaInfContent, ::ucbhelper::InsertOperation::Copy,
        OUString(), NameClash::OVERWRITE );

    if( xSFA->exists( aSourcePath ) )
        xSFA->kill( aSourcePath );
    if( xSFA->exists( aMetaInfFolder ) )
        xSFA->kill( aMetaInfFolder );
}

void ExportAsBasic(const ScriptDocument& rScriptDocument, const OUString& aLibName,
                   weld::Dialog* pDialog)
{
    EnsureIde();
    // Folder picker
    const Reference< uno::XComponentContext >& xContext( ::comphelper::getProcessComponentContext() );
    Reference<XFolderPicker2> xFolderPicker = sfx2::createFolderPicker(xContext, pDialog);
    Reference< task::XInteractionHandler2 > xHandler( task::InteractionHandler::createWithParent(xContext, nullptr) );

    xFolderPicker->setTitle(IDEResId(RID_STR_EXPORTBASIC));

    // set display directory and filter
    OUString aPath =GetExtraData()->GetAddLibPath();
    if( aPath.isEmpty() )
        aPath = SvtPathOptions().GetWorkPath();

    // INetURLObject aURL(m_sSavePath, INetProtocol::File);
    xFolderPicker->setDisplayDirectory( aPath );
    short nRet = xFolderPicker->execute();
    if( nRet == RET_OK )
    {
        OUString aTargetURL = xFolderPicker->getDirectory();
        GetExtraData()->SetAddLibPath(aTargetURL);

        Reference< task::XInteractionHandler > xDummyHandler( new DummyInteractionHandler( xHandler ) );
        implExportLib(rScriptDocument, aLibName, aTargetURL, xDummyHandler);
    }
}

void LibPage::DeleteCurrent()
{
    std::unique_ptr<weld::TreeIter> xCurEntry(m_xLibBox->make_iterator());
    if (!m_xLibBox->get_cursor(xCurEntry.get()))
        return;
    OUString aLibName(m_xLibBox->get_text(*xCurEntry, 0));

    // check, if library is link
    bool bIsLibraryLink = false;
    Reference< script::XLibraryContainer2 > xModLibContainer( m_aCurDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
    Reference< script::XLibraryContainer2 > xDlgLibContainer( m_aCurDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY );
    if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) && xModLibContainer->isLibraryLink( aLibName ) ) ||
         ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) && xDlgLibContainer->isLibraryLink( aLibName ) ) )
    {
        bIsLibraryLink = true;
    }

    if (!QueryDelLib(aLibName, bIsLibraryLink, m_pDialog->getDialog()))
        return;

    // inform BasicIDE
    SfxUnoAnyItem aDocItem( SID_BASICIDE_ARG_DOCUMENT_MODEL, Any( m_aCurDocument.getDocumentOrNull() ) );
    SfxStringItem aLibNameItem( SID_BASICIDE_ARG_LIBNAME, aLibName );
    if (SfxDispatcher* pDispatcher = GetDispatcher())
        pDispatcher->ExecuteList(SID_BASICIDE_LIBREMOVED,
                  SfxCallMode::SYNCHRON, { &aDocItem, &aLibNameItem });

    // remove library from module and dialog library containers
    if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
        xModLibContainer->removeLibrary( aLibName );
    if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) )
        xDlgLibContainer->removeLibrary( aLibName );

    m_xLibBox->remove(*xCurEntry);
    MarkDocumentModified( m_aCurDocument );
}

void LibPage::EndTabDialog()
{
    m_pDialog->response(RET_OK);
}

void LibPage::FillListBox()
{
    InsertListBoxEntry( ScriptDocument::getApplicationScriptDocument(), LIBRARY_LOCATION_USER );
    InsertListBoxEntry( ScriptDocument::getApplicationScriptDocument(), LIBRARY_LOCATION_SHARE );

    ScriptDocuments aDocuments( ScriptDocument::getAllScriptDocuments( ScriptDocument::DocumentsSorted ) );
    for (auto const& doc : aDocuments)
    {
        InsertListBoxEntry( doc, LIBRARY_LOCATION_DOCUMENT );
    }
}

void LibPage::InsertListBoxEntry( const ScriptDocument& rDocument, LibraryLocation eLocation )
{
    OUString aEntryText(rDocument.getTitle(eLocation));
    OUString sId(weld::toId(new DocumentEntry(rDocument, eLocation)));
    m_xBasicsBox->append(sId,  aEntryText);
}

void LibPage::SetCurLib()
{
    DocumentEntry* pEntry = weld::fromId<DocumentEntry*>(m_xBasicsBox->get_active_id());
    if (!pEntry)
        return;

    const ScriptDocument& aDocument( pEntry->GetDocument() );
    DBG_ASSERT( aDocument.isAlive(), "LibPage::SetCurLib: no document, or document is dead!" );
    if ( !aDocument.isAlive() )
        return;
    LibraryLocation eLocation = pEntry->GetLocation();
    if ( aDocument == m_aCurDocument && eLocation == m_eCurLocation )
        return;

    m_aCurDocument = aDocument;
    m_eCurLocation = eLocation;
    m_xLibBox->clear();

    // get a sorted list of library names
    int nEntry = 0;
    for (auto& aLibName : aDocument.getLibraryNames())
    {
        if (eLocation == aDocument.getLibraryLocation(aLibName))
            ImpInsertLibEntry(aLibName, nEntry++);
    }

    int nEntry_ = FindEntry(*m_xLibBox, u"Standard");
    if (nEntry_ == -1 && m_xLibBox->n_children())
        nEntry_ = 0;
    m_xLibBox->set_cursor(nEntry_);

    m_xLibBox->columns_autosize();
}

void LibPage::ImpInsertLibEntry( const OUString& rLibName, int nPos )
{
    // check, if library is password protected
    bool bProtected = false;
    Reference< script::XLibraryContainer2 > xModLibContainer( m_aCurDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
    if ( xModLibContainer.is() && xModLibContainer->hasByName( rLibName ) )
    {
        Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
        if ( xPasswd.is() )
        {
            bProtected = xPasswd->isLibraryPasswordProtected( rLibName );
        }
    }

    m_xLibBox->insert_text(nPos, rLibName);

    if (bProtected)
        m_xLibBox->set_image(nPos, RID_BMP_LOCKED);

    // check, if library is link
    if ( xModLibContainer.is() && xModLibContainer->hasByName( rLibName ) && xModLibContainer->isLibraryLink( rLibName ) )
    {
        OUString aLinkURL = xModLibContainer->getLibraryLinkURL( rLibName );
        m_xLibBox->set_text(nPos, aLinkURL, 1);
    }
}

// Helper function
void createLibImpl(weld::Window* pWin, const ScriptDocument& rDocument,
                   weld::TreeView* pLibBox, SbTreeListBox* pBasicBox)
{
    OSL_ENSURE( rDocument.isAlive(), "createLibImpl: invalid document!" );
    if ( !rDocument.isAlive() )
        return;

    // create library name
    OUString aLibName;
    bool bValid = false;
    sal_Int32 i = 1;
    while ( !bValid )
    {
        aLibName = "Library" + OUString::number( i );
        if ( !rDocument.hasLibrary( E_SCRIPTS, aLibName ) && !rDocument.hasLibrary( E_DIALOGS, aLibName ) )
            bValid = true;
        i++;
    }

    NewObjectDialog aNewDlg(pWin, ObjectMode::Library);
    aNewDlg.SetObjectName(aLibName);

    if (!aNewDlg.run())
        return;

    if (!aNewDlg.GetObjectName().isEmpty())
        aLibName = aNewDlg.GetObjectName();

    if ( aLibName.getLength() > 30 )
    {
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(pWin,
                                                       VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_LIBNAMETOLONG)));
        xErrorBox->run();
    }
    else if ( !IsValidSbxName( aLibName ) )
    {
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(pWin,
                                                       VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_BADSBXNAME)));
        xErrorBox->run();
    }
    else if ( rDocument.hasLibrary( E_SCRIPTS, aLibName ) || rDocument.hasLibrary( E_DIALOGS, aLibName ) )
    {
        std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(pWin,
                                                       VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_SBXNAMEALLREADYUSED2)));
        xErrorBox->run();
    }
    else
    {
        try
        {
            // create module and dialog library
            rDocument.getOrCreateLibrary( E_SCRIPTS, aLibName );
            rDocument.getOrCreateLibrary( E_DIALOGS, aLibName );

            if( pLibBox )
            {
                pLibBox->append_text(aLibName);
                pLibBox->set_cursor(pLibBox->find_text(aLibName));
            }

            // create a module
            OUString aModName = rDocument.createObjectName( E_SCRIPTS, aLibName );
            OUString sModuleCode;
            if ( !rDocument.createModule( aLibName, aModName, true, sModuleCode ) )
                throw Exception("could not create module " + aModName, nullptr);

            // tdf#151741 - store all libraries to the file system, otherwise they
            // cannot be renamed/moved since the SfxLibraryContainer::renameLibrary
            // moves the folders/files on the file system
            Reference<script::XLibraryContainer2> xModLibContainer(
                rDocument.getLibraryContainer(E_SCRIPTS), UNO_QUERY);
            Reference<script::XLibraryContainer2> xDlgLibContainer(
                rDocument.getLibraryContainer(E_DIALOGS), UNO_QUERY);
            Reference<script::XPersistentLibraryContainer> xModPersLibContainer(xModLibContainer,
                                                                                UNO_QUERY);
            if (xModPersLibContainer.is())
                xModPersLibContainer->storeLibraries();
            Reference<script::XPersistentLibraryContainer> xDlgPersLibContainer(xDlgLibContainer,
                                                                                UNO_QUERY);
            if (xDlgPersLibContainer.is())
                xDlgPersLibContainer->storeLibraries();

            SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, rDocument, aLibName, aModName, SBX_TYPE_MODULE );
            if (SfxDispatcher* pDispatcher = GetDispatcher())
                pDispatcher->ExecuteList(SID_BASICIDE_SBXINSERTED,
                                      SfxCallMode::SYNCHRON, { &aSbxItem });

            if( pBasicBox )
            {
                std::unique_ptr<weld::TreeIter> xIter(pBasicBox->make_iterator(nullptr));
                bool bValidIter = pBasicBox->get_cursor(xIter.get());
                std::unique_ptr<weld::TreeIter> xRootEntry(pBasicBox->make_iterator(xIter.get()));
                while (bValidIter)
                {
                    pBasicBox->copy_iterator(*xIter, *xRootEntry);
                    bValidIter = pBasicBox->iter_parent(*xIter);
                }

                BrowseMode nMode = pBasicBox->GetMode();
                bool bDlgMode = ( nMode & BrowseMode::Dialogs ) && !( nMode & BrowseMode::Modules );
                const auto sId = bDlgMode ? RID_BMP_DLGLIB : RID_BMP_MODLIB;
                pBasicBox->AddEntry(aLibName, sId, xRootEntry.get(), false, std::make_unique<Entry>(OBJ_TYPE_LIBRARY));
                pBasicBox->AddEntry(aModName, RID_BMP_MODULE, xRootEntry.get(), false, std::make_unique<Entry>(OBJ_TYPE_MODULE));
                pBasicBox->set_cursor(*xRootEntry);
                pBasicBox->select(*xRootEntry);
            }
        }
        catch (const uno::Exception& )
        {
            DBG_UNHANDLED_EXCEPTION("basctl.basicide");
        }
    }
}

} // namespace basctl

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