Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 465 insertions, 0 deletions

diff --git a/sfx2/source/control/objface.cxx b/sfx2/source/control/objface.cxx
new file mode 100644
index 000000000..d794d715a
--- /dev/null
+++ b/sfx2/source/control/objface.cxx
@@ -0,0 +1,465 @@
+/* -*- 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 <assert.h>
+#include <stdlib.h>
+
+#include <sal/log.hxx>
+
+#include <sfx2/module.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/msgpool.hxx>
+
+extern "C" {
+
+static int
+SfxCompareSlots_qsort( const void* pSmaller, const void* pBigger )
+{
+    return static_cast<int>(static_cast<SfxSlot const *>(pSmaller)->GetSlotId()) -
+           static_cast<int>(static_cast<SfxSlot const *>(pBigger)->GetSlotId());
+}
+
+static int
+SfxCompareSlots_bsearch( const void* pSmaller, const void* pBigger )
+{
+    return static_cast<int>(*static_cast<sal_uInt16 const *>(pSmaller)) -
+           static_cast<int>(static_cast<SfxSlot const *>(pBigger)->GetSlotId());
+}
+
+}
+
+namespace {
+
+struct SfxObjectUI_Impl
+{
+    sal_uInt16         nPos;
+    SfxVisibilityFlags nFlags;
+    sal_uInt32         nObjId;
+    bool               bContext;
+    SfxShellFeature    nFeature;
+
+    SfxObjectUI_Impl(sal_uInt16 n, SfxVisibilityFlags f, sal_uInt32 nId, SfxShellFeature nFeat) :
+        nPos(n),
+        nFlags(f),
+        nObjId(nId),
+        bContext(false),
+        nFeature(nFeat)
+    {
+    }
+};
+
+}
+
+struct SfxInterface_Impl
+{
+    std::vector<std::unique_ptr<SfxObjectUI_Impl>>
+                            aObjectBars;    // registered ObjectBars
+    std::vector<std::unique_ptr<SfxObjectUI_Impl>>
+                            aChildWindows;  // registered ChildWindows
+    OUString                aPopupName;     // registered PopupMenu
+    StatusBarId             eStatBarResId;  // registered StatusBar
+    SfxModule*              pModule;
+    bool                    bRegistered;
+
+    SfxInterface_Impl()
+        : eStatBarResId(StatusBarId::None)
+        , pModule(nullptr)
+        , bRegistered(false)
+    {
+    }
+};
+
+static SfxObjectUI_Impl* CreateObjectBarUI_Impl(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId, SfxShellFeature nFeature);
+
+// constructor, registers a new unit
+SfxInterface::SfxInterface( const char *pClassName,
+                            bool bUsableSuperClass,
+                            SfxInterfaceId nId,
+                            const SfxInterface* pParent,
+                            SfxSlot &rSlotMap, sal_uInt16 nSlotCount ):
+    pName(pClassName),
+    pGenoType(pParent),
+    nClassId(nId),
+    bSuperClass(bUsableSuperClass),
+    pImplData(new SfxInterface_Impl)
+{
+    SetSlotMap( rSlotMap, nSlotCount );
+}
+
+void SfxInterface::Register( SfxModule* pMod )
+{
+    pImplData->bRegistered = true;
+    pImplData->pModule = pMod;
+    if ( pMod )
+        pMod->GetSlotPool()->RegisterInterface(*this);
+    else
+        SfxGetpApp()->GetAppSlotPool_Impl().RegisterInterface(*this);
+}
+
+void SfxInterface::SetSlotMap( SfxSlot& rSlotMap, sal_uInt16 nSlotCount )
+{
+    pSlots = &rSlotMap;
+    nCount = nSlotCount;
+    SfxSlot* pIter = pSlots;
+    if ( 1 == nCount && !pIter->pNextSlot )
+        pIter->pNextSlot = pIter;
+
+    if ( !pIter->pNextSlot )
+    {
+        // sort the SfxSlots by id
+        qsort( pSlots, nCount, sizeof(SfxSlot), SfxCompareSlots_qsort );
+
+        // link masters and slaves
+        sal_uInt16 nIter = 1;
+        for ( pIter = pSlots; nIter <= nCount; ++pIter, ++nIter )
+        {
+
+            assert( nIter == nCount ||
+                    pIter->GetSlotId() != (pIter+1)->GetSlotId() );
+
+            if ( nullptr == pIter->GetNextSlot() )
+            {
+                // Slots referring in circle to the next with the same
+                // Status method.
+                SfxSlot *pLastSlot = pIter;
+                for ( sal_uInt16 n = nIter; n < Count(); ++n )
+                {
+                    SfxSlot *pCurSlot = pSlots+n;
+                    if ( pCurSlot->GetStateFnc() == pIter->GetStateFnc() )
+                    {
+                        pLastSlot->pNextSlot = pCurSlot;
+                        pLastSlot = pCurSlot;
+                    }
+                }
+                pLastSlot->pNextSlot = pIter;
+            }
+        }
+    }
+#ifdef DBG_UTIL
+    else
+    {
+        sal_uInt16 nIter = 1;
+        for ( SfxSlot *pNext = pIter+1; nIter < nCount; ++pNext, ++nIter )
+        {
+
+            if ( pNext->GetSlotId() <= pIter->GetSlotId() )
+                SAL_WARN( "sfx.control", "Wrong order" );
+
+            const SfxSlot *pCurSlot = pIter;
+            do
+            {
+                pCurSlot = pCurSlot->pNextSlot;
+                if ( pCurSlot->GetStateFnc() != pIter->GetStateFnc() )
+                {
+                    SAL_WARN("sfx.control", "Linked Slots with different State Methods : "
+                                << pCurSlot->GetSlotId()
+                                << " , " << pIter->GetSlotId() );
+                }
+            }
+            while ( pCurSlot != pIter );
+
+            pIter = pNext;
+        }
+    }
+#endif
+}
+
+
+SfxInterface::~SfxInterface()
+{
+    SfxModule *pMod = pImplData->pModule;
+    bool bRegistered = pImplData->bRegistered;
+    assert( bRegistered );
+    if ( bRegistered )
+    {
+        if ( pMod )
+        {
+            // can return nullptr if we are called from the SfxSlotPool destructor
+            if (pMod->GetSlotPool())
+                pMod->GetSlotPool()->ReleaseInterface(*this);
+        }
+        else
+            SfxGetpApp()->GetAppSlotPool_Impl().ReleaseInterface(*this);
+    }
+}
+
+
+// searches for the specified func
+
+const SfxSlot* SfxInterface::GetSlot( sal_uInt16 nFuncId ) const
+{
+
+    assert( pSlots );
+    assert( nCount );
+
+    // find the id using binary search
+    void* p = bsearch( &nFuncId, pSlots, nCount, sizeof(SfxSlot),
+                       SfxCompareSlots_bsearch );
+    if ( !p && pGenoType )
+        return pGenoType->GetSlot( nFuncId );
+
+    return static_cast<const SfxSlot*>(p);
+}
+
+const SfxSlot* SfxInterface::GetSlot( const OUString& rCommand ) const
+{
+    static const char UNO_COMMAND[] = ".uno:";
+
+    OUString aCommand( rCommand );
+    if ( aCommand.startsWith( UNO_COMMAND ) )
+         aCommand = aCommand.copy( sizeof( UNO_COMMAND )-1 );
+
+    for ( sal_uInt16 n=0; n<nCount; n++ )
+    {
+        if ( (pSlots+n)->pUnoName &&
+             aCommand.compareToIgnoreAsciiCaseAscii( (pSlots+n)->GetUnoName() ) == 0 )
+            return pSlots+n;
+    }
+
+    return pGenoType ? pGenoType->GetSlot( aCommand ) : nullptr;
+}
+
+
+const SfxSlot* SfxInterface::GetRealSlot( const SfxSlot *pSlot ) const
+{
+
+    assert( pSlots );
+    assert( nCount );
+
+    if ( !ContainsSlot_Impl(pSlot) )
+    {
+        if(pGenoType)
+            return pGenoType->GetRealSlot(pSlot);
+        SAL_WARN( "sfx.control", "unknown Slot" );
+        return nullptr;
+    }
+
+    return nullptr;
+}
+
+
+void SfxInterface::RegisterPopupMenu( const OUString& rResourceName )
+{
+    pImplData->aPopupName = rResourceName;
+}
+
+void SfxInterface::RegisterObjectBar(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId)
+{
+    RegisterObjectBar(nPos, nFlags, eId, SfxShellFeature::NONE);
+}
+
+void SfxInterface::RegisterObjectBar(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId, SfxShellFeature nFeature)
+{
+    SfxObjectUI_Impl* pUI = CreateObjectBarUI_Impl(nPos, nFlags, eId, nFeature);
+    if ( pUI )
+        pImplData->aObjectBars.emplace_back(pUI);
+}
+
+SfxObjectUI_Impl* CreateObjectBarUI_Impl(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId, SfxShellFeature nFeature)
+{
+    if (nFlags == SfxVisibilityFlags::Invisible)
+        nFlags |= SfxVisibilityFlags::Standard;
+
+    return new SfxObjectUI_Impl(nPos, nFlags, static_cast<sal_uInt32>(eId), nFeature);
+}
+
+ToolbarId SfxInterface::GetObjectBarId(sal_uInt16 nNo) const
+{
+    bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
+    if ( bGenoType )
+    {
+        // Are there toolbars in the super class?
+        sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
+        if ( nNo < nBaseCount )
+            // The Super class comes first
+            return pGenoType->GetObjectBarId(nNo);
+        else
+            nNo = nNo - nBaseCount;
+    }
+
+    assert( nNo<pImplData->aObjectBars.size() );
+
+    return static_cast<ToolbarId>(pImplData->aObjectBars[nNo]->nObjId);
+}
+
+sal_uInt16 SfxInterface::GetObjectBarPos( sal_uInt16 nNo ) const
+{
+    bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
+    if ( bGenoType )
+    {
+        // Are there toolbars in the super class?
+        sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
+        if ( nNo < nBaseCount )
+            // The Super class comes first
+            return pGenoType->GetObjectBarPos( nNo );
+        else
+            nNo = nNo - nBaseCount;
+    }
+
+    assert( nNo<pImplData->aObjectBars.size() );
+
+    return pImplData->aObjectBars[nNo]->nPos;
+}
+
+SfxVisibilityFlags SfxInterface::GetObjectBarFlags( sal_uInt16 nNo ) const
+{
+    bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
+    if ( bGenoType )
+    {
+        // Are there toolbars in the super class?
+        sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
+        if ( nNo < nBaseCount )
+            // The Super class comes first
+            return pGenoType->GetObjectBarFlags( nNo );
+        else
+            nNo = nNo - nBaseCount;
+    }
+
+    assert( nNo<pImplData->aObjectBars.size() );
+
+    return pImplData->aObjectBars[nNo]->nFlags;
+}
+
+sal_uInt16 SfxInterface::GetObjectBarCount() const
+{
+    if (pGenoType && pGenoType->UseAsSuperClass())
+        return pImplData->aObjectBars.size() + pGenoType->GetObjectBarCount();
+    else
+        return pImplData->aObjectBars.size();
+}
+
+void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext)
+{
+    RegisterChildWindow(nId, bContext, SfxShellFeature::NONE);
+}
+
+void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext, SfxShellFeature nFeature)
+{
+    SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(0, SfxVisibilityFlags::Invisible, nId, nFeature);
+    pUI->bContext = bContext;
+    pImplData->aChildWindows.emplace_back(pUI);
+}
+
+void SfxInterface::RegisterStatusBar(StatusBarId eId)
+{
+    pImplData->eStatBarResId = eId;
+}
+
+sal_uInt32 SfxInterface::GetChildWindowId (sal_uInt16 nNo) const
+{
+    if ( pGenoType )
+    {
+        // Are there ChildWindows in the superclass?
+        sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
+        if ( nNo < nBaseCount )
+            // The Super class comes first
+            return pGenoType->GetChildWindowId( nNo );
+        else
+            nNo = nNo - nBaseCount;
+    }
+
+    assert( nNo<pImplData->aChildWindows.size() );
+
+    sal_uInt32 nRet = pImplData->aChildWindows[nNo]->nObjId;
+    if ( pImplData->aChildWindows[nNo]->bContext )
+        nRet += sal_uInt16( nClassId ) << 16;
+    return nRet;
+}
+
+SfxShellFeature SfxInterface::GetChildWindowFeature (sal_uInt16 nNo) const
+{
+    if ( pGenoType )
+    {
+        // Are there ChildWindows in the superclass?
+        sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
+        if ( nNo < nBaseCount )
+            // The Super class comes first
+            return pGenoType->GetChildWindowFeature( nNo );
+        else
+            nNo = nNo - nBaseCount;
+    }
+
+    assert( nNo<pImplData->aChildWindows.size() );
+
+    return pImplData->aChildWindows[nNo]->nFeature;
+}
+
+
+sal_uInt16 SfxInterface::GetChildWindowCount() const
+{
+    if (pGenoType)
+        return pImplData->aChildWindows.size() + pGenoType->GetChildWindowCount();
+    else
+        return pImplData->aChildWindows.size();
+}
+
+const OUString& SfxInterface::GetPopupMenuName() const
+{
+    return pImplData->aPopupName;
+}
+
+StatusBarId SfxInterface::GetStatusBarId() const
+{
+    if (pImplData->eStatBarResId == StatusBarId::None && pGenoType)
+        return pGenoType->GetStatusBarId();
+    else
+        return pImplData->eStatBarResId;
+}
+
+SfxShellFeature SfxInterface::GetObjectBarFeature ( sal_uInt16 nNo ) const
+{
+    bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
+    if ( bGenoType )
+    {
+        // Are there toolbars in the super class?
+        sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
+        if ( nNo < nBaseCount )
+            // The Super class comes first
+            return pGenoType->GetObjectBarFeature( nNo );
+        else
+            nNo = nNo - nBaseCount;
+    }
+
+    assert( nNo<pImplData->aObjectBars.size() );
+
+    return pImplData->aObjectBars[nNo]->nFeature;
+}
+
+bool SfxInterface::IsObjectBarVisible(sal_uInt16 nNo) const
+{
+    bool bGenoType = (pGenoType != nullptr && pGenoType->UseAsSuperClass());
+    if ( bGenoType )
+    {
+        // Are there toolbars in the super class?
+        sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
+        if ( nNo < nBaseCount )
+            // The Super class comes first
+            return pGenoType->IsObjectBarVisible( nNo );
+        else
+            nNo = nNo - nBaseCount;
+    }
+
+    assert( nNo<pImplData->aObjectBars.size() );
+
+    return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */