    /* -*- 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 <comphelper/propertysequence.hxx>
    #include <cppuhelper/implbase.hxx>
    #include <cppuhelper/supportsservice.hxx>
    #include <cppuhelper/weakref.hxx>
    #include <svtools/toolboxcontroller.hxx>
    #include <toolkit/helper/vclunohelper.hxx>
    #include <tools/gen.hxx>
    #include <vcl/svapp.hxx>
    #include <vcl/toolbox.hxx>
    #include <vcl/commandinfoprovider.hxx>

    #include <com/sun/star/awt/XDockableWindow.hpp>
    #include <com/sun/star/frame/XSubToolbarController.hpp>
    #include <com/sun/star/frame/status/Visibility.hpp>
    #include <com/sun/star/lang/XServiceInfo.hpp>
    #include <com/sun/star/ui/theUIElementFactoryManager.hpp>

    typedef cppu::ImplInheritanceHelper< svt::ToolboxController,
                                         css::frame::XSubToolbarController,
                                         css::awt::XDockableWindowListener,
                                         css::lang::XServiceInfo > ToolBarBase;

    class SubToolBarController : public ToolBarBase
    {
        OUString m_aSubTbName;
        OUString m_aLastCommand;
        css::uno::Reference< css::ui::XUIElement > m_xUIElement;
        void disposeUIElement();
    public:
        explicit SubToolBarController( const css::uno::Sequence< css::uno::Any >& rxArgs );
        virtual ~SubToolBarController() override;

        // XInitialization
        virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& rxArgs ) override;

        // XStatusListener
        virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& Event ) override;

        // XToolbarController
        virtual void SAL_CALL execute( sal_Int16 nKeyModifier ) override;
        virtual css::uno::Reference< css::awt::XWindow > SAL_CALL createPopupWindow() override;

        // XSubToolbarController
        virtual sal_Bool SAL_CALL opensSubToolbar() override;
        virtual OUString SAL_CALL getSubToolbarName() override;
        virtual void SAL_CALL functionSelected( const OUString& rCommand ) override;
        virtual void SAL_CALL updateImage() override;

        //  XDockableWindowListener
        virtual void SAL_CALL startDocking( const css::awt::DockingEvent& e ) override;
        virtual css::awt::DockingData SAL_CALL docking( const css::awt::DockingEvent& e ) override;
        virtual void SAL_CALL endDocking( const css::awt::EndDockingEvent& e ) override;
        virtual sal_Bool SAL_CALL prepareToggleFloatingMode( const css::lang::EventObject& e ) override;
        virtual void SAL_CALL toggleFloatingMode( const css::lang::EventObject& e ) override;
        virtual void SAL_CALL closed( const css::lang::EventObject& e ) override;
        virtual void SAL_CALL endPopupMode( const css::awt::EndPopupModeEvent& e ) override;

        // XEventListener
        virtual void SAL_CALL disposing( const css::lang::EventObject& e ) override;

        // XComponent
        virtual void SAL_CALL dispose() override;

        // XServiceInfo
        virtual OUString SAL_CALL getImplementationName() override;
        virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) override;
        virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
    };

    SubToolBarController::SubToolBarController( const css::uno::Sequence< css::uno::Any >& rxArgs )
    {
        css::beans::PropertyValue aPropValue;
        for ( sal_Int32 i = 0; i < rxArgs.getLength(); ++i )
        {
            rxArgs[i] >>= aPropValue;
            if ( aPropValue.Name == "Value" )
            {
                OUString aValue;
                aPropValue.Value >>= aValue;
                m_aSubTbName = aValue.getToken(0, ';');
                m_aLastCommand = aValue.getToken(1, ';');
                break;
            }
        }
        if ( !m_aLastCommand.isEmpty() )
            addStatusListener( m_aLastCommand );
    }

    SubToolBarController::~SubToolBarController()
    {
        disposeUIElement();
        m_xUIElement = nullptr;
    }

    void SubToolBarController::disposeUIElement()
    {
        if ( m_xUIElement.is() )
        {
            css::uno::Reference< css::lang::XComponent > xComponent( m_xUIElement, css::uno::UNO_QUERY );
            xComponent->dispose();
        }
    }

    void SubToolBarController::statusChanged( const css::frame::FeatureStateEvent& Event )
    {
        SolarMutexGuard aSolarMutexGuard;

        if ( m_bDisposed )
            return;

        ToolBox* pToolBox = nullptr;
        sal_uInt16 nId = 0;
        if ( getToolboxId( nId, &pToolBox ) )
        {
            ToolBoxItemBits nItemBits = pToolBox->GetItemBits( nId );
            nItemBits &= ~ToolBoxItemBits::CHECKABLE;
            TriState eTri = TRISTATE_FALSE;

            if ( Event.FeatureURL.Complete == m_aCommandURL )
            {
                pToolBox->EnableItem( nId, Event.IsEnabled );

                OUString aStrValue;
                css::frame::status::Visibility aItemVisibility;
                if ( Event.State >>= aStrValue )
                {
                    // Enum command, such as the current custom shape,
                    // toggle checked state.
                    if ( m_aLastCommand == ( m_aCommandURL + "." + aStrValue ) )
                    {
                        eTri = TRISTATE_TRUE;
                        nItemBits |= ToolBoxItemBits::CHECKABLE;
                    }
                }
                else if ( Event.State >>= aItemVisibility )
                {
                    pToolBox->ShowItem( nId, aItemVisibility.bVisible );
                }
            }
            else
            {
                bool bValue;
                if ( Event.State >>= bValue )
                {
                    // Boolean, treat it as checked/unchecked
                    if ( bValue )
                        eTri = TRISTATE_TRUE;
                    nItemBits |= ToolBoxItemBits::CHECKABLE;
                }
            }

            pToolBox->SetItemState( nId, eTri );
            pToolBox->SetItemBits( nId, nItemBits );
        }
    }

    void SubToolBarController::execute( sal_Int16 nKeyModifier )
    {
        if ( !m_aLastCommand.isEmpty() )
        {
            auto aArgs( comphelper::InitPropertySequence( {
                { "KeyModifier", css::uno::makeAny( nKeyModifier ) }
            } ) );
            dispatchCommand( m_aLastCommand, aArgs );
        }
    }

    css::uno::Reference< css::awt::XWindow > SubToolBarController::createPopupWindow()
    {
        SolarMutexGuard aGuard;

        ToolBox* pToolBox = nullptr;
        sal_uInt16 nId = 0;
        if ( getToolboxId( nId, &pToolBox ) )
        {
            css::uno::Reference< css::frame::XFrame > xFrame ( getFrameInterface() );

            // create element with factory
            static css::uno::WeakReference< css::ui::XUIElementFactoryManager > xWeakUIElementFactory;
            css::uno::Reference< css::ui::XUIElement > xUIElement;
            css::uno::Reference< css::ui::XUIElementFactoryManager > xUIElementFactory;

            xUIElementFactory = xWeakUIElementFactory;
            if ( !xUIElementFactory.is() )
            {
                xUIElementFactory = css::ui::theUIElementFactoryManager::get( m_xContext );
                xWeakUIElementFactory = xUIElementFactory;
            }

            auto aPropSeq( comphelper::InitPropertySequence( {
                { "Frame", css::uno::makeAny( xFrame ) },
                { "ParentWindow", css::uno::makeAny( m_xParentWindow ) },
                { "Persistent", css::uno::makeAny( false ) },
                { "PopupMode", css::uno::makeAny( true ) }
            } ) );

            try
            {
                xUIElement = xUIElementFactory->createUIElement( "private:resource/toolbar/" + m_aSubTbName, aPropSeq );
            }
            catch ( css::container::NoSuchElementException& )
            {}
            catch ( css::lang::IllegalArgumentException& )
            {}

            if ( xUIElement.is() )
            {
                css::uno::Reference< css::awt::XWindow > xSubToolBar( xUIElement->getRealInterface(), css::uno::UNO_QUERY );
                if ( xSubToolBar.is() )
                {
                    css::uno::Reference< css::awt::XDockableWindow > xDockWindow( xSubToolBar, css::uno::UNO_QUERY );
                    xDockWindow->addDockableWindowListener( css::uno::Reference< css::awt::XDockableWindowListener >(
                                                            static_cast< OWeakObject * >( this ), css::uno::UNO_QUERY ) );
                    xDockWindow->enableDocking( true );

                    // keep reference to UIElement to avoid its destruction
                    disposeUIElement();
                    m_xUIElement = xUIElement;

                    VclPtr<vcl::Window> pTbxWindow = VCLUnoHelper::GetWindow( xSubToolBar );
                    if ( pTbxWindow && pTbxWindow->GetType() == WindowType::TOOLBOX )
                    {
                        ToolBox* pToolBar = static_cast< ToolBox* >( pTbxWindow.get() );
                        // calc and set size for popup mode
                        Size aSize = pToolBar->CalcPopupWindowSizePixel();
                        pToolBar->SetSizePixel( aSize );
                        // open subtoolbox in popup mode
                        vcl::Window::GetDockingManager()->StartPopupMode( pToolBox, pToolBar );
                    }
                }
            }
        }
        return css::uno::Reference< css::awt::XWindow >();
    }

    sal_Bool SubToolBarController::opensSubToolbar()
    {
        return !m_aLastCommand.isEmpty();
    }

    OUString SubToolBarController::getSubToolbarName()
    {
        return m_aSubTbName;
    }

    void SubToolBarController::functionSelected( const OUString& rCommand )
    {
        if ( !m_aLastCommand.isEmpty() && m_aLastCommand != rCommand )
        {
            removeStatusListener( m_aLastCommand );
            m_aLastCommand = rCommand;
            addStatusListener( m_aLastCommand );
            updateImage();
        }
    }

    void SubToolBarController::updateImage()
    {
        SolarMutexGuard aGuard;
        if ( !m_aLastCommand.isEmpty() )
        {
            ToolBox* pToolBox = nullptr;
            sal_uInt16 nId = 0;
            if ( getToolboxId( nId, &pToolBox ) )
            {
                vcl::ImageType eImageType = pToolBox->GetImageSize();
                Image aImage = vcl::CommandInfoProvider::GetImageForCommand(m_aLastCommand, getFrameInterface(), eImageType);
                if ( !!aImage )
                    pToolBox->SetItemImage( nId, aImage );
            }
        }
    }

    void SubToolBarController::startDocking( const css::awt::DockingEvent& )
    {
    }

    css::awt::DockingData SubToolBarController::docking( const css::awt::DockingEvent& )
    {
        return css::awt::DockingData();
    }

    void SubToolBarController::endDocking( const css::awt::EndDockingEvent& )
    {
    }

    sal_Bool SubToolBarController::prepareToggleFloatingMode( const css::lang::EventObject& )
    {
        return false;
    }

    void SubToolBarController::toggleFloatingMode( const css::lang::EventObject& )
    {
    }

    void SubToolBarController::closed( const css::lang::EventObject& )
    {
    }

    void SubToolBarController::endPopupMode( const css::awt::EndPopupModeEvent& e )
    {
        SolarMutexGuard aGuard;

        OUString aSubToolBarResName;
        if ( m_xUIElement.is() )
        {
            css::uno::Reference< css::beans::XPropertySet > xPropSet( m_xUIElement, css::uno::UNO_QUERY );
            if ( xPropSet.is() )
            {
                try
                {
                    xPropSet->getPropertyValue("ResourceURL") >>= aSubToolBarResName;
                }
                catch ( css::beans::UnknownPropertyException& )
                {}
                catch ( css::lang::WrappedTargetException& )
                {}
            }
            disposeUIElement();
        }
        m_xUIElement = nullptr;

        // if the toolbar was teared-off recreate it and place it at the given position
        if( e.bTearoff )
        {
            css::uno::Reference< css::ui::XUIElement > xUIElement;
            css::uno::Reference< css::frame::XLayoutManager > xLayoutManager = getLayoutManager();

            if ( !xLayoutManager.is() )
                return;

            xLayoutManager->createElement( aSubToolBarResName );
            xUIElement = xLayoutManager->getElement( aSubToolBarResName );
            if ( xUIElement.is() )
            {
                css::uno::Reference< css::awt::XWindow > xSubToolBar( xUIElement->getRealInterface(), css::uno::UNO_QUERY );
                css::uno::Reference< css::beans::XPropertySet > xProp( xUIElement, css::uno::UNO_QUERY );
                if ( xSubToolBar.is() && xProp.is() )
                {
                    OUString aPersistentString( "Persistent" );
                    try
                    {
                        VclPtr<vcl::Window> pTbxWindow = VCLUnoHelper::GetWindow( xSubToolBar );
                        if ( pTbxWindow && pTbxWindow->GetType() == WindowType::TOOLBOX )
                        {
                            css::uno::Any a = xProp->getPropertyValue( aPersistentString );
                            xProp->setPropertyValue( aPersistentString, css::uno::makeAny( false ) );

                            xLayoutManager->hideElement( aSubToolBarResName );
                            xLayoutManager->floatWindow( aSubToolBarResName );

                            xLayoutManager->setElementPos( aSubToolBarResName, e.FloatingPosition );
                            xLayoutManager->showElement( aSubToolBarResName );

                            xProp->setPropertyValue("Persistent", a );
                        }
                    }
                    catch ( css::uno::RuntimeException& )
                    {
                        throw;
                    }
                    catch ( css::uno::Exception& )
                    {}
                }
            }
        }
    }

    void SubToolBarController::disposing( const css::lang::EventObject& e )
    {
        svt::ToolboxController::disposing( e );
    }

    void SubToolBarController::initialize( const css::uno::Sequence< css::uno::Any >& rxArgs )
    {
        svt::ToolboxController::initialize( rxArgs );

        ToolBox* pToolBox = nullptr;
        sal_uInt16 nId = 0;
        if ( getToolboxId( nId, &pToolBox ) )
        {
            if ( m_aLastCommand.isEmpty() )
                pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
            else
                pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWN );
        }
        updateImage();
    }

    void SubToolBarController::dispose()
    {
        if ( m_bDisposed )
            return;

        svt::ToolboxController::dispose();
        disposeUIElement();
        m_xUIElement = nullptr;
    }

    OUString SubToolBarController::getImplementationName()
    {
        return OUString( "com.sun.star.comp.framework.SubToolBarController" );
    }

    sal_Bool SubToolBarController::supportsService( const OUString& rServiceName )
    {
        return cppu::supportsService( this, rServiceName );
    }

    css::uno::Sequence< OUString > SubToolBarController::getSupportedServiceNames()
    {
        return {"com.sun.star.frame.ToolbarController"};
    }

    extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
    com_sun_star_comp_framework_SubToolBarController_get_implementation(
        css::uno::XComponentContext*,
        css::uno::Sequence<css::uno::Any> const & rxArgs )
    {
        return cppu::acquire( new SubToolBarController( rxArgs ) );
    }

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

↑ V614 Uninitialized variable 'bValue' used.