navigatortree.cxx

Go to the documentation of this file.

/* -*- 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 <memory>
#include <svx/dialmgr.hxx>
#include <svx/fmshell.hxx>
#include <svx/fmmodel.hxx>
#include <svx/fmpage.hxx>
#include <svx/svdpagv.hxx>
#include <svx/svditer.hxx>
 
#include <helpids.h>
#include <fmexpl.hxx>
#include <fmshimp.hxx>
#include <fmservs.hxx>
#include <fmundo.hxx>
#include <fmpgeimp.hxx>
#include <fmobj.hxx>
#include <fmprop.hxx>
#include <sal/log.hxx>
#include <vcl/svapp.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/viewfrm.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/property.hxx>
#include <comphelper/types.hxx>
#include <com/sun/star/form/FormComponentType.hpp>
#include <com/sun/star/sdb/CommandType.hpp>
#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/script/XEventAttacherManager.hpp>
#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
#include <com/sun/star/datatransfer/XTransferable.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <svx/sdrpaintwindow.hxx>
 
#include <svx/strings.hrc>
#include <comphelper/diagnose_ex.hxx>
#include <svx/svxids.hrc>
#include <bitmaps.hlst>
#include <vcl/commandevent.hxx>
 
namespace svxform
{
    #define EXPLORER_SYNC_DELAY                 200
        // Time (in ms) until explorer synchronizes the view after select or deselect
 
    using namespace ::com::sun::star::uno;
    using namespace ::com::sun::star::lang;
    using namespace ::com::sun::star::beans;
    using namespace ::com::sun::star::form;
    using namespace ::com::sun::star::awt;
    using namespace ::com::sun::star::container;
    using namespace ::com::sun::star::script;
    using namespace ::com::sun::star::datatransfer;
    using namespace ::com::sun::star::datatransfer::clipboard;
    using namespace ::com::sun::star::sdb;
 
 
    // helper
 
 
    typedef ::std::map< Reference< XInterface >, SdrObject* > MapModelToShape;
 
 
    static void    collectShapeModelMapping( SdrPage const * _pPage, MapModelToShape& _rMapping )
    {
        OSL_ENSURE( _pPage, "collectShapeModelMapping: invalid arg!" );
 
        _rMapping.clear();
 
        SdrObjListIter aIter( _pPage );
        while ( aIter.IsMore() )
        {
            SdrObject* pSdrObject = aIter.Next();
            FmFormObj* pFormObject = FmFormObj::GetFormObject( pSdrObject );
            if ( !pFormObject )
                continue;
 
            Reference< XInterface > xNormalizedModel( pFormObject->GetUnoControlModel(), UNO_QUERY );
                // note that this is normalized (i.e. queried for XInterface explicitly)
 
            ::std::pair< MapModelToShape::iterator, bool > aPos =
                  _rMapping.emplace( xNormalizedModel, pSdrObject );
            DBG_ASSERT( aPos.second, "collectShapeModelMapping: model was already existent!" );
                // if this asserts, this would mean we have 2 shapes pointing to the same model
        }
    }
 
    NavigatorTreeDropTarget::NavigatorTreeDropTarget(NavigatorTree& rTreeView)
        : DropTargetHelper(rTreeView.get_widget().get_drop_target())
        , m_rTreeView(rTreeView)
    {
    }
 
    sal_Int8 NavigatorTreeDropTarget::AcceptDrop(const AcceptDropEvent& rEvt)
    {
        sal_Int8 nAccept = m_rTreeView.AcceptDrop(rEvt);
 
        if (nAccept != DND_ACTION_NONE)
        {
            // to enable the autoscroll when we're close to the edges
            weld::TreeView& rWidget = m_rTreeView.get_widget();
            rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr, true);
        }
 
        return nAccept;
    }
 
    sal_Int8 NavigatorTreeDropTarget::ExecuteDrop(const ExecuteDropEvent& rEvt)
    {
        return m_rTreeView.ExecuteDrop(rEvt);
    }
 
    NavigatorTree::NavigatorTree(std::unique_ptr<weld::TreeView> xTreeView)
        :m_xTreeView(std::move(xTreeView))
        ,m_aDropTargetHelper(*this)
        ,m_aSynchronizeTimer("svx NavigatorTree m_aSynchronizeTimer")
        ,nEditEvent(nullptr)
        ,m_sdiState(SDI_DIRTY)
        ,m_nSelectLock(0)
        ,m_nFormsSelected(0)
        ,m_nControlsSelected(0)
        ,m_nHiddenControls(0)
        ,m_bDragDataDirty(false)
        ,m_bPrevSelectionMixed(false)
        ,m_bRootSelected(false)
        ,m_bInitialUpdate(true)
        ,m_bKeyboardCut( false )
        ,m_bEditing( false )
    {
        m_xTreeView->set_help_id(HID_FORM_NAVIGATOR);
        m_xTreeView->set_size_request(200, 200);
 
        m_xTreeView->set_selection_mode(SelectionMode::Multiple);
 
        m_pNavModel.reset(new NavigatorTreeModel());
        Clear();
 
        StartListening( *m_pNavModel );
 
        m_aSynchronizeTimer.SetInvokeHandler(LINK(this, NavigatorTree, OnSynchronizeTimer));
        m_xTreeView->connect_changed(LINK(this, NavigatorTree, OnEntrySelDesel));
        m_xTreeView->connect_key_press(LINK(this, NavigatorTree, KeyInputHdl));
        m_xTreeView->connect_popup_menu(LINK(this, NavigatorTree, PopupMenuHdl));
        m_xTreeView->connect_editing(LINK(this, NavigatorTree, EditingEntryHdl),
                                     LINK(this, NavigatorTree, EditedEntryHdl));
        m_xTreeView->connect_drag_begin(LINK(this, NavigatorTree, DragBeginHdl));
    }
 
    NavigatorTree::~NavigatorTree()
    {
        if( nEditEvent )
            Application::RemoveUserEvent( nEditEvent );
 
        if (m_aSynchronizeTimer.IsActive())
            m_aSynchronizeTimer.Stop();
 
        DBG_ASSERT(GetNavModel() != nullptr, "NavigatorTree::~NavigatorTree : unexpected : no ExplorerModel");
        EndListening( *m_pNavModel );
        Clear();
        m_pNavModel.reset();
    }
 
    void NavigatorTree::Clear()
    {
        m_pNavModel->Clear();
    }
 
    void NavigatorTree::UpdateContent( FmFormShell* pFormShell )
    {
        if (m_bInitialUpdate)
        {
            GrabFocus();
            m_bInitialUpdate = false;
        }
 
        FmFormShell* pOldShell = GetNavModel()->GetFormShell();
        FmFormPage* pOldPage = GetNavModel()->GetFormPage();
        FmFormPage* pNewPage = pFormShell ? pFormShell->GetCurPage() : nullptr;
 
        if ((pOldShell != pFormShell) || (pOldPage != pNewPage))
        {
            // new shell during editing
            if (IsEditingActive())
            {
                m_xTreeView->end_editing();
                m_bEditing = false;
            }
 
            m_bDragDataDirty = true;    // as a precaution, although I don't drag
        }
        GetNavModel()->UpdateContent( pFormShell );
 
        // if there is a form, expand root
        if (m_xRootEntry && !m_xTreeView->get_row_expanded(*m_xRootEntry))
            m_xTreeView->expand_row(*m_xRootEntry);
        // if there is EXACTLY ONE form, expand it too
        if (m_xRootEntry)
        {
            std::unique_ptr<weld::TreeIter> xFirst(m_xTreeView->make_iterator(m_xRootEntry.get()));
            bool bFirst = m_xTreeView->iter_children(*xFirst);
            if (bFirst)
            {
                std::unique_ptr<weld::TreeIter> xSibling(m_xTreeView->make_iterator(xFirst.get()));
                if (!m_xTreeView->iter_next_sibling(*xSibling))
                    m_xTreeView->expand_row(*xFirst);
            }
        }
    }
 
    bool NavigatorTree::implAllowExchange( sal_Int8 _nAction, bool* _pHasNonHidden )
    {
        bool bCurEntry = m_xTreeView->get_cursor(nullptr);
        if (!bCurEntry)
            return false;
 
        // Information for AcceptDrop and Execute Drop
        CollectSelectionData(SDI_ALL);
        if (m_arrCurrentSelection.empty())
            // nothing to do
            return false;
 
        // check whether there are only hidden controls
        // I may add a format to pCtrlExch
        bool bHasNonHidden = std::any_of(m_arrCurrentSelection.begin(), m_arrCurrentSelection.end(),
            [this](const auto& rEntry) {
                FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rEntry));
                return !IsHiddenControl( pCurrent );
            });
 
        if ( bHasNonHidden && ( 0 == ( _nAction & DND_ACTION_MOVE ) ) )
            // non-hidden controls need to be moved
            return false;
 
        if ( _pHasNonHidden )
            *_pHasNonHidden = bHasNonHidden;
 
        return true;
    }
 
    bool NavigatorTree::implPrepareExchange( sal_Int8 _nAction )
    {
        bool bHasNonHidden = false;
        if ( !implAllowExchange( _nAction, &bHasNonHidden ) )
            return false;
 
        m_aControlExchange.prepareDrag();
        m_aControlExchange->setFocusEntry(m_xTreeView->get_cursor(nullptr));
 
        for (const auto& rpEntry : m_arrCurrentSelection)
            m_aControlExchange->addSelectedEntry(m_xTreeView->make_iterator(rpEntry.get()));
 
        m_aControlExchange->setFormsRoot( GetNavModel()->GetFormPage()->GetForms() );
        m_aControlExchange->buildPathFormat(m_xTreeView.get(), m_xRootEntry.get());
 
        if (!bHasNonHidden)
        {
            // create a sequence
            Sequence< Reference< XInterface > > seqIFaces(m_arrCurrentSelection.size());
            Reference< XInterface >* pArray = seqIFaces.getArray();
            for (const auto& rpEntry : m_arrCurrentSelection)
            {
                *pArray = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rpEntry))->GetElement();
                ++pArray;
            }
            // and the new format
            m_aControlExchange->addHiddenControlsFormat(seqIFaces);
        }
 
        m_bDragDataDirty = false;
        return true;
    }
 
    IMPL_LINK(NavigatorTree, DragBeginHdl, bool&, rUnsetDragIcon, bool)
    {
        rUnsetDragIcon = false;
 
        bool bSuccess = implPrepareExchange(DND_ACTION_COPYMOVE);
        if (bSuccess)
        {
            OControlExchange& rExchange = *m_aControlExchange;
            rtl::Reference<TransferDataContainer> xHelper(&rExchange);
            m_xTreeView->enable_drag_source(xHelper, DND_ACTION_COPYMOVE);
            rExchange.setDragging(true);
        }
        return !bSuccess;
    }
 
    IMPL_LINK(NavigatorTree, PopupMenuHdl, const CommandEvent&, rEvt, bool)
    {
        bool bHandled = false;
        switch( rEvt.GetCommand() )
        {
            case CommandEventId::ContextMenu:
            {
                // Position of click
                ::Point ptWhere;
                if (rEvt.IsMouseEvent())
                {
                    ptWhere = rEvt.GetMousePosPixel();
                    std::unique_ptr<weld::TreeIter> xClickedOn(m_xTreeView->make_iterator());
                    if (!m_xTreeView->get_dest_row_at_pos(ptWhere, xClickedOn.get(), false))
                        break;
                    if (!m_xTreeView->is_selected(*xClickedOn))
                    {
                        m_xTreeView->unselect_all();
                        m_xTreeView->select(*xClickedOn);
                        m_xTreeView->set_cursor(*xClickedOn);
                    }
                }
                else
                {
                    if (m_arrCurrentSelection.empty()) // only happens with context menu via keyboard
                        break;
 
                    std::unique_ptr<weld::TreeIter> xCurrent(m_xTreeView->make_iterator());
                    if (!m_xTreeView->get_cursor(xCurrent.get()))
                        break;
                    ptWhere = m_xTreeView->get_row_area(*xCurrent).Center();
                }
 
                // update my selection data
                CollectSelectionData(SDI_ALL);
 
                // if there is at least one no-root-entry and the root selected, I deselect root
                if ( (m_arrCurrentSelection.size() > 1) && m_bRootSelected )
                {
                    const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin();
                    m_xTreeView->set_cursor(*rIter);
                    m_xTreeView->unselect(*m_xRootEntry);
                }
                bool bSingleSelection = (m_arrCurrentSelection.size() == 1);
 
 
                DBG_ASSERT( (!m_arrCurrentSelection.empty()) || m_bRootSelected, "no entries selected" );
                    // shouldn't happen, because I would have selected one during call to IsSelected,
                    // if there was none before
 
 
                // create menu
                FmFormShell* pFormShell = GetNavModel()->GetFormShell();
                FmFormModel* pFormModel = pFormShell ? pFormShell->GetFormModel() : nullptr;
                if( pFormShell && pFormModel )
                {
                    std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "svx/ui/formnavimenu.ui"));
                    std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu("menu"));
                    std::unique_ptr<weld::Menu> xSubMenuNew(xBuilder->weld_menu("submenu"));
 
                    // menu 'New' only exists, if only the root or only one form is selected
                    bool bShowNew = bSingleSelection && (m_nFormsSelected || m_bRootSelected);
                    if (!bShowNew)
                        xContextMenu->remove("new");
 
                    // 'New'\'Form' under the same terms
                    bool bShowForm = bSingleSelection && (m_nFormsSelected || m_bRootSelected);
                    if (bShowForm)
                        xSubMenuNew->append("form", SvxResId(RID_STR_FORM), RID_SVXBMP_FORM);
 
                    // 'New'\'hidden...', if exactly one form is selected
                    bool bShowHidden = bSingleSelection && m_nFormsSelected;
                    if (bShowHidden)
                        xSubMenuNew->append("hidden", SvxResId(RID_STR_HIDDEN), RID_SVXBMP_HIDDEN);
 
                    // 'Delete': everything which is not root can be removed
                    if (m_bRootSelected)
                        xContextMenu->remove("delete");
 
                    // 'Cut', 'Copy' and 'Paste'
                    bool bShowCut = !m_bRootSelected && implAllowExchange(DND_ACTION_MOVE);
                    if (!bShowCut)
                        xContextMenu->remove("cut");
                    bool bShowCopy = !m_bRootSelected && implAllowExchange(DND_ACTION_COPY);
                    if (!bShowCopy)
                        xContextMenu->remove("copy");
                    if (!implAcceptPaste())
                        xContextMenu->remove("paste");
 
                    // TabDialog, if exactly one form
                    bool bShowTabOrder = bSingleSelection && m_nFormsSelected;
                    if (!bShowTabOrder)
                        xContextMenu->remove("taborder");
 
                    bool bShowProps = true;
                    // in XML forms, we don't allow for the properties of a form
                    // #i36484#
                    if (pFormShell->GetImpl()->isEnhancedForm_Lock() && !m_nControlsSelected)
                        bShowProps = false;
                    // if the property browser is already open, we don't allow for the properties, too
                    if (pFormShell->GetImpl()->IsPropBrwOpen_Lock())
                        bShowProps = false;
 
                    // and finally, if there's a mixed selection of forms and controls, disable the entry, too
                    if (bShowProps && !pFormShell->GetImpl()->IsPropBrwOpen_Lock())
                        bShowProps =
                            (m_nControlsSelected && !m_nFormsSelected) || (!m_nControlsSelected && m_nFormsSelected);
 
                    if (!bShowProps)
                        xContextMenu->remove("props");
 
                    // rename, if one element and no root
                    bool bShowRename = bSingleSelection && !m_bRootSelected;
                    if (!bShowRename)
                        xContextMenu->remove("rename");
 
                    if (!m_bRootSelected)
                    {
                        // Readonly-entry is only for root
                        xContextMenu->remove("designmode");
                        // the same for automatic control focus
                        xContextMenu->remove("controlfocus");
                    }
 
                    std::unique_ptr<weld::Menu> xConversionMenu(xBuilder->weld_menu("changemenu"));
                    // ConvertTo-Slots are enabled, if one control is selected
                    // the corresponding slot is disabled
                    if (!m_bRootSelected && !m_nFormsSelected && (m_nControlsSelected == 1))
                    {
                        FmXFormShell::GetConversionMenu_Lock(*xConversionMenu);
#if OSL_DEBUG_LEVEL > 0
                        const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin();
                        FmControlData* pCurrent = weld::fromId<FmControlData*>(m_xTreeView->get_id(*rIter));
                        OSL_ENSURE( pFormShell->GetImpl()->isSolelySelected_Lock( pCurrent->GetFormComponent() ),
                            "NavigatorTree::Command: inconsistency between the navigator selection, and the selection as the shell knows it!" );
#endif
 
                        pFormShell->GetImpl()->checkControlConversionSlotsForCurrentSelection_Lock(*xConversionMenu);
                    }
                    else
                        xContextMenu->remove("change");
 
                    if (m_bRootSelected)
                    {
                        // set OpenReadOnly
                        xContextMenu->set_active("designmode", pFormModel->GetOpenInDesignMode());
                        xContextMenu->set_active("controlfocus", pFormModel->GetAutoControlFocus());
                    }
 
                    OUString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(ptWhere, ::Size(1, 1)));
                    if (sIdent == "form")
                    {
                        OUString aStr(SvxResId(RID_STR_FORM));
                        OUString aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_INSERT).replaceAll("#", aStr);
 
                        pFormModel->BegUndo(aUndoStr);
                        // slot was only available, if there is only one selected entry,
                        // which is a root or a form
                        const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin();
                        NewForm(*rIter);
                        pFormModel->EndUndo();
                    }
                    else if (sIdent == "hidden")
                    {
                        OUString aStr(SvxResId(RID_STR_CONTROL));
                        OUString aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_INSERT).replaceAll("#", aStr);
 
                        pFormModel->BegUndo(aUndoStr);
                        // slot was valid for (exactly) one selected form
                        const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin();
                        NewControl(FM_COMPONENT_HIDDEN, *rIter, true);
                        pFormModel->EndUndo();
                    }
                    else if (sIdent == "cut")
                        doCut();
                    else if (sIdent == "copy")
                        doCopy();
                    else if (sIdent == "paste")
                        doPaste();
                    else if (sIdent == "delete")
                        DeleteSelection();
                    else if (sIdent == "taborder")
                    {
                        // this slot was effective for exactly one selected form
                        const std::unique_ptr<weld::TreeIter>& rSelectedForm = *m_arrCurrentSelection.begin();
                        DBG_ASSERT( IsFormEntry(*rSelectedForm), "NavigatorTree::Command: This entry must be a FormEntry." );
 
                        FmFormData* pFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(*rSelectedForm));
                        const Reference< XForm >&  xForm(  pFormData->GetFormIface());
 
                        Reference< XTabControllerModel >  xTabController(xForm, UNO_QUERY);
                        if( !xTabController.is() )
                            break;
                        GetNavModel()->GetFormShell()->GetImpl()->ExecuteTabOrderDialog_Lock(xTabController);
                    }
                    else if (sIdent == "props")
                        ShowSelectionProperties(true);
                    else if (sIdent == "rename")
                    {
                        // only allowed for one no-root-entry
                        const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin();
                        m_xTreeView->start_editing(*rIter);
                        m_bEditing = true;
                    }
                    else if (sIdent == "designmode")
                    {
                        pFormModel->SetOpenInDesignMode( !pFormModel->GetOpenInDesignMode() );
                        pFormShell->GetViewShell()->GetViewFrame().GetBindings().Invalidate(SID_FM_OPEN_READONLY);
                    }
                    else if (sIdent == "controlfocus")
                    {
                        pFormModel->SetAutoControlFocus( !pFormModel->GetAutoControlFocus() );
                        pFormShell->GetViewShell()->GetViewFrame().GetBindings().Invalidate(SID_FM_AUTOCONTROLFOCUS);
                    }
                    else if (FmXFormShell::isControlConversionSlot(sIdent))
                    {
                        const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin();
                        FmControlData* pCurrent = weld::fromId<FmControlData*>(m_xTreeView->get_id(*rIter));
                        if (pFormShell->GetImpl()->executeControlConversionSlot_Lock(pCurrent->GetFormComponent(), sIdent))
                            ShowSelectionProperties();
                    }
                }
                bHandled = true;
            }
            break;
            default: break;
        }
 
        return bHandled;
    }
 
    std::unique_ptr<weld::TreeIter> NavigatorTree::FindEntry(FmEntryData* pEntryData)
    {
        std::unique_ptr<weld::TreeIter> xRet;
        if(!pEntryData)
            return xRet;
 
        m_xTreeView->all_foreach([this, pEntryData, &xRet](weld::TreeIter& rEntry){
            FmEntryData* pCurEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rEntry));
            if (pCurEntryData && pCurEntryData->IsEqualWithoutChildren(pEntryData))
            {
                xRet = m_xTreeView->make_iterator(&rEntry);
                return true;
            }
            return false;
        });
 
        return xRet;
    }
 
    void NavigatorTree::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
    {
        if( auto pRemovedHint = dynamic_cast<const FmNavRemovedHint*>(&rHint) )
        {
            FmEntryData* pEntryData = pRemovedHint->GetEntryData();
            Remove( pEntryData );
        }
        else if( auto pInsertedHint = dynamic_cast<const FmNavInsertedHint*>(&rHint) )
        {
            FmEntryData* pEntryData = pInsertedHint->GetEntryData();
            sal_uInt32 nRelPos = pInsertedHint->GetRelPos();
            Insert( pEntryData, nRelPos );
        }
        else if( auto pReplacedHint = dynamic_cast<const FmNavModelReplacedHint*>(&rHint) )
        {
            FmEntryData* pData = pReplacedHint->GetEntryData();
            std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pData);
            if (xEntry)
            {
                // reset image
                m_xTreeView->set_image(*xEntry, pData->GetNormalImage());
            }
        }
        else if( auto pNameChangedHint = dynamic_cast<const FmNavNameChangedHint*>(&rHint) )
        {
            std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pNameChangedHint->GetEntryData());
            m_xTreeView->set_text(*xEntry, pNameChangedHint->GetNewName());
        }
        else if( dynamic_cast<const FmNavClearedHint*>(&rHint) )
        {
            m_aCutEntries.clear();
            if (m_aControlExchange.isDataExchangeActive())
                m_aControlExchange.clear();
            m_xTreeView->clear();
 
            // default-entry "Forms"
            OUString sText(SvxResId(RID_STR_FORMS));
            m_xRootEntry = m_xTreeView->make_iterator();
            m_xTreeView->insert(nullptr, -1, &sText, nullptr, nullptr, nullptr,
                                false, m_xRootEntry.get());
            m_xTreeView->set_image(*m_xRootEntry, RID_SVXBMP_FORMS);
            m_xTreeView->set_sensitive(*m_xRootEntry, true);
        }
        else if (auto pSelectHint = dynamic_cast<FmNavRequestSelectHint*>(const_cast<SfxHint*>(&rHint)))
        {
            FmEntryDataArray& arredToSelect = pSelectHint->GetItems();
            SynchronizeSelection(arredToSelect);
 
            if (pSelectHint->IsMixedSelection())
                // in this case I deselect all, although the view had a mixed selection
                // during next selection, I must adapt the navigator to the view
                m_bPrevSelectionMixed = true;
        }
    }
 
    std::unique_ptr<weld::TreeIter> NavigatorTree::Insert(const FmEntryData* pEntryData, int nRelPos)
    {
        // insert current entry
        std::unique_ptr<weld::TreeIter> xParentEntry = FindEntry( pEntryData->GetParent() );
        std::unique_ptr<weld::TreeIter> xNewEntry(m_xTreeView->make_iterator());
        OUString sId(weld::toId(pEntryData));
 
        if(!xParentEntry)
        {
            m_xTreeView->insert(m_xRootEntry.get(), nRelPos, &pEntryData->GetText(), &sId,
                                nullptr, nullptr, false, xNewEntry.get());
        }
        else
        {
            m_xTreeView->insert(xParentEntry.get(), nRelPos, &pEntryData->GetText(), &sId,
                                nullptr, nullptr, false, xNewEntry.get());
        }
 
        m_xTreeView->set_image(*xNewEntry, pEntryData->GetNormalImage());
        m_xTreeView->set_sensitive(*xNewEntry, true);
 
        // If root-entry, expand root
        if (!xParentEntry)
            m_xTreeView->expand_row(*m_xRootEntry);
 
        // insert children
        FmEntryDataList* pChildList = pEntryData->GetChildList();
        size_t nChildCount = pChildList->size();
        for( size_t i = 0; i < nChildCount; i++ )
        {
            FmEntryData* pChildData = pChildList->at( i );
            Insert(pChildData, -1);
        }
 
        return xNewEntry;
    }
 
    void NavigatorTree::Remove( FmEntryData* pEntryData )
    {
        if( !pEntryData )
            return;
 
        // entry for the data
        std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pEntryData);
        if (!xEntry)
            return;
 
        // delete entry from TreeListBox
        // I'm not allowed, to treat the selection, which I trigger:
        // select changes the MarkList of the view, if somebody else does this at the same time
        // and removes a selection, we get a problem
        // e.g. Group controls with open navigator
        LockSelectionHandling();
 
        // little problem: I remember the selected data, but if somebody deletes one of these entries,
        // I get inconsistent... this would be bad
        m_xTreeView->unselect(*xEntry);
 
        // selection can be modified during deletion,
        // but because I disabled SelectionHandling, I have to do it later
        auto nExpectedSelectionCount = m_xTreeView->count_selected_rows();
 
        ModelHasRemoved(xEntry.get());
        m_xTreeView->remove(*xEntry);
 
        if (nExpectedSelectionCount != m_xTreeView->count_selected_rows())
            SynchronizeSelection();
 
        // by default I treat the selection of course
        UnlockSelectionHandling();
    }
 
    bool NavigatorTree::IsFormEntry(const weld::TreeIter& rEntry)
    {
        FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rEntry));
        return !pEntryData || dynamic_cast<const FmFormData*>( pEntryData) !=  nullptr;
    }
 
    bool NavigatorTree::IsFormComponentEntry(const weld::TreeIter& rEntry)
    {
        FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rEntry));
        return dynamic_cast<const FmControlData*>( pEntryData) != nullptr;
    }
 
    bool NavigatorTree::implAcceptPaste( )
    {
        auto nSelectedEntries = m_xTreeView->count_selected_rows();
        if (nSelectedEntries != 1)
            // no selected entry, or at least two selected entries
            return false;
 
        // get the clipboard
        TransferableDataHelper aClipboardContent(TransferableDataHelper::CreateFromClipboard(m_xTreeView->get_clipboard()));
 
        sal_Int8 nAction = m_aControlExchange.isClipboardOwner() && doingKeyboardCut( ) ? DND_ACTION_MOVE : DND_ACTION_COPY;
        std::unique_ptr<weld::TreeIter> xSelected(m_xTreeView->make_iterator());
        if (!m_xTreeView->get_selected(xSelected.get()))
            xSelected.reset();
        return nAction == implAcceptDataTransfer(aClipboardContent.GetDataFlavorExVector(), nAction, xSelected.get(), false);
    }
 
    sal_Int8 NavigatorTree::implAcceptDataTransfer( const DataFlavorExVector& _rFlavors, sal_Int8 _nAction, const weld::TreeIter* _pTargetEntry, bool _bDnD )
    {
        // no target -> no drop
        if (!_pTargetEntry)
            return DND_ACTION_NONE;
 
        // format check
        bool bHasDefControlFormat = OControlExchange::hasFieldExchangeFormat( _rFlavors );
        bool bHasControlPathFormat = OControlExchange::hasControlPathFormat( _rFlavors );
        bool bHasHiddenControlsFormat = OControlExchange::hasHiddenControlModelsFormat( _rFlavors );
        if (!bHasDefControlFormat && !bHasControlPathFormat && !bHasHiddenControlsFormat)
            return DND_ACTION_NONE;
 
        bool bSelfSource = _bDnD ? m_aControlExchange.isDragSource() : m_aControlExchange.isClipboardOwner();
 
        if ( bHasHiddenControlsFormat )
        {   // bHasHiddenControlsFormat means that only hidden controls are part of the data
 
            // hidden controls can be copied to a form only
            if (m_xTreeView->iter_compare(*_pTargetEntry, *m_xRootEntry) == 0 || !IsFormEntry(*_pTargetEntry))
                return DND_ACTION_NONE;
 
            return bSelfSource ? ( DND_ACTION_COPYMOVE & _nAction ) : DND_ACTION_COPY;
        }
 
        if  ( !bSelfSource )
        {
            // DnD or CnP crossing navigator boundaries
            // The main problem here is that the current API does not allow us to sneak into the content which
            // is to be inserted. So we have to allow it for the moment, but maybe reject later on (in the real drop).
 
            // TODO: this smart behaviour later on ... at the moment, we disallow data transfer crossing navigator
            // boundaries.
 
            return DND_ACTION_NONE;
        }
 
        DBG_ASSERT( _bDnD ? m_aControlExchange.isDragSource() : m_aControlExchange.isClipboardOwner(),
            "NavigatorTree::implAcceptDataTransfer: here only with source=dest!" );
            // somebody changed the logic of this method ...
 
        // from here on, I can work with m_aControlExchange instead of _rData!
 
        bool bForeignCollection = m_aControlExchange->getFormsRoot().get() != GetNavModel()->GetFormPage()->GetForms().get();
        if ( bForeignCollection )
        {
            // crossing shell/page boundaries, we can exchange hidden controls only
            // But if we survived the checks above, we do not have hidden controls.
            // -> no data transfer
            DBG_ASSERT( !bHasHiddenControlsFormat, "NavigatorTree::implAcceptDataTransfer: still hidden controls format!" );
                // somebody changed the logic of this method ...
 
            return DND_ACTION_COPY;
        }
 
        if (DND_ACTION_MOVE != _nAction) // 'normal' controls within a shell are moved only (never copied)
            return DND_ACTION_NONE;
 
        if ( m_bDragDataDirty || !bHasDefControlFormat )
        {
            if (!bHasControlPathFormat)
                // I am in the shell/page, which has the controls, but I have no format,
                // which survived the shell change (SVX_FM_CONTROLS_AS_PATH)
                return DND_ACTION_NONE;
 
            // I must recreate the list of the ExchangeObjects, because the shell was changed during dragging
            // (there are SvLBoxEntries in it, and we lost them during change)
            m_aControlExchange->buildListFromPath(m_xTreeView.get(), m_xRootEntry.get());
            m_bDragDataDirty = false;
        }
 
        // List of dropped entries from DragServer
        const ListBoxEntrySet& rDropped = m_aControlExchange->selected();
        DBG_ASSERT(!rDropped.empty(), "NavigatorTree::implAcceptDataTransfer: no entries !");
 
        bool bDropTargetIsComponent = IsFormComponentEntry( *_pTargetEntry );
 
        // conditions to disallow the drop
        // 0) the root entry is part of the list (can't DnD the root!)
        // 1) one of the dragged entries is to be dropped onto its own parent
        // 2) -               "       - is to be dropped onto itself
        // 3) -               "       - is a Form and to be dropped onto one of its descendants
        // 4) one of the entries is a control and to be dropped onto the root
        // 5) a control or form will be dropped onto a control which is _not_ a sibling (dropping onto a sibling
        //      means moving the control)
 
        // collect the ancestors of the drop target (speeds up 3)
        SvLBoxEntrySortedArray arrDropAncestors;
        std::unique_ptr<weld::TreeIter> xLoop(m_xTreeView->make_iterator(_pTargetEntry));
        do
        {
            arrDropAncestors.emplace(m_xTreeView->make_iterator(xLoop.get()));
        }
        while (m_xTreeView->iter_parent(*xLoop));
 
        for (const auto& rCurrent : rDropped)
        {
            // test for 0)
            if (m_xTreeView->iter_compare(*rCurrent, *m_xRootEntry) == 0)
                return DND_ACTION_NONE;
 
            std::unique_ptr<weld::TreeIter> xCurrentParent(m_xTreeView->make_iterator(rCurrent.get()));
            m_xTreeView->iter_parent(*xCurrentParent);
 
            // test for 1)
            if (m_xTreeView->iter_compare(*_pTargetEntry, *xCurrentParent) == 0)
                return DND_ACTION_NONE;
 
            // test for 2)
            if (m_xTreeView->iter_compare(*rCurrent, *_pTargetEntry) == 0)
                return DND_ACTION_NONE;
 
            // test for 5)
            if (bDropTargetIsComponent)
                return DND_ACTION_NONE;
 
            // test for 3)
            if (IsFormEntry(*rCurrent))
            {
                auto aIter = std::find_if(arrDropAncestors.begin(), arrDropAncestors.end(),
                                          [this, &rCurrent](const auto& rElem) {
                                            return m_xTreeView->iter_compare(*rElem, *rCurrent) == 0;
                                          });
 
                if ( aIter != arrDropAncestors.end() )
                    return DND_ACTION_NONE;
            }
            else if (IsFormComponentEntry(*rCurrent))
            {
                // test for 4)
                if (m_xTreeView->iter_compare(*_pTargetEntry, *m_xRootEntry) == 0)
                    return DND_ACTION_NONE;
            }
        }
        return DND_ACTION_MOVE;
    }
 
    sal_Int8 NavigatorTree::AcceptDrop( const AcceptDropEvent& rEvt )
    {
        ::Point aDropPos = rEvt.maPosPixel;
        std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator());
        // get_dest_row_at_pos with false cause we must drop exactly "on" a form to paste a control into it
        if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false))
            xDropTarget.reset();
        return implAcceptDataTransfer(m_aDropTargetHelper.GetDataFlavorExVector(), rEvt.mnAction, xDropTarget.get(), true);
    }
 
    sal_Int8 NavigatorTree::implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, const ::Point& _rDropPos, bool _bDnD )
    {
        std::unique_ptr<weld::TreeIter> xDrop(m_xTreeView->make_iterator());
        // get_dest_row_at_pos with false cause we must drop exactly "on" a form to paste a control into it
        if (!m_xTreeView->get_dest_row_at_pos(_rDropPos, xDrop.get(), false))
            xDrop.reset();
        return implExecuteDataTransfer( _rData, _nAction, xDrop.get(), _bDnD );
    }
 
    sal_Int8 NavigatorTree::implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, const weld::TreeIter* _pTargetEntry, bool _bDnD )
    {
        const DataFlavorExVector& rDataFlavors = _rData.GetDataFlavorExVector();
 
        if ( DND_ACTION_NONE == implAcceptDataTransfer( rDataFlavors, _nAction, _pTargetEntry, _bDnD ) )
            // under some platforms, it may happen that ExecuteDrop is called though AcceptDrop returned DND_ACTION_NONE
            return DND_ACTION_NONE;
 
        if (!_pTargetEntry)
            // no target -> no drop
            return DND_ACTION_NONE;
 
        // format checks
#ifdef DBG_UTIL
        bool bHasHiddenControlsFormat = OControlExchange::hasHiddenControlModelsFormat( rDataFlavors );
        bool bForeignCollection = _rData.getFormsRoot().get() != GetNavModel()->GetFormPage()->GetForms().get();
        DBG_ASSERT(!bForeignCollection || bHasHiddenControlsFormat, "NavigatorTree::implExecuteDataTransfer: invalid format (AcceptDrop shouldn't have let this pass) !");
        DBG_ASSERT(bForeignCollection || !m_bDragDataDirty, "NavigatorTree::implExecuteDataTransfer: invalid state (shell changed since last exchange resync) !");
            // this should be done in AcceptDrop: the list of controls is created in _rData
            // and m_bDragDataDirty is reset
#endif
 
        if ( DND_ACTION_COPY == _nAction )
        {   // bHasHiddenControlsFormat means that only hidden controls are part of the data
#ifdef DBG_UTIL
            DBG_ASSERT( bHasHiddenControlsFormat, "NavigatorTree::implExecuteDataTransfer: copy allowed for hidden controls only!" );
#endif
            DBG_ASSERT( _pTargetEntry && m_xTreeView->iter_compare(*_pTargetEntry, *m_xRootEntry) != 0 && IsFormEntry( *_pTargetEntry ),
                "NavigatorTree::implExecuteDataTransfer: should not be here!" );
                // implAcceptDataTransfer should have caught both cases
 
#ifdef DBG_UTIL
            DBG_ASSERT(bHasHiddenControlsFormat, "NavigatorTree::implExecuteDataTransfer: only copying of hidden controls is supported !");
                // should be caught by AcceptDrop
#endif
 
            // because i want to select all targets (and only them)
            m_xTreeView->unselect_all();
 
            const Sequence< Reference< XInterface > >& aControls = _rData.hiddenControls();
            sal_Int32 nCount = aControls.getLength();
            const Reference< XInterface >* pControls = aControls.getConstArray();
 
            FmFormShell* pFormShell = GetNavModel()->GetFormShell();
            FmFormModel* pFormModel = pFormShell ? pFormShell->GetFormModel() : nullptr;
 
            // within undo
            if (pFormModel)
            {
                OUString aStr(SvxResId(RID_STR_CONTROL));
                OUString aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_INSERT).replaceAll("#", aStr);
                pFormModel->BegUndo(aUndoStr);
            }
 
            // copy controls
            for (sal_Int32 i=0; i<nCount; ++i)
            {
                // create new control
                FmControlData* pNewControlData = NewControl( FM_COMPONENT_HIDDEN, *_pTargetEntry, false);
                Reference< XPropertySet >  xNewPropSet( pNewControlData->GetPropertySet() );
 
                // copy properties form old control to new one
                Reference< XPropertySet >  xCurrent(pControls[i], UNO_QUERY);
#if (OSL_DEBUG_LEVEL > 0)
                // check whether it is a hidden control
                sal_Int16 nClassId = ::comphelper::getINT16(xCurrent->getPropertyValue(FM_PROP_CLASSID));
                OSL_ENSURE(nClassId == FormComponentType::HIDDENCONTROL, "NavigatorTree::implExecuteDataTransfer: invalid control in drop list !");
                    // if SVX_FM_HIDDEN_CONTROLS-format exists, the sequence
                    // should only contain hidden controls
#endif // (OSL_DEBUG_LEVEL > 0)
                Reference< XPropertySetInfo >  xPropInfo( xCurrent->getPropertySetInfo());
                const Sequence< Property> seqAllCurrentProps = xPropInfo->getProperties();
                for (Property const & currentProp : seqAllCurrentProps)
                {
                    if (((currentProp.Attributes & PropertyAttribute::READONLY) == 0) && (currentProp.Name != FM_PROP_NAME))
                    {   // (read-only attribs aren't set, ditto name,
                        // NewControl defined it uniquely
                        xNewPropSet->setPropertyValue(currentProp.Name, xCurrent->getPropertyValue(currentProp.Name));
                    }
                }
 
                std::unique_ptr<weld::TreeIter> xToSelect = FindEntry(pNewControlData);
                m_xTreeView->select(*xToSelect);
                if (i == 0)
                    m_xTreeView->set_cursor(*xToSelect);
            }
 
            if (pFormModel)
                pFormModel->EndUndo();
 
            return _nAction;
        }
 
        if ( !OControlExchange::hasFieldExchangeFormat( _rData.GetDataFlavorExVector() ) )
        {
            // can't do anything without the internal format here ... usually happens when doing DnD or CnP
            // over navigator boundaries
            return DND_ACTION_NONE;
        }
 
        // some data for the target
        bool bDropTargetIsForm = IsFormEntry(*_pTargetEntry);
        FmFormData* pTargetData = bDropTargetIsForm ? weld::fromId<FmFormData*>(m_xTreeView->get_id(*_pTargetEntry)) : nullptr;
 
        DBG_ASSERT( DND_ACTION_COPY != _nAction, "NavigatorTree::implExecuteDataTransfer: somebody changed the logics!" );
 
        // list of dragged entries
        const ListBoxEntrySet& rDropped = _rData.selected();
        DBG_ASSERT(!rDropped.empty(), "NavigatorTree::implExecuteDataTransfer: no entries!");
 
        // make a copy because rDropped is updated on deleting an entry which we do in the processing loop
        ListBoxEntrySet aDropped;
        for (const auto& rEntry : rDropped)
            aDropped.emplace(m_xTreeView->make_iterator(rEntry.get()));
 
        // shell and model
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        FmFormModel* pFormModel = pFormShell ? pFormShell->GetFormModel() : nullptr;
        if (!pFormModel)
            return DND_ACTION_NONE;
 
        // for Undo
        const bool bUndo = pFormModel->IsUndoEnabled();
 
        if( bUndo )
        {
            OUString strUndoDescription(SvxResId(RID_STR_UNDO_CONTAINER_REPLACE));
            pFormModel->BegUndo(strUndoDescription);
        }
 
        // remove selection before adding an entry, so the mark doesn't flicker
        // -> lock action of selection
        LockSelectionHandling();
 
        // go through all dropped entries
        for (   ListBoxEntrySet::const_iterator dropped = aDropped.begin();
                dropped != aDropped.end();
                ++dropped
            )
        {
            bool bFirstEntry = aDropped.begin() == dropped;
 
            // some data of the current element
            const auto& rCurrent = *dropped;
            DBG_ASSERT(rCurrent, "NavigatorTree::implExecuteDataTransfer: invalid entry");
            DBG_ASSERT(m_xTreeView->get_iter_depth(*rCurrent) != 0, "NavigatorTree::implExecuteDataTransfer: invalid entry");
                // don't drag root
 
            FmEntryData* pCurrentUserData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rCurrent));
 
            Reference< XChild >  xCurrentChild = pCurrentUserData->GetChildIFace();
            Reference< XIndexContainer >  xContainer(xCurrentChild->getParent(), UNO_QUERY);
 
            FmFormData* pCurrentParentUserData = static_cast<FmFormData*>(pCurrentUserData->GetParent());
            DBG_ASSERT(pCurrentParentUserData == nullptr || dynamic_cast<const FmFormData*>(pCurrentUserData->GetParent()) !=  nullptr, "NavigatorTree::implExecuteDataTransfer: invalid parent");
 
            // remove from parent
            if (pCurrentParentUserData)
                pCurrentParentUserData->GetChildList()->removeNoDelete( pCurrentUserData );
            else
                GetNavModel()->GetRootList()->removeNoDelete( pCurrentUserData );
 
            // remove from container
            sal_Int32 nIndex = getElementPos(xContainer, xCurrentChild);
            GetNavModel()->m_pPropChangeList->Lock();
            // UndoAction for removal
            if ( bUndo && GetNavModel()->m_pPropChangeList->CanUndo())
            {
                pFormModel->AddUndo(std::make_unique<FmUndoContainerAction>(*pFormModel, FmUndoContainerAction::Removed,
                                                            xContainer, xCurrentChild, nIndex));
            }
            else if( !GetNavModel()->m_pPropChangeList->CanUndo() )
            {
                FmUndoContainerAction::DisposeElement( xCurrentChild );
            }
 
            // copy events
            Reference< XEventAttacherManager >  xManager(xContainer, UNO_QUERY);
            Sequence< ScriptEventDescriptor > aEvts;
 
            if (xManager.is() && nIndex >= 0)
                aEvts = xManager->getScriptEvents(nIndex);
            xContainer->removeByIndex(nIndex);
 
            // remove selection
            m_xTreeView->unselect(*rCurrent);
            // and delete it
            Remove(pCurrentUserData);
 
            // position in DropParents, where to insert dropped entries
            if (pTargetData)
                xContainer.set(pTargetData->GetElement(), UNO_QUERY);
            else
                xContainer = GetNavModel()->GetForms();
 
            // always insert at the end
            nIndex = xContainer->getCount();
 
            // UndoAction for insertion
            if ( bUndo && GetNavModel()->m_pPropChangeList->CanUndo())
                pFormModel->AddUndo(std::make_unique<FmUndoContainerAction>(*pFormModel, FmUndoContainerAction::Inserted,
                                                         xContainer, xCurrentChild, nIndex));
 
            // insert in new container
            if (pTargetData)
            {
                 // insert in a form needs a FormComponent
                xContainer->insertByIndex( nIndex,
                    Any( Reference< XFormComponent >( xCurrentChild, UNO_QUERY ) ) );
            }
            else
            {
                xContainer->insertByIndex( nIndex,
                    Any( Reference< XForm >( xCurrentChild, UNO_QUERY ) ) );
            }
 
            if (aEvts.hasElements())
            {
                xManager.set(xContainer, UNO_QUERY);
                if (xManager.is())
                    xManager->registerScriptEvents(nIndex, aEvts);
            }
 
            GetNavModel()->m_pPropChangeList->UnLock();
 
            // give an entry the new parent
            pCurrentUserData->SetParent(pTargetData);
 
            // give parent the new child
            if (pTargetData)
                pTargetData->GetChildList()->insert( std::unique_ptr<FmEntryData>(pCurrentUserData), nIndex );
            else
                GetNavModel()->GetRootList()->insert( std::unique_ptr<FmEntryData>(pCurrentUserData), nIndex );
 
            // announce to myself and reselect
            std::unique_ptr<weld::TreeIter> xNew = Insert( pCurrentUserData, nIndex );
            if (bFirstEntry && xNew)
            {
                if (m_xTreeView->iter_parent(*xNew))
                    m_xTreeView->expand_row(*xNew);
            }
        }
 
        UnlockSelectionHandling();
 
        if( bUndo )
            pFormModel->EndUndo();
 
        // During the move, the markings of the underlying view did not change (because the view is not affected by the logical
        // hierarchy of the form/control models. But my selection changed - which means I have to adjust it according to the
        // view marks, again.
        SynchronizeSelection();
 
        // in addition, with the move of controls such things as "the current form" may have changed - force the shell
        // to update itself accordingly
        if( pFormShell && pFormShell->GetImpl() && pFormShell->GetFormView() )
            pFormShell->GetImpl()->DetermineSelection_Lock( pFormShell->GetFormView()->GetMarkedObjectList() );
 
        if ( m_aControlExchange.isClipboardOwner() && ( DND_ACTION_MOVE == _nAction ) )
            m_aControlExchange->clear();
 
        return _nAction;
    }
 
    sal_Int8 NavigatorTree::ExecuteDrop( const ExecuteDropEvent& rEvt )
    {
        sal_Int8 nResult( DND_ACTION_NONE );
        if ( m_aControlExchange.isDragSource() )
            nResult = implExecuteDataTransfer( *m_aControlExchange, rEvt.mnAction, rEvt.maPosPixel, true );
        else
        {
            OControlTransferData aDroppedData( rEvt.maDropEvent.Transferable );
            nResult = implExecuteDataTransfer( aDroppedData, rEvt.mnAction, rEvt.maPosPixel, true );
        }
        return nResult;
    }
 
    void NavigatorTree::doPaste()
    {
        std::unique_ptr<weld::TreeIter> xSelected(m_xTreeView->make_iterator());
        if (!m_xTreeView->get_selected(xSelected.get()))
            xSelected.reset();
 
        try
        {
            if ( m_aControlExchange.isClipboardOwner() )
            {
                implExecuteDataTransfer( *m_aControlExchange, doingKeyboardCut( ) ? DND_ACTION_MOVE : DND_ACTION_COPY, xSelected.get(), false );
            }
            else
            {
                // the clipboard content
                Reference< XClipboard > xClipboard(m_xTreeView->get_clipboard());
                Reference< XTransferable > xTransferable;
                if ( xClipboard.is() )
                    xTransferable = xClipboard->getContents();
 
                OControlTransferData aClipboardContent( xTransferable );
                implExecuteDataTransfer( aClipboardContent, DND_ACTION_COPY, xSelected.get(), false );
            }
        }
        catch( const Exception& )
        {
            TOOLS_WARN_EXCEPTION( "svx", "NavigatorTree::doPaste" );
        }
    }
 
    void NavigatorTree::doCopy()
    {
        if ( implPrepareExchange( DND_ACTION_COPY ) )
        {
            m_aControlExchange.setClipboardListener( LINK( this, NavigatorTree, OnClipboardAction ) );
            m_aControlExchange.copyToClipboard(*m_xTreeView);
        }
    }
 
    void NavigatorTree::ModelHasRemoved(const weld::TreeIter* pTypedEntry)
    {
        if (doingKeyboardCut())
        {
            auto aIter = std::find_if(m_aCutEntries.begin(), m_aCutEntries.end(),
                                      [this, pTypedEntry](const auto& rElem) {
                                        return m_xTreeView->iter_compare(*rElem, *pTypedEntry) == 0;
                                      });
            if (aIter != m_aCutEntries.end())
                m_aCutEntries.erase(aIter);
        }
 
        if (m_aControlExchange.isDataExchangeActive())
        {
            if (0 == m_aControlExchange->onEntryRemoved(m_xTreeView.get(), pTypedEntry))
            {
                // last of the entries which we put into the clipboard has been deleted from the tree.
                // Give up the clipboard ownership.
                m_aControlExchange.clear();
            }
        }
    }
 
    void NavigatorTree::doCut()
    {
        if ( !implPrepareExchange( DND_ACTION_MOVE ) )
            return;
 
        m_aControlExchange.setClipboardListener( LINK( this, NavigatorTree, OnClipboardAction ) );
        m_aControlExchange.copyToClipboard(*m_xTreeView);
        m_bKeyboardCut = true;
 
        // mark all the entries we just "cut" into the clipboard as "nearly moved"
        for (const auto& rEntry : m_arrCurrentSelection )
        {
            if (!rEntry)
                continue;
            m_aCutEntries.emplace(m_xTreeView->make_iterator(rEntry.get()));
            m_xTreeView->set_sensitive(*rEntry, false);
        }
    }
 
    IMPL_LINK(NavigatorTree, KeyInputHdl, const ::KeyEvent&, rKEvt, bool)
    {
        const vcl::KeyCode& rCode = rKEvt.GetKeyCode();
 
        // delete?
        if (rCode.GetCode() == KEY_DELETE && !rCode.GetModifier())
        {
            DeleteSelection();
            return true;
        }
 
        // copy'n'paste?
        switch ( rCode.GetFunction() )
        {
            case KeyFuncType::CUT:
                doCut();
                break;
 
            case KeyFuncType::PASTE:
                if ( implAcceptPaste() )
                    doPaste();
                break;
 
            case KeyFuncType::COPY:
                doCopy();
                break;
 
            default:
                break;
        }
 
        return false;
    }
 
    IMPL_LINK(NavigatorTree, EditingEntryHdl, const weld::TreeIter&, rIter, bool)
    {
        // root, which isn't allowed to be renamed, has UserData=NULL
        m_bEditing = !m_xTreeView->get_id(rIter).isEmpty();
        return m_bEditing;
    }
 
    void NavigatorTree::NewForm(const weld::TreeIter& rParentEntry)
    {
        // get ParentFormData
        if (!IsFormEntry(rParentEntry))
            return;
 
        FmFormData* pParentFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(rParentEntry));
 
 
        // create new form
        Reference<XComponentContext> xContext = comphelper::getProcessComponentContext();
        Reference< XForm >  xNewForm(xContext->getServiceManager()->createInstanceWithContext(FM_SUN_COMPONENT_FORM, xContext), UNO_QUERY);
        if (!xNewForm.is())
            return;
 
        Reference< XPropertySet >  xPropertySet(xNewForm, UNO_QUERY);
        if (!xPropertySet.is())
            return;
 
        FmFormData* pNewFormData = new FmFormData(xNewForm, pParentFormData);
 
 
        // set name
        OUString aName = GenerateName(pNewFormData);
        pNewFormData->SetText(aName);
 
        try
        {
            xPropertySet->setPropertyValue( FM_PROP_NAME, Any(aName) );
            // a form should always have the command type table as default
            xPropertySet->setPropertyValue( FM_PROP_COMMANDTYPE, Any(sal_Int32(CommandType::TABLE)));
        }
        catch ( const Exception& )
        {
            OSL_FAIL("NavigatorTree::NewForm : could not set essential properties!");
        }
 
 
        // insert form
        GetNavModel()->Insert(pNewFormData, SAL_MAX_UINT32, true);
 
 
        // set new form as active
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if( pFormShell )
        {
            InterfaceBag aSelection;
            aSelection.insert( Reference<XInterface>( xNewForm, UNO_QUERY ) );
            pFormShell->GetImpl()->setCurrentSelection_Lock(std::move(aSelection));
 
            pFormShell->GetViewShell()->GetViewFrame().GetBindings().Invalidate(SID_FM_PROPERTIES, true, true);
        }
        GetNavModel()->SetModified();
 
        // switch to EditMode
        std::unique_ptr<weld::TreeIter> xNewEntry = FindEntry(pNewFormData);
        m_xTreeView->start_editing(*xNewEntry);
        m_bEditing = true;
    }
 
    FmControlData* NavigatorTree::NewControl(const OUString& rServiceName, const weld::TreeIter& rParentEntry, bool bEditName)
    {
        // get ParentForm
        if (!GetNavModel()->GetFormShell())
            return nullptr;
        if (!IsFormEntry(rParentEntry))
            return nullptr;
 
        FmFormData* pParentFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(rParentEntry));
        Reference<XForm>  xParentForm(pParentFormData->GetFormIface());
 
        // create new component
        Reference<XComponentContext> xContext = comphelper::getProcessComponentContext();
        Reference<XFormComponent> xNewComponent( xContext->getServiceManager()->createInstanceWithContext(rServiceName, xContext), UNO_QUERY);
        if (!xNewComponent.is())
            return nullptr;
 
        FmControlData* pNewFormControlData = new FmControlData(xNewComponent, pParentFormData);
 
        // set name
        OUString sName = FmFormPageImpl::setUniqueName( xNewComponent, xParentForm );
 
        pNewFormControlData->SetText( sName );
 
        // insert FormComponent
        GetNavModel()->Insert(pNewFormControlData, SAL_MAX_UINT32, true);
        GetNavModel()->SetModified();
 
        if (bEditName)
        {
            // switch to EditMode
            std::unique_ptr<weld::TreeIter> xNewEntry = FindEntry( pNewFormControlData );
            m_xTreeView->select(*xNewEntry);
 
            m_xTreeView->start_editing(*xNewEntry);
            m_bEditing = true;
        }
 
        return pNewFormControlData;
    }
 
    OUString NavigatorTree::GenerateName( FmEntryData const * pEntryData )
    {
        const sal_uInt16 nMaxCount = 99;
        OUString aNewName;
 
        // create base name
        OUString aBaseName;
        if( dynamic_cast<const FmFormData*>( pEntryData) !=  nullptr )
            aBaseName = SvxResId( RID_STR_STDFORMNAME );
        else if( dynamic_cast<const FmControlData*>( pEntryData) !=  nullptr )
            aBaseName = SvxResId( RID_STR_CONTROL );
 
 
        // create new name
        FmFormData* pFormParentData = static_cast<FmFormData*>(pEntryData->GetParent());
 
        for( sal_Int32 i=0; i<nMaxCount; i++ )
        {
            aNewName = aBaseName;
            if( i>0 )
            {
                aNewName += " " + OUString::number(i);
            }
 
            if( GetNavModel()->FindData(aNewName, pFormParentData,false) == nullptr )
                break;
        }
 
        return aNewName;
    }
 
    IMPL_LINK(NavigatorTree, EditedEntryHdl, const IterString&, rIterString, bool)
    {
        m_bEditing = false;
 
        const weld::TreeIter& rIter = rIterString.first;
 
        FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rIter));
        bool bRes = NavigatorTreeModel::Rename(pEntryData, rIterString.second);
        if (!bRes)
        {
            m_xEditEntry = m_xTreeView->make_iterator(&rIter);
            nEditEvent = Application::PostUserEvent(LINK(this, NavigatorTree, OnEdit));
        }
 
        return bRes;
    }
 
    IMPL_LINK_NOARG(NavigatorTree, OnEdit, void*, void)
    {
        nEditEvent = nullptr;
        m_xTreeView->start_editing(*m_xEditEntry);
        m_bEditing = true;
        m_xEditEntry.reset();
    }
 
    IMPL_LINK_NOARG(NavigatorTree, OnEntrySelDesel, weld::TreeView&, void)
    {
        m_sdiState = SDI_DIRTY;
 
        if (IsSelectionHandlingLocked())
            return;
 
        if (m_aSynchronizeTimer.IsActive())
            m_aSynchronizeTimer.Stop();
 
        m_aSynchronizeTimer.SetTimeout(EXPLORER_SYNC_DELAY);
        m_aSynchronizeTimer.Start();
    }
 
    IMPL_LINK_NOARG(NavigatorTree, OnSynchronizeTimer, Timer *, void)
    {
        SynchronizeMarkList();
    }
 
    IMPL_LINK_NOARG(NavigatorTree, OnClipboardAction, OLocalExchange&, void)
    {
        if ( m_aControlExchange.isClipboardOwner() )
            return;
 
        if ( !doingKeyboardCut() )
            return;
 
        for (const auto& rEntry : m_aCutEntries)
        {
            if (!rEntry)
                continue;
            m_xTreeView->set_sensitive(*rEntry, true);
        }
        ListBoxEntrySet().swap(m_aCutEntries);
 
        m_bKeyboardCut = false;
    }
 
    void NavigatorTree::ShowSelectionProperties(bool bForce)
    {
        // at first i need the FormShell
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if (!pFormShell)
            // no shell -> impossible to set curObject -> leave
            return;
 
        CollectSelectionData(SDI_ALL);
        SAL_WARN_IF(static_cast<size_t>(m_nFormsSelected + m_nControlsSelected
                + (m_bRootSelected ? 1 : 0)) != m_arrCurrentSelection.size(),
            "svx.form",
            "NavigatorTree::ShowSelectionProperties : selection meta data invalid !");
 
 
        InterfaceBag aSelection;
        bool bSetSelectionAsMarkList = false;
 
        if (m_bRootSelected)
            ;                                   // no properties for the root, neither for single nor for multi selection
        else if ( m_nFormsSelected + m_nControlsSelected == 0 )   // none of the two should be less 0
            ;                                   // no selection -> no properties
        else if ( m_nFormsSelected * m_nControlsSelected != 0 )
            ;                                   // mixed selection -> no properties
        else
        {   // either only forms, or only controls are selected
            if (m_arrCurrentSelection.size() == 1)
            {
                const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin();
                if (m_nFormsSelected > 0)
                {   // exactly one form is selected
                    FmFormData* pFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(*rIter));
                    aSelection.insert( Reference< XInterface >( pFormData->GetFormIface(), UNO_QUERY ) );
                }
                else
                {   // exactly one control is selected (whatever hidden or normal)
                    FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rIter));
 
                    aSelection.insert( Reference< XInterface >( pEntryData->GetElement(), UNO_QUERY ) );
                }
            }
            else
            {   // it's a MultiSelection, so we must build a MultiSet
                if (m_nFormsSelected > 0)
                {   // ... only forms
                    // first of all collect PropertySet-Interfaces of the forms
                    SvLBoxEntrySortedArray::const_iterator it = m_arrCurrentSelection.begin();
                    for ( sal_Int32 i = 0; i < m_nFormsSelected; ++i )
                    {
                        const std::unique_ptr<weld::TreeIter>& rIter = *it;
                        FmFormData* pFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(*rIter));
                        aSelection.insert( pFormData->GetPropertySet() );
                        ++it;
                    }
                }
                else
                {   // ... only controls
                    if (m_nHiddenControls == m_nControlsSelected)
                    {   // a MultiSet for properties of hidden controls
                        SvLBoxEntrySortedArray::const_iterator it = m_arrCurrentSelection.begin();
                        for ( sal_Int32 i = 0; i < m_nHiddenControls; ++i )
                        {
                            const std::unique_ptr<weld::TreeIter>& rIter = *it;
                            FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rIter));
                            aSelection.insert( pEntryData->GetPropertySet() );
                            ++it;
                        }
                    }
                    else if (m_nHiddenControls == 0)
                    {   // only normal controls
                        bSetSelectionAsMarkList = true;
                    }
                }
            }
 
        }
 
        // and now my form and my SelObject
        if ( bSetSelectionAsMarkList )
            pFormShell->GetImpl()->setCurrentSelectionFromMark_Lock(pFormShell->GetFormView()->GetMarkedObjectList());
        else
            pFormShell->GetImpl()->setCurrentSelection_Lock(std::move(aSelection));
 
        if (pFormShell->GetImpl()->IsPropBrwOpen_Lock() || bForce)
        {
            // and now deliver all to the PropertyBrowser
            pFormShell->GetViewShell()->GetViewFrame().GetDispatcher()->Execute( SID_FM_SHOW_PROPERTY_BROWSER, SfxCallMode::ASYNCHRON );
        }
    }
 
 
    void NavigatorTree::DeleteSelection()
    {
        // of course, i can't delete root
        bool bRootSelected = m_xTreeView->is_selected(*m_xRootEntry);
        auto nSelectedEntries = m_xTreeView->count_selected_rows();
        if (bRootSelected && (nSelectedEntries > 1))     // root and other elements ?
            m_xTreeView->unselect(*m_xRootEntry);                // yes -> remove root from selection
 
        if ((nSelectedEntries == 0) || bRootSelected)    // still root ?
            return;                                     // -> only selected element -> leave
 
        DBG_ASSERT(!m_bPrevSelectionMixed, "NavigatorTree::DeleteSelection() : delete permitted if mark and selection are inconsistent");
 
        // i need the FormModel later
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if (!pFormShell)
            return;
        FmFormModel* pFormModel = pFormShell->GetFormModel();
        if (!pFormModel)
            return;
 
        // now I have to safeguard the DeleteList: if you delete a form and a dependent element
        // - in this order - than the SvLBoxEntryPtr of the dependent element is already invalid,
        // when it should be deleted... you have to prohibit this GPF, that of course would happen,
        // so I take the 'normalized' list
        CollectSelectionData( SDI_NORMALIZED );
 
        // see below for why we need this mapping from models to shapes
        FmFormView*     pFormView       = pFormShell->GetFormView();
        SdrPageView*    pPageView       = pFormView ? pFormView->GetSdrPageView() : nullptr;
        SdrPage*        pPage           = pPageView ? pPageView->GetPage() : nullptr;
        DBG_ASSERT( pPage, "NavigatorTree::DeleteSelection: invalid form page!" );
 
        MapModelToShape aModelShapes;
        if ( pPage )
            collectShapeModelMapping( pPage, aModelShapes );
 
        // problem: we have to use ExplorerModel::Remove, since only this one properly deletes Form objects.
        // But, the controls themself must be deleted via DeleteMarked (else, the Writer has some problems
        // somewhere). In case I'd first delete the structure, then the controls, the UNDO would not work
        // (since UNDO then would mean to first restore the controls, then the structure, means their parent
        // form). The other way round, the EntryDatas would be invalid, if I'd first delete the controls and
        // then go on to the structure. This means I have to delete the forms *after* the normal controls, so
        // that during UNDO, they're restored in the proper order.
        pFormShell->GetImpl()->EnableTrackProperties_Lock(false);
        for (SvLBoxEntrySortedArray::reverse_iterator it = m_arrCurrentSelection.rbegin();
             it != m_arrCurrentSelection.rend(); )
        {
            const std::unique_ptr<weld::TreeIter>& rIter = *it;
            FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rIter));
 
            // a form ?
            auto pFormData = dynamic_cast<FmFormData*>(pCurrent);
 
            // because deletion is done by the view, and i build on its MarkList,
            // but normally only direct controls, no indirect ones, are marked in a marked form,
            // I have to do it later
            if (pFormData)
                MarkViewObj(pFormData, true/*deep*/);
 
            // a hidden control ?
            bool bIsHidden = IsHiddenControl(pCurrent);
 
            // keep forms and hidden controls, the rest not
            if (!pFormData && !bIsHidden)
            {
                // well, no form and no hidden control -> we can remove it from m_arrCurrentSelection, as it will
                // be deleted automatically. This is because for every model (except forms and hidden control models)
                // there exist a shape, which is marked _if_and_only_if_ the model is selected in our tree.
                if ( aModelShapes.find( pCurrent->GetElement() ) != aModelShapes.end() )
                {
                    // if there's a shape for the current entry, then either it is marked or it is in a
                    // hidden layer (#i28502#), or something like this.
                    // In the first case, it will be deleted below, in the second case, we currently don't
                    // delete it, as there's no real (working!) API for this, neither in UNO nor in non-UNO.
                    m_arrCurrentSelection.erase( --(it.base()) );
                }
                else
                   ++it;
                // In case there is no shape for the current entry, we keep the entry in m_arrCurrentSelection,
                // since then we can definitely remove it.
            }
            else
                ++it;
        }
        pFormShell->GetImpl()->EnableTrackProperties_Lock(true);
 
        // let the view delete the marked controls
        pFormShell->GetFormView()->DeleteMarked();
 
        // start UNDO at this point. Unfortunately, this results in 2 UNDO actions, since DeleteMarked is
        // creating an own one. However, if we'd move it before DeleteMarked, Writer does not really like
        // this ... :(
        // #i31038#
        {
 
            // initialize UNDO
            OUString aUndoStr;
            if ( m_arrCurrentSelection.size() == 1 )
            {
                aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_REMOVE);
                if (m_nFormsSelected)
                    aUndoStr = aUndoStr.replaceFirst( "#", SvxResId( RID_STR_FORM ) );
                else
                    // it must be a control (else the root would be selected, but it cannot be deleted)
                    aUndoStr = aUndoStr.replaceFirst( "#", SvxResId( RID_STR_CONTROL ) );
            }
            else
            {
                aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_REMOVE_MULTIPLE);
                aUndoStr = aUndoStr.replaceFirst( "#", OUString::number( m_arrCurrentSelection.size() ) );
            }
            pFormModel->BegUndo(aUndoStr);
        }
 
        // remove remaining structure
        for (const auto& rpSelection : m_arrCurrentSelection)
        {
            FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rpSelection));
 
            // if the entry still has children, we skipped deletion of one of those children.
            // This may for instance be because the shape is in a hidden layer, where we're unable
            // to remove it
            if ( pCurrent->GetChildList()->size() )
                continue;
 
            // one remaining subtle problem, before deleting it : if it's a form and the shell
            // knows it as CurrentObject, I have to tell it something else
            if (auto pFormData = dynamic_cast<FmFormData*>( pCurrent))
            {
                Reference< XForm >  xCurrentForm( pFormData->GetFormIface() );
                if (pFormShell->GetImpl()->getCurrentForm_Lock() == xCurrentForm)  // shell knows form to be deleted ?
                    pFormShell->GetImpl()->forgetCurrentForm_Lock();                 // -> take away ...
            }
            GetNavModel()->Remove(pCurrent, true);
        }
        pFormModel->EndUndo();
    }
 
 
    void NavigatorTree::CollectSelectionData(SELDATA_ITEMS sdiHow)
    {
        DBG_ASSERT(sdiHow != SDI_DIRTY, "NavigatorTree::CollectSelectionData : ever thought about your parameter ? DIRTY ?");
        if (sdiHow == m_sdiState)
            return;
 
        m_arrCurrentSelection.clear();
        m_nFormsSelected = m_nControlsSelected = m_nHiddenControls = 0;
        m_bRootSelected = false;
 
        m_xTreeView->selected_foreach([this, sdiHow](weld::TreeIter& rSelectionLoop){
            // count different elements
            if (m_xTreeView->iter_compare(rSelectionLoop, *m_xRootEntry) == 0)
                m_bRootSelected = true;
            else
            {
                if (IsFormEntry(rSelectionLoop))
                    ++m_nFormsSelected;
                else
                {
                    ++m_nControlsSelected;
                    if (IsHiddenControl(weld::fromId<FmEntryData*>(m_xTreeView->get_id(rSelectionLoop))))
                        ++m_nHiddenControls;
                }
            }
 
            if (sdiHow == SDI_NORMALIZED)
            {
                // don't take something with a selected ancestor
                if (m_xTreeView->iter_compare(rSelectionLoop, *m_xRootEntry) == 0)
                    m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop));
                else
                {
                    std::unique_ptr<weld::TreeIter> xParentLoop(m_xTreeView->make_iterator(&rSelectionLoop));
                    bool bParentLoop = m_xTreeView->iter_parent(*xParentLoop);
                    while (bParentLoop)
                    {
                        // actually i would have to test, if parent is part of m_arr_CurrentSelection ...
                        // but if it's selected, then it's in m_arrCurrentSelection
                        // or one of its ancestors, which was selected earlier.
                        // In both cases IsSelected is enough
                        if (m_xTreeView->is_selected(*xParentLoop))
                            break;
                        else
                        {
                            if (m_xTreeView->iter_compare(*xParentLoop, *m_xRootEntry) == 0)
                            {
                                // until root (exclusive), there was no selected parent -> entry belongs to normalized list
                                m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop));
                                break;
                            }
                            else
                                bParentLoop = m_xTreeView->iter_parent(*xParentLoop);
                        }
                    }
                }
            }
            else if (sdiHow == SDI_NORMALIZED_FORMARK)
            {
                std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rSelectionLoop));
                bool bParent = m_xTreeView->iter_parent(*xParent);
                if (!bParent || !m_xTreeView->is_selected(*xParent) || IsFormEntry(rSelectionLoop))
                    m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop));
            }
            else
                m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop));
 
            return false;
        });
 
        m_sdiState = sdiHow;
    }
 
    void NavigatorTree::SynchronizeSelection(FmEntryDataArray& arredToSelect)
    {
        LockSelectionHandling();
        if (arredToSelect.empty())
        {
            m_xTreeView->unselect_all();
        }
        else
        {
            // compare current selection with requested SelectList
            m_xTreeView->selected_foreach([this, &arredToSelect](weld::TreeIter& rSelection) {
                FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rSelection));
                if (pCurrent != nullptr)
                {
                    FmEntryDataArray::iterator it = arredToSelect.find(pCurrent);
                    if ( it != arredToSelect.end() )
                    {   // entry already selected, but also in SelectList
                        // remove it from there
                        arredToSelect.erase(it);
                    } else
                    {   // entry selected, but not in SelectList -> remove selection
                        m_xTreeView->unselect(rSelection);
                        // make it visible (maybe it's the only modification i do in this handler
                        // so you should see it
                        m_xTreeView->scroll_to_row(rSelection);
                    }
                }
                else
                    m_xTreeView->unselect(rSelection);
 
                return false;
            });
 
            // now SelectList contains only entries, which have to be selected
            // two possibilities : 1) run through SelectList, get SvTreeListEntry for every entry and select it (is more intuitive)
            // 2) run through my SvLBoxEntries and select those, i can find in the SelectList
            // 1) needs =(k*n) (k=length of SelectList, n=number of entries),
            // plus the fact, that FindEntry uses extensive IsEqualWithoutChilden instead of comparing pointer to UserData
            // 2) needs =(n*log k), duplicates some code from FindEntry
            // This may be a frequently used code ( at every change in mark of the view!),
            // so i use latter one
            m_xTreeView->all_foreach([this, &arredToSelect](weld::TreeIter& rLoop){
                FmEntryData* pCurEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rLoop));
                FmEntryDataArray::iterator it = arredToSelect.find(pCurEntryData);
                if (it != arredToSelect.end())
                {
                    m_xTreeView->select(rLoop);
                    m_xTreeView->scroll_to_row(rLoop);
                }
 
                return false;
            });
        }
        UnlockSelectionHandling();
    }
 
 
    void NavigatorTree::SynchronizeSelection()
    {
        // shell and view
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if(!pFormShell) return;
 
        FmFormView* pFormView = pFormShell->GetFormView();
        if (!pFormView) return;
 
        GetNavModel()->BroadcastMarkedObjects(pFormView->GetMarkedObjectList());
    }
 
 
    void NavigatorTree::SynchronizeMarkList()
    {
        // i'll need this shell
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if (!pFormShell) return;
 
        CollectSelectionData(SDI_NORMALIZED_FORMARK);
 
        // the view shouldn't notify now if MarkList changed
        pFormShell->GetImpl()->EnableTrackProperties_Lock(false);
 
        UnmarkAllViewObj();
 
        for (auto& rSelectionLoop : m_arrCurrentSelection)
        {
            // When form selection, mark all controls of form
            if (IsFormEntry(*rSelectionLoop) && m_xTreeView->iter_compare(*rSelectionLoop, *m_xRootEntry) != 0)
                MarkViewObj(weld::fromId<FmFormData*>(m_xTreeView->get_id(*rSelectionLoop)), false/*deep*/);
 
            // When control selection, mark Control-SdrObjects
            else if (IsFormComponentEntry(*rSelectionLoop))
            {
                FmControlData* pControlData = weld::fromId<FmControlData*>(m_xTreeView->get_id(*rSelectionLoop));
                if (pControlData)
                {
 
                    // When HiddenControl no object can be selected
                    Reference< XFormComponent >  xFormComponent( pControlData->GetFormComponent());
                    if (!xFormComponent.is())
                        continue;
                    Reference< XPropertySet >  xSet(xFormComponent, UNO_QUERY);
                    if (!xSet.is())
                        continue;
 
                    sal_uInt16 nClassId = ::comphelper::getINT16(xSet->getPropertyValue(FM_PROP_CLASSID));
                    if (nClassId != FormComponentType::HIDDENCONTROL)
                        MarkViewObj(pControlData);
                }
            }
        }
 
        // if PropertyBrowser is open, I have to adopt it according to my selection
        // (Not as MarkList of view : if a form is selected, all belonging controls are selected in the view
        // but of course i want to see the form-properties
        ShowSelectionProperties();
 
        // reset flag at view
        pFormShell->GetImpl()->EnableTrackProperties_Lock(true);
 
        // if exactly one form is selected now, shell should notice it as CurrentForm
        // (if selection handling isn't locked, view cares about it in MarkListHasChanged
        // but mechanism doesn't work, if form is empty for example
        if ((m_arrCurrentSelection.size() != 1) || (m_nFormsSelected != 1))
            return;
 
        std::unique_ptr<weld::TreeIter> xSelected(m_xTreeView->make_iterator());
        if (!m_xTreeView->get_selected(xSelected.get()))
            xSelected.reset();
        FmFormData* pSingleSelectionData = xSelected ? dynamic_cast<FmFormData*>(weld::fromId<FmEntryData*>(m_xTreeView->get_id(*xSelected)))
                                                     : nullptr;
        DBG_ASSERT( pSingleSelectionData, "NavigatorTree::SynchronizeMarkList: invalid selected form!" );
        if ( pSingleSelectionData )
        {
            InterfaceBag aSelection;
            aSelection.insert( Reference< XInterface >( pSingleSelectionData->GetFormIface(), UNO_QUERY ) );
            pFormShell->GetImpl()->setCurrentSelection_Lock(std::move(aSelection));
        }
    }
 
    bool NavigatorTree::IsHiddenControl(FmEntryData const * pEntryData)
    {
        if (pEntryData == nullptr) return false;
 
        Reference< XPropertySet > xProperties( pEntryData->GetPropertySet() );
        if (::comphelper::hasProperty(FM_PROP_CLASSID, xProperties))
        {
            Any aClassID = xProperties->getPropertyValue( FM_PROP_CLASSID );
            return (::comphelper::getINT16(aClassID) == FormComponentType::HIDDENCONTROL);
        }
        return false;
    }
 
    void NavigatorTree::UnmarkAllViewObj()
    {
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if( !pFormShell )
            return;
        FmFormView* pFormView = pFormShell->GetFormView();
        pFormView->UnMarkAll();
    }
 
    void NavigatorTree::MarkViewObj(FmFormData const * pFormData, bool bDeep )
    {
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if( !pFormShell )
            return;
 
        // first collect all sdrobjects
        ::std::set< Reference< XFormComponent > > aObjects;
        CollectObjects(pFormData,bDeep,aObjects);
 
 
        // find and select appropriate SdrObj in page
        FmFormView*     pFormView       = pFormShell->GetFormView();
        SdrPageView*    pPageView       = pFormView->GetSdrPageView();
        SdrPage*        pPage           = pPageView->GetPage();
        //FmFormPage*     pFormPage       = dynamic_cast< FmFormPage* >( pPage );
 
        SdrObjListIter aIter( pPage );
        while ( aIter.IsMore() )
        {
            SdrObject* pSdrObject = aIter.Next();
            FmFormObj* pFormObject = FmFormObj::GetFormObject( pSdrObject );
            if ( !pFormObject )
                continue;
 
            Reference< XFormComponent > xControlModel( pFormObject->GetUnoControlModel(),UNO_QUERY );
            if ( xControlModel.is() && aObjects.find(xControlModel) != aObjects.end() && !pFormView->IsObjMarked( pSdrObject ) )
            {
                // unfortunately, the writer doesn't like marking an already-marked object, again, so reset the mark first
                pFormView->MarkObj( pSdrObject, pPageView );
            }
        } // while ( aIter.IsMore() )
        // make the mark visible
        ::tools::Rectangle aMarkRect( pFormView->GetAllMarkedRect());
        for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i )
        {
            SdrPaintWindow* pPaintWindow = pFormView->GetPaintWindow( i );
            OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
            if ( ( OUTDEV_WINDOW == rOutDev.GetOutDevType() ) && !aMarkRect.IsEmpty() )
            {
                pFormView->MakeVisible( aMarkRect, *rOutDev.GetOwnerWindow() );
            }
        } // for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i )
    }
 
    void NavigatorTree::CollectObjects(FmFormData const * pFormData, bool bDeep, ::std::set< Reference< XFormComponent > >& _rObjects)
    {
        FmEntryDataList* pChildList = pFormData->GetChildList();
        for( size_t i = 0; i < pChildList->size(); ++i )
        {
            FmEntryData* pEntryData = pChildList->at( i );
            if( auto pControlData = dynamic_cast<FmControlData*>( pEntryData) )
            {
                _rObjects.insert(pControlData->GetFormComponent());
            } // if( dynamic_cast<const FmControlData*>( pEntryData) !=  nullptr )
            else if (bDeep)
                if (auto pEntryFormData = dynamic_cast<FmFormData*>( pEntryData))
                    CollectObjects(pEntryFormData, bDeep, _rObjects);
        } // for( sal_uInt32 i=0; i<pChildList->Count(); i++ )
    }
 
    void NavigatorTree::MarkViewObj( FmControlData const * pControlData)
    {
        if( !pControlData )
            return;
        FmFormShell* pFormShell = GetNavModel()->GetFormShell();
        if( !pFormShell )
            return;
 
 
        // find and select appropriate SdrObj
        FmFormView*     pFormView       = pFormShell->GetFormView();
        Reference< XFormComponent >  xFormComponent( pControlData->GetFormComponent());
        SdrPageView*    pPageView       = pFormView->GetSdrPageView();
        SdrPage*        pPage           = pPageView->GetPage();
 
        bool bPaint = false;
        SdrObjListIter aIter( pPage );
        while ( aIter.IsMore() )
        {
            SdrObject* pSdrObject = aIter.Next();
            FmFormObj* pFormObject = FmFormObj::GetFormObject( pSdrObject );
            if ( !pFormObject )
                continue;
 
            Reference< XInterface > xControlModel( pFormObject->GetUnoControlModel() );
            if ( xControlModel != xFormComponent )
                continue;
 
            // mark the object
            if ( !pFormView->IsObjMarked( pSdrObject ) )
                // unfortunately, the writer doesn't like marking an already-marked object, again, so reset the mark first
                pFormView->MarkObj( pSdrObject, pPageView );
 
            bPaint = true;
 
        } // while ( aIter.IsMore() )
        if ( !bPaint )
            return;
 
        // make the mark visible
        ::tools::Rectangle aMarkRect( pFormView->GetAllMarkedRect());
        for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i )
        {
            SdrPaintWindow* pPaintWindow = pFormView->GetPaintWindow( i );
            OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
            if ( OUTDEV_WINDOW == rOutDev.GetOutDevType() )
            {
                pFormView->MakeVisible( aMarkRect, *rOutDev.GetOwnerWindow() );
            }
        } // for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i )
    }
 
 
}
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */