/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <sal/log.hxx>

#include <osl/diagnose.h>

// due to pSlotPool

#include <appdata.hxx>

#include <sfx2/msgpool.hxx>

#include <sfx2/msg.hxx>

#include <sfx2/app.hxx>

#include <sfx2/objface.hxx>

#include <sfx2/sfxresid.hxx>

#include <sfx2/module.hxx>

#include <sfx2/strings.hrc>

SfxSlotPool::SfxSlotPool(SfxSlotPool *pParent)

 : _pParentPool( pParent )

 , _nCurGroup(0)

 , _nCurInterface(0)

 , _nCurMsg(0)

{

}

SfxSlotPool::~SfxSlotPool()

{

    _pParentPool = nullptr;

    // swap out _vInterfaces because ~SfxInterface() might call ReleaseInterface()

    std::vector<SfxInterface*> tmpInterfaces;

    tmpInterfaces.swap(_vInterfaces);

    for ( SfxInterface *pIF : tmpInterfaces )

        delete pIF;

}

namespace

{

    TranslateId getGidResId(SfxGroupId nId)

    {

        if (nId == SfxGroupId::Intern)

            return STR_GID_INTERN;

        else if (nId == SfxGroupId::Application)

            return STR_GID_APPLICATION;

        else if (nId == SfxGroupId::View)

            return STR_GID_VIEW;

        else if (nId == SfxGroupId::Document)

            return STR_GID_DOCUMENT;

        else if (nId == SfxGroupId::Edit)

            return STR_GID_EDIT;

        else if (nId == SfxGroupId::Macro)

            return STR_GID_MACRO;

        else if (nId == SfxGroupId::Options)

            return STR_GID_OPTIONS;

        else if (nId == SfxGroupId::Math)

            return STR_GID_MATH;

        else if (nId == SfxGroupId::Navigator)

            return STR_GID_NAVIGATOR;

        else if (nId == SfxGroupId::Insert)

            return STR_GID_INSERT;

        else if (nId == SfxGroupId::Format)

            return STR_GID_FORMAT;

        else if (nId == SfxGroupId::Template)

            return STR_GID_TEMPLATE;

        else if (nId == SfxGroupId::Text)

            return STR_GID_TEXT;

        else if (nId == SfxGroupId::Frame)

            return STR_GID_FRAME;

        else if (nId == SfxGroupId::Graphic)

            return STR_GID_GRAPHIC;

        else if (nId == SfxGroupId::Table)

            return STR_GID_TABLE;

        else if (nId == SfxGroupId::Enumeration)

            return STR_GID_ENUMERATION;

        else if (nId == SfxGroupId::Data)

            return STR_GID_DATA;

        else if (nId == SfxGroupId::Special)

            return STR_GID_SPECIAL;

        else if (nId == SfxGroupId::Image)

            return STR_GID_IMAGE;

        else if (nId == SfxGroupId::Chart)

            return STR_GID_CHART;

        else if (nId == SfxGroupId::Explorer)

            return STR_GID_EXPLORER;

        else if (nId == SfxGroupId::Connector)

            return STR_GID_CONNECTOR;

        else if (nId == SfxGroupId::Modify)

            return STR_GID_MODIFY;

        else if (nId == SfxGroupId::Drawing)

            return STR_GID_DRAWING;

        else if (nId == SfxGroupId::Controls)

            return STR_GID_CONTROLS;

        return {};

    }

}

// registers the availability of the Interface of functions

void SfxSlotPool::RegisterInterface( SfxInterface& rInterface )

{

    // add to the list of SfxObjectInterface instances

    _vInterfaces.push_back(&rInterface);

    // Stop at a (single) Null-slot (for syntactic reasons the interfaces

    // always contain at least one slot)

    if ( rInterface.Count() != 0 && !rInterface.pSlots[0].nSlotId )

        return;

    // possibly add Interface-id and group-ids of funcs to the list of groups

    if ( _pParentPool )

    {

        // The Groups in parent Slotpool are also known here

        _vGroups.insert( _vGroups.end(), _pParentPool->_vGroups.begin(), _pParentPool->_vGroups.end() );

    }

    for ( size_t nFunc = 0; nFunc < rInterface.Count(); ++nFunc )

    {

        const SfxSlot &rDef = rInterface.pSlots[nFunc];

        if ( rDef.GetGroupId() != SfxGroupId::NONE &&

             std::find(_vGroups.begin(), _vGroups.end(), rDef.GetGroupId()) == _vGroups.end() )

        {

            if (rDef.GetGroupId() == SfxGroupId::Intern)

                _vGroups.insert(_vGroups.begin(), rDef.GetGroupId());

            else

                _vGroups.push_back(rDef.GetGroupId());

        }

    }

}

const std::type_info* SfxSlotPool::GetSlotType( sal_uInt16 nId ) const

{

    const SfxSlot* pSlot = GetSlot( nId );

    return pSlot ? pSlot->GetType()->Type() : nullptr;

}

// get the first SfxMessage for a special Id (e.g. for getting check-mode)

const SfxSlot* SfxSlotPool::GetSlot( sal_uInt16 nId ) const

{

    // First, search their own interfaces

    for (SfxInterface* _pInterface : _vInterfaces)

    {

        const SfxSlot *pDef = _pInterface->GetSlot(nId);

        if ( pDef )

            return pDef;

    }

    // Then try any of the possible existing parent

    return _pParentPool ? _pParentPool->GetSlot( nId ) : nullptr;

}

// skips to the next group

OUString SfxSlotPool::SeekGroup( sal_uInt16 nNo )

{

    // if the group exists, use it

    if (  nNo < _vGroups.size() )

    {

        _nCurGroup = nNo;

        if ( _pParentPool )

        {

            // In most cases, the order of the IDs agree

            sal_uInt16 nParentCount = _pParentPool->_vGroups.size();

            if ( nNo < nParentCount && _vGroups[nNo] == _pParentPool->_vGroups[nNo] )

                _pParentPool->_nCurGroup = nNo;

            else

            {

                // Otherwise search. If the group is not found in the parent

                // pool, _nCurGroup is set outside the valid range

                sal_uInt16 i;

                for ( i=1; i<nParentCount; i++ )

                    if ( _vGroups[nNo] == _pParentPool->_vGroups[i] )

                        break;

                _pParentPool->_nCurGroup = i;

            }

        }

        TranslateId pResId = getGidResId(_vGroups[_nCurGroup]);

        if (!pResId)

        {

            OSL_FAIL( "GroupId-Name not defined in SFX!" );

            return OUString();

        }

        return SfxResId(pResId);

    }

    return OUString();

}

sal_uInt16 SfxSlotPool::GetGroupCount() const

{

    return _vGroups.size();

}

// internal search loop

const SfxSlot* SfxSlotPool::SeekSlot( sal_uInt16 nStartInterface )

{

    // The numbering starts at the interfaces of the parent pool

    sal_uInt16 nFirstInterface = _pParentPool ? _pParentPool->_vInterfaces.size() : 0;

    // have reached the end of the Parent-Pools?

    if ( nStartInterface < nFirstInterface &&

         _pParentPool->_nCurGroup >= _pParentPool->_vGroups.size() )

        nStartInterface = nFirstInterface;

    // Is the Interface still in the Parent-Pool?

    if ( nStartInterface < nFirstInterface )

    {

        SAL_WARN_IF(!_pParentPool, "sfx.control", "No parent pool!");

        _nCurInterface = nStartInterface;

        return _pParentPool->SeekSlot( nStartInterface );

    }

    // find the first func-def with the current group id

    sal_uInt16 nCount = _vInterfaces.size() + nFirstInterface;

    for ( _nCurInterface = nStartInterface;

            _nCurInterface < nCount;

          ++_nCurInterface )

    {

        SfxInterface* pInterface = _vInterfaces[_nCurInterface-nFirstInterface];

        for ( _nCurMsg = 0;

              _nCurMsg < pInterface->Count();

              ++_nCurMsg )

        {

            const SfxSlot& rMsg = pInterface->pSlots[_nCurMsg];

            if (rMsg.GetGroupId() == _vGroups.at(_nCurGroup))

                return &rMsg;

        }

    }

    return nullptr;

}

// skips to the next func in the current group

const SfxSlot* SfxSlotPool::NextSlot()

{

    // The numbering starts at the interfaces of the parent pool

    sal_uInt16 nFirstInterface = _pParentPool ? _pParentPool->_vInterfaces.size() : 0;

    if ( _nCurInterface < nFirstInterface && _nCurGroup >= _pParentPool->_vGroups.size() )

        _nCurInterface = nFirstInterface;

    if ( _nCurInterface < nFirstInterface )

    {

        SAL_WARN_IF(!_pParentPool, "sfx.control", "No parent pool!");

        const SfxSlot *pSlot = _pParentPool->NextSlot();

        _nCurInterface = _pParentPool->_nCurInterface;

        if ( pSlot )

            return pSlot;

        if ( _nCurInterface == nFirstInterface )

            // parent pool is ready

            return SeekSlot( nFirstInterface );

    }

    sal_uInt16 nInterface = _nCurInterface - nFirstInterface;

    // possibly we are already at the end

    if ( nInterface >= _vInterfaces.size() )

        return nullptr;

    // look for further matching func-defs within the same Interface

    SfxInterface* pInterface = _vInterfaces[nInterface];

    while ( ++_nCurMsg < pInterface->Count() )

    {

        const SfxSlot& rMsg = pInterface->pSlots[_nCurMsg];

        if (rMsg.GetGroupId() == _vGroups.at(_nCurGroup))

            return &rMsg;

    }

    return SeekSlot(++_nCurInterface );

}

// Query SlotName with help text

const SfxSlot* SfxSlotPool::GetUnoSlot( const OUString& rName ) const

{

    const SfxSlot *pSlot = nullptr;

    for (auto const & nInterface: _vInterfaces)

    {

        pSlot = nInterface->GetSlot( rName );

        if ( pSlot )

            break;

    }

    if ( !pSlot && _pParentPool )

        pSlot = _pParentPool->GetUnoSlot( rName );

    return pSlot;

}

SfxSlotPool& SfxSlotPool::GetSlotPool( SfxViewFrame *pFrame )

{

    SfxModule *pMod = SfxModule::GetActiveModule( pFrame );

    if ( pMod && pMod->GetSlotPool() )

        return *pMod->GetSlotPool();

    else

        return *SfxGetpApp()->Get_Impl()->pSlotPool;

}

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