547 lines
18 KiB
C++
547 lines
18 KiB
C++
/* -*- 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/popupwindowcontroller.hxx>
|
|
#include <svtools/toolbarmenu.hxx>
|
|
#include <toolkit/helper/vclunohelper.hxx>
|
|
#include <tools/gen.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <vcl/toolbox.hxx>
|
|
#include <vcl/commandinfoprovider.hxx>
|
|
#include <vcl/weldutils.hxx>
|
|
|
|
#include <com/sun/star/awt/XDockableWindow.hpp>
|
|
#include <com/sun/star/frame/XLayoutManager.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>
|
|
#include <com/sun/star/container/NoSuchElementException.hpp>
|
|
|
|
typedef cppu::ImplInheritanceHelper< svt::PopupWindowController,
|
|
css::frame::XSubToolbarController,
|
|
css::awt::XDockableWindowListener> ToolBarBase;
|
|
|
|
namespace {
|
|
|
|
class SubToolBarController : public ToolBarBase
|
|
{
|
|
OUString m_aSubTbName;
|
|
OUString m_aLastCommand;
|
|
css::uno::Reference< css::ui::XUIElement > m_xUIElement;
|
|
void disposeUIElement();
|
|
public:
|
|
explicit SubToolBarController( const rtl::Reference< css::uno::XComponentContext >& rxContext,
|
|
const css::uno::Sequence< css::uno::Any >& rxArgs );
|
|
virtual ~SubToolBarController() override;
|
|
|
|
void PopoverDestroyed();
|
|
|
|
// 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;
|
|
|
|
// PopupWindowController
|
|
virtual VclPtr<vcl::Window> createVclPopupWindow(vcl::Window* pParent) override;
|
|
virtual std::unique_ptr<WeldToolbarPopup> weldPopupWindow() 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 rtl::Reference< css::uno::XComponentContext >& rxContext,
|
|
const css::uno::Sequence< css::uno::Any >& rxArgs
|
|
) : ToolBarBase(
|
|
rxContext,
|
|
rtl::Reference< css::frame::XFrame >(),
|
|
""
|
|
)
|
|
{
|
|
for ( css::uno::Any const & arg : rxArgs )
|
|
{
|
|
css::beans::PropertyValue aPropValue;
|
|
arg >>= aPropValue;
|
|
if ( aPropValue.Name == "Value" )
|
|
{
|
|
sal_Int32 nIdx{ 0 };
|
|
OUString aValue;
|
|
aPropValue.Value >>= aValue;
|
|
m_aSubTbName = aValue.getToken(0, ';', nIdx);
|
|
m_aCommandURL = m_aSubTbName;
|
|
m_aLastCommand = aValue.getToken(0, ';', nIdx);
|
|
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;
|
|
ToolBoxItemId nId;
|
|
if ( !getToolboxId( nId, &pToolBox ) )
|
|
return;
|
|
|
|
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 == Concat2View( 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::Any( nKeyModifier ) }
|
|
} ) );
|
|
dispatchCommand( m_aLastCommand, aArgs );
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
class SubToolbarControl final : public WeldToolbarPopup
|
|
{
|
|
public:
|
|
explicit SubToolbarControl(SubToolBarController& rController, weld::Widget* pParent);
|
|
virtual ~SubToolbarControl() override;
|
|
|
|
virtual void GrabFocus() override;
|
|
|
|
weld::Container* GetContainer() { return m_xTargetContainer.get(); }
|
|
|
|
private:
|
|
SubToolBarController& m_rController;
|
|
std::unique_ptr<weld::Container> m_xTargetContainer;
|
|
};
|
|
}
|
|
|
|
SubToolbarControl::SubToolbarControl(SubToolBarController& rController,
|
|
weld::Widget* pParent)
|
|
: WeldToolbarPopup(rController.getFrameInterface(), pParent, u"svt/ui/subtoolbar.ui"_ustr, u"subtoolbar"_ustr)
|
|
, m_rController(rController)
|
|
, m_xTargetContainer(m_xBuilder->weld_container(u"container"_ustr))
|
|
{
|
|
}
|
|
|
|
void SubToolbarControl::GrabFocus()
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
SubToolbarControl::~SubToolbarControl()
|
|
{
|
|
m_rController.PopoverDestroyed();
|
|
}
|
|
|
|
std::unique_ptr<WeldToolbarPopup> SubToolBarController::weldPopupWindow()
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
auto pPopup = std::make_unique<SubToolbarControl>(*this, m_pToolbar);
|
|
|
|
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::XUIElementFactoryManager > xUIElementFactory = xWeakUIElementFactory;
|
|
if ( !xUIElementFactory.is() )
|
|
{
|
|
xUIElementFactory = css::ui::theUIElementFactoryManager::get( m_xContext );
|
|
xWeakUIElementFactory = xUIElementFactory;
|
|
}
|
|
|
|
css::uno::Reference< css::awt::XWindow > xParent = new weld::TransportAsXWindow(pPopup->GetContainer());
|
|
|
|
auto aPropSeq( comphelper::InitPropertySequence( {
|
|
{ "Frame", css::uno::Any( xFrame ) },
|
|
{ "ParentWindow", css::uno::Any( xParent ) },
|
|
{ "Persistent", css::uno::Any( false ) },
|
|
{ "PopupMode", css::uno::Any( true ) }
|
|
} ) );
|
|
|
|
try
|
|
{
|
|
m_xUIElement = xUIElementFactory->createUIElement( "private:resource/toolbar/" + m_aSubTbName, aPropSeq );
|
|
}
|
|
catch ( css::container::NoSuchElementException& )
|
|
{}
|
|
catch ( css::lang::IllegalArgumentException& )
|
|
{}
|
|
|
|
return pPopup;
|
|
}
|
|
|
|
VclPtr<vcl::Window> SubToolBarController::createVclPopupWindow(vcl::Window* /*pParent*/)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
ToolBox* pToolBox = nullptr;
|
|
ToolBoxItemId nId;
|
|
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 = xWeakUIElementFactory;
|
|
if ( !xUIElementFactory.is() )
|
|
{
|
|
xUIElementFactory = css::ui::theUIElementFactoryManager::get( m_xContext );
|
|
xWeakUIElementFactory = xUIElementFactory;
|
|
}
|
|
|
|
auto aPropSeq( comphelper::InitPropertySequence( {
|
|
{ "Frame", css::uno::Any( xFrame ) },
|
|
{ "ParentWindow", css::uno::Any( m_xParentWindow ) },
|
|
{ "Persistent", css::uno::Any( false ) },
|
|
{ "PopupMode", css::uno::Any( 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 >(this) );
|
|
xDockWindow->enableDocking( true );
|
|
|
|
// keep reference to UIElement to avoid its destruction
|
|
disposeUIElement();
|
|
m_xUIElement = std::move(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 nullptr;
|
|
}
|
|
|
|
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;
|
|
ToolBoxItemId nId;
|
|
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(u"ResourceURL"_ustr) >>= 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 )
|
|
return;
|
|
|
|
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() )
|
|
return;
|
|
|
|
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()) )
|
|
return;
|
|
|
|
try
|
|
{
|
|
VclPtr<vcl::Window> pTbxWindow = VCLUnoHelper::GetWindow( xSubToolBar );
|
|
if ( pTbxWindow && pTbxWindow->GetType() == WindowType::TOOLBOX )
|
|
{
|
|
OUString aPersistentString( u"Persistent"_ustr );
|
|
css::uno::Any a = xProp->getPropertyValue( aPersistentString );
|
|
xProp->setPropertyValue( aPersistentString, css::uno::Any( false ) );
|
|
|
|
xLayoutManager->hideElement( aSubToolBarResName );
|
|
xLayoutManager->floatWindow( aSubToolBarResName );
|
|
|
|
xLayoutManager->setElementPos( aSubToolBarResName, e.FloatingPosition );
|
|
xLayoutManager->showElement( aSubToolBarResName );
|
|
|
|
xProp->setPropertyValue(u"Persistent"_ustr, 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::PopupWindowController::initialize( rxArgs );
|
|
|
|
ToolBox* pToolBox = nullptr;
|
|
ToolBoxItemId nId;
|
|
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 );
|
|
}
|
|
|
|
if (m_pToolbar)
|
|
{
|
|
mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar));
|
|
m_pToolbar->set_item_popover(m_aCommandURL, mxPopoverContainer->getTopLevel());
|
|
}
|
|
|
|
updateImage();
|
|
}
|
|
|
|
void SubToolBarController::PopoverDestroyed()
|
|
{
|
|
disposeUIElement();
|
|
m_xUIElement = nullptr;
|
|
}
|
|
|
|
void SubToolBarController::dispose()
|
|
{
|
|
if ( m_bDisposed )
|
|
return;
|
|
|
|
svt::PopupWindowController::dispose();
|
|
disposeUIElement();
|
|
m_xUIElement = nullptr;
|
|
}
|
|
|
|
OUString SubToolBarController::getImplementationName()
|
|
{
|
|
return u"com.sun.star.comp.framework.SubToolBarController"_ustr;
|
|
}
|
|
|
|
sal_Bool SubToolBarController::supportsService( const OUString& rServiceName )
|
|
{
|
|
return cppu::supportsService( this, rServiceName );
|
|
}
|
|
|
|
css::uno::Sequence< OUString > SubToolBarController::getSupportedServiceNames()
|
|
{
|
|
return {u"com.sun.star.frame.ToolbarController"_ustr};
|
|
}
|
|
|
|
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
|
|
com_sun_star_comp_framework_SubToolBarController_get_implementation(
|
|
css::uno::XComponentContext* rxContext,
|
|
css::uno::Sequence<css::uno::Any> const & rxArgs )
|
|
{
|
|
return cppu::acquire( new SubToolBarController( rxContext, rxArgs ) );
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|