diff options
Diffstat (limited to '')
41 files changed, 10114 insertions, 0 deletions
diff --git a/sfx2/source/sidebar/Accessible.cxx b/sfx2/source/sidebar/Accessible.cxx new file mode 100644 index 000000000..8eb264f39 --- /dev/null +++ b/sfx2/source/sidebar/Accessible.cxx @@ -0,0 +1,52 @@ +/* -*- 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 <sidebar/Accessible.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Accessible::Accessible ( + const Reference<accessibility::XAccessibleContext>& rxContext) + : AccessibleInterfaceBase(m_aMutex), + mxContext(rxContext) +{ +} + +Accessible::~Accessible() +{ +} + +void SAL_CALL Accessible::disposing() +{ + Reference<XComponent> xComponent (mxContext, UNO_QUERY); + if (xComponent.is()) + xComponent->dispose(); +} + +Reference<accessibility::XAccessibleContext> SAL_CALL Accessible::getAccessibleContext() +{ + return mxContext; +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/AccessibleTitleBar.cxx b/sfx2/source/sidebar/AccessibleTitleBar.cxx new file mode 100644 index 000000000..c92fbf59e --- /dev/null +++ b/sfx2/source/sidebar/AccessibleTitleBar.cxx @@ -0,0 +1,60 @@ +/* -*- 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 <sidebar/AccessibleTitleBar.hxx> +#include <sidebar/Accessible.hxx> +#include <sidebar/TitleBar.hxx> + +#include <com/sun/star/accessibility/AccessibleStateType.hpp> + +#include <unotools/accessiblestatesethelper.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Reference<accessibility::XAccessible> AccessibleTitleBar::Create (TitleBar& rTitleBar) +{ + rTitleBar.GetComponentInterface(); + VCLXWindow* pWindow = rTitleBar.GetWindowPeer(); + if (pWindow != nullptr) + return new Accessible(new AccessibleTitleBar(pWindow)); + else + return nullptr; +} + +AccessibleTitleBar::AccessibleTitleBar (VCLXWindow* pWindow) + : VCLXAccessibleComponent(pWindow) +{ +} + +AccessibleTitleBar::~AccessibleTitleBar() +{ +} + +void AccessibleTitleBar::FillAccessibleStateSet (utl::AccessibleStateSetHelper& rStateSet) +{ + VCLXAccessibleComponent::FillAccessibleStateSet(rStateSet); + rStateSet.AddState(accessibility::AccessibleStateType::FOCUSABLE); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/AsynchronousCall.cxx b/sfx2/source/sidebar/AsynchronousCall.cxx new file mode 100644 index 000000000..5a3ce8db2 --- /dev/null +++ b/sfx2/source/sidebar/AsynchronousCall.cxx @@ -0,0 +1,71 @@ +/* -*- 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 <sfx2/sidebar/AsynchronousCall.hxx> +#include <vcl/svapp.hxx> + +namespace sfx2::sidebar { + +AsynchronousCall::AsynchronousCall (const Action& rAction) + : maAction(rAction), + mnCallId(nullptr) +{ +} + +AsynchronousCall::~AsynchronousCall() +{ + CancelRequest(); +} + +void AsynchronousCall::RequestCall() +{ + if (mnCallId == nullptr) + { + Link<void*,void> aLink (LINK(this, AsynchronousCall, HandleUserCall)); + mnCallId = Application::PostUserEvent(aLink); + } +} + +void AsynchronousCall::CancelRequest() +{ + if (mnCallId != nullptr) + { + Application::RemoveUserEvent(mnCallId); + mnCallId = nullptr; + } +} + +void AsynchronousCall::Sync() +{ + if (mnCallId != nullptr) { + maAction(); + CancelRequest(); + } +} + +IMPL_LINK_NOARG(AsynchronousCall, HandleUserCall, void*, void ) +{ + mnCallId = nullptr; + if (maAction) + maAction(); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/Context.cxx b/sfx2/source/sidebar/Context.cxx new file mode 100644 index 000000000..b2bfd68a3 --- /dev/null +++ b/sfx2/source/sidebar/Context.cxx @@ -0,0 +1,85 @@ +/* -*- 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 <sfx2/sidebar/Context.hxx> + + +#define AnyApplicationName "any" +#define AnyContextName "any" + +namespace sfx2::sidebar { + +const sal_Int32 Context::NoMatch = 4; +const sal_Int32 Context::ApplicationWildcardMatch = 1; +const sal_Int32 Context::ContextWildcardMatch = 2; +const sal_Int32 Context::OptimalMatch = 0; // Neither application nor context name is "any". + +Context::Context() + : msApplication(AnyApplicationName), + msContext(AnyContextName) +{ +} + +Context::Context ( + const OUString& rsApplication, + const OUString& rsContext) + : msApplication(rsApplication), + msContext(rsContext) +{ +} + +sal_Int32 Context::EvaluateMatch ( + const Context& rOther) const +{ + bool bApplicationNameIsAny (rOther.msApplication == AnyApplicationName); + + // special case for charts which use a whole own set of decks + if (msApplication == "com.sun.star.chart2.ChartDocument") + { + bApplicationNameIsAny = false; + } + + if (rOther.msApplication == msApplication || bApplicationNameIsAny) + { + // Application name matches. + const bool bContextNameIsAny (rOther.msContext == AnyContextName); + if (rOther.msContext == msContext || bContextNameIsAny) + { + // Context name matches. + return (bApplicationNameIsAny ? ApplicationWildcardMatch : 0) + + (bContextNameIsAny ? ContextWildcardMatch : 0); + } + } + return NoMatch; +} + +bool Context::operator== (const Context& rOther) const +{ + return msApplication == rOther.msApplication + && msContext == rOther.msContext; +} + +bool Context::operator!= (const Context& rOther) const +{ + return ( msApplication != rOther.msApplication) + || ( msContext != rOther.msContext); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/ContextChangeBroadcaster.cxx b/sfx2/source/sidebar/ContextChangeBroadcaster.cxx new file mode 100644 index 000000000..8e213e68b --- /dev/null +++ b/sfx2/source/sidebar/ContextChangeBroadcaster.cxx @@ -0,0 +1,130 @@ +/* -*- 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 <sidebar/ContextChangeBroadcaster.hxx> +#include <vcl/EnumContext.hxx> +#include <com/sun/star/ui/ContextChangeEventObject.hpp> +#include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp> +#include <com/sun/star/frame/ModuleManager.hpp> +#include <osl/diagnose.h> +#include <comphelper/lok.hxx> +#include <comphelper/processfactory.hxx> +#include <sfx2/lokhelper.hxx> +#include <sfx2/viewsh.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +ContextChangeBroadcaster::ContextChangeBroadcaster() + : msContextName(), + mbIsBroadcasterEnabled(true) +{ +} + +ContextChangeBroadcaster::~ContextChangeBroadcaster() +{ +} + +void ContextChangeBroadcaster::Initialize (const OUString& rsContextName) +{ + msContextName = rsContextName; +} + +void ContextChangeBroadcaster::Activate (const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + if (msContextName.getLength() > 0) + BroadcastContextChange(rxFrame, GetModuleName(rxFrame), msContextName); +} + +void ContextChangeBroadcaster::Deactivate (const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + if (msContextName.getLength() > 0) + { + BroadcastContextChange( + rxFrame, + GetModuleName(rxFrame), + vcl::EnumContext::GetContextName(vcl::EnumContext::Context::Default)); + } +} + +bool ContextChangeBroadcaster::SetBroadcasterEnabled (const bool bIsEnabled) +{ + const bool bWasEnabled (mbIsBroadcasterEnabled); + mbIsBroadcasterEnabled = bIsEnabled; + return bWasEnabled; +} + +void ContextChangeBroadcaster::BroadcastContextChange ( + const css::uno::Reference<css::frame::XFrame>& rxFrame, + const OUString& rsModuleName, + const OUString& rsContextName) +{ + if ( ! mbIsBroadcasterEnabled) + return; + + if (rsContextName.getLength() == 0) + return; + + if ( ! rxFrame.is() || ! rxFrame->getController().is()) + { + // Frame is (probably) being deleted. Broadcasting context + // changes is not necessary anymore. + return; + } + + // notify the LOK too + if (comphelper::LibreOfficeKit::isActive()) + { + if (SfxViewShell* pViewShell = SfxViewShell::Get(rxFrame->getController())) + SfxLokHelper::notifyContextChange(pViewShell, rsModuleName, rsContextName); + } + + const css::ui::ContextChangeEventObject aEvent( + rxFrame->getController(), + rsModuleName, + rsContextName); + + css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer ( + css::ui::ContextChangeEventMultiplexer::get( + ::comphelper::getProcessComponentContext())); + if (xMultiplexer.is()) + xMultiplexer->broadcastContextChangeEvent(aEvent, rxFrame->getController()); +} + +OUString ContextChangeBroadcaster::GetModuleName (const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + if ( ! rxFrame.is() || ! rxFrame->getController().is()) + return OUString(); + try + { + const Reference<XComponentContext> xContext (::comphelper::getProcessComponentContext() ); + const Reference<frame::XModuleManager> xModuleManager = frame::ModuleManager::create( xContext ); + return xModuleManager->identify(rxFrame); + } + catch (const Exception&) + { + OSL_ENSURE(false, "can not determine module name"); + } + return OUString(); +} + +} // end of namespace ::sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/ContextList.cxx b/sfx2/source/sidebar/ContextList.cxx new file mode 100644 index 000000000..36e9872d3 --- /dev/null +++ b/sfx2/source/sidebar/ContextList.cxx @@ -0,0 +1,104 @@ +/* -*- 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 <sidebar/ContextList.hxx> +#include <sfx2/sidebar/Context.hxx> + +namespace sfx2::sidebar { + +ContextList::ContextList() + : maEntries() +{ +} + +const ContextList::Entry* ContextList::GetMatch (const Context& rContext) const +{ + const ::std::vector<Entry>::const_iterator iEntry = FindBestMatch(rContext); + if (iEntry != maEntries.end()) + return &*iEntry; + else + return nullptr; +} + +ContextList::Entry* ContextList::GetMatch (const Context& rContext) +{ + const ::std::vector<Entry>::const_iterator iEntry = FindBestMatch(rContext); + if (iEntry != maEntries.end()) + return const_cast<Entry*>(&*iEntry); + else + return nullptr; +} + +::std::vector<ContextList::Entry>::const_iterator ContextList::FindBestMatch (const Context& rContext) const +{ + sal_Int32 nBestMatch (Context::NoMatch); + ::std::vector<Entry>::const_iterator iBestMatch (maEntries.end()); + + for (::std::vector<Entry>::const_iterator + iEntry(maEntries.begin()), + iEnd(maEntries.end()); + iEntry!=iEnd; + ++iEntry) + { + const sal_Int32 nMatch (rContext.EvaluateMatch(iEntry->maContext)); + if (nMatch < nBestMatch) + { + nBestMatch = nMatch; + iBestMatch = iEntry; + } + if (nBestMatch == Context::OptimalMatch) + return iEntry; + } + + return iBestMatch; +} + +void ContextList::AddContextDescription ( + const Context& rContext, + const bool bIsInitiallyVisible, + const OUString& rsMenuCommand) +{ + maEntries.emplace_back(); + maEntries.back().maContext = rContext; + maEntries.back().mbIsInitiallyVisible = bIsInitiallyVisible; + maEntries.back().msMenuCommand = rsMenuCommand; +} + +void ContextList::ToggleVisibilityForContext( const Context &rContext, const bool bVisible) +{ + ContextList::Entry *pEntry = GetMatch( rContext ); + + if ( !pEntry ) + return; + + const sal_Int32 nMatch( rContext.EvaluateMatch( pEntry->maContext ) ); + + if ( nMatch & Context::ApplicationWildcardMatch ) + { + // Create a separate context list entry for this app if 'any' + // is the only context that matches. Toggling the visibility + // for 'any' would change it for all apps, not just this one + AddContextDescription( rContext, bVisible, OUString() ); + } + else if ( nMatch == Context::OptimalMatch || nMatch == Context::ContextWildcardMatch ) + pEntry->mbIsInitiallyVisible = bVisible; +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/ControlFactory.cxx b/sfx2/source/sidebar/ControlFactory.cxx new file mode 100644 index 000000000..d2d3d27dd --- /dev/null +++ b/sfx2/source/sidebar/ControlFactory.cxx @@ -0,0 +1,38 @@ +/* -*- 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 <sidebar/ControlFactory.hxx> + +#include <sidebar/MenuButton.hxx> +#include <sidebar/TabItem.hxx> + +namespace sfx2::sidebar { + +VclPtr<CheckBox> ControlFactory::CreateMenuButton (vcl::Window* pParentWindow) +{ + return VclPtr<MenuButton>::Create(pParentWindow); +} + +VclPtr<RadioButton> ControlFactory::CreateTabItem (vcl::Window* pParentWindow) +{ + return VclPtr<TabItem>::Create(pParentWindow); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/ControllerFactory.cxx b/sfx2/source/sidebar/ControllerFactory.cxx new file mode 100644 index 000000000..50ba57a00 --- /dev/null +++ b/sfx2/source/sidebar/ControllerFactory.cxx @@ -0,0 +1,265 @@ +/* -*- 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 <sidebar/ControllerFactory.hxx> +#include <sidebar/Tools.hxx> + +#include <com/sun/star/frame/XToolbarController.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/frame/theToolbarControllerFactory.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> + +#include <framework/sfxhelperfunctions.hxx> +#include <vcl/commandinfoprovider.hxx> +#include <vcl/weldutils.hxx> +#include <svtools/generictoolboxcontroller.hxx> +#include <comphelper/processfactory.hxx> +#include <toolkit/helper/vclunohelper.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Reference<frame::XToolbarController> ControllerFactory::CreateToolBoxController( + ToolBox* pToolBox, + const sal_uInt16 nItemId, + const OUString& rsCommandName, + const Reference<frame::XFrame>& rxFrame, + const Reference<frame::XController>& rxController, + const Reference<awt::XWindow>& rxParentWindow, + const sal_Int32 nWidth, bool bSideBar) +{ + Reference<frame::XToolbarController> xController ( + CreateToolBarController( + VCLUnoHelper::GetInterface(pToolBox), + rsCommandName, + rxFrame, rxController, + nWidth, bSideBar)); + + bool bFactoryHasController( xController.is() ); + + // Create a controller for the new item. + if ( !bFactoryHasController ) + { + xController.set( + static_cast<XWeak*>(::framework::CreateToolBoxController( + rxFrame, + pToolBox, + nItemId, + rsCommandName)), + UNO_QUERY); + } + if ( ! xController.is()) + { + xController.set( + static_cast<XWeak*>(new svt::GenericToolboxController( + ::comphelper::getProcessComponentContext(), + rxFrame, + pToolBox, + nItemId, + rsCommandName)), + UNO_QUERY); + } + + // Initialize the controller with eg a service factory. + Reference<lang::XInitialization> xInitialization (xController, UNO_QUERY); + if (!bFactoryHasController && xInitialization.is()) + { + beans::PropertyValue aPropValue; + std::vector<Any> aPropertyVector; + + aPropValue.Name = "Frame"; + aPropValue.Value <<= rxFrame; + aPropertyVector.push_back(makeAny(aPropValue)); + + aPropValue.Name = "ServiceManager"; + aPropValue.Value <<= ::comphelper::getProcessServiceFactory(); + aPropertyVector.push_back(makeAny(aPropValue)); + + aPropValue.Name = "CommandURL"; + aPropValue.Value <<= rsCommandName; + aPropertyVector.push_back(makeAny(aPropValue)); + + Sequence<Any> aArgs (comphelper::containerToSequence(aPropertyVector)); + xInitialization->initialize(aArgs); + } + + if (xController.is()) + { + if (rxParentWindow.is()) + { + Reference<awt::XWindow> xItemWindow (xController->createItemWindow(rxParentWindow)); + VclPtr<vcl::Window> pItemWindow = VCLUnoHelper::GetWindow(xItemWindow); + if (pItemWindow != nullptr) + { + WindowType nType = pItemWindow->GetType(); + if (nType == WindowType::LISTBOX || nType == WindowType::MULTILISTBOX || nType == WindowType::COMBOBOX) + pItemWindow->SetAccessibleName(pToolBox->GetItemText(nItemId)); + if (nWidth > 0) + pItemWindow->SetSizePixel(Size(nWidth, pItemWindow->GetSizePixel().Height())); + pToolBox->SetItemWindow(nItemId, pItemWindow); + } + } + + Reference<util::XUpdatable> xUpdatable (xController, UNO_QUERY); + if (xUpdatable.is()) + xUpdatable->update(); + + // Add tooltip. + if (xController.is()) + { + auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(rsCommandName, + vcl::CommandInfoProvider::GetModuleIdentifier(rxFrame)); + const OUString sTooltip (vcl::CommandInfoProvider::GetTooltipForCommand( + rsCommandName, aProperties, rxFrame)); + if (pToolBox->GetQuickHelpText(nItemId).isEmpty()) + pToolBox->SetQuickHelpText(nItemId, sTooltip); + pToolBox->EnableItem(nItemId); + } + } + + return xController; +} + +Reference<frame::XToolbarController> ControllerFactory::CreateToolBoxController( + weld::Toolbar& rToolbar, weld::Builder& rBuilder, + const OUString& rsCommandName, + const Reference<frame::XFrame>& rxFrame, bool bSideBar) +{ + css::uno::Reference<css::awt::XWindow> xWidget(new weld::TransportAsXWindow(&rToolbar, &rBuilder)); + + Reference<frame::XToolbarController> xController( + CreateToolBarController( + xWidget, + rsCommandName, + rxFrame, rxFrame->getController(), + -1, bSideBar)); + + if (!xController.is()) + { + xController.set( + static_cast<XWeak*>(new svt::GenericToolboxController( + ::comphelper::getProcessComponentContext(), + rxFrame, + rToolbar, + rsCommandName)), + UNO_QUERY); + } + + // Initialize the controller with eg a service factory. + Reference<lang::XInitialization> xInitialization (xController, UNO_QUERY); + if (/*!bFactoryHasController &&*/ xInitialization.is()) + { + beans::PropertyValue aPropValue; + std::vector<Any> aPropertyVector; + + aPropValue.Name = "Frame"; + aPropValue.Value <<= rxFrame; + aPropertyVector.push_back(makeAny(aPropValue)); + + aPropValue.Name = "ServiceManager"; + aPropValue.Value <<= ::comphelper::getProcessServiceFactory(); + aPropertyVector.push_back(makeAny(aPropValue)); + + aPropValue.Name = "CommandURL"; + aPropValue.Value <<= rsCommandName; + aPropertyVector.push_back(makeAny(aPropValue)); + + Sequence<Any> aArgs (comphelper::containerToSequence(aPropertyVector)); + xInitialization->initialize(aArgs); + } + + if (xController.is()) + { + xController->createItemWindow(xWidget); + + Reference<util::XUpdatable> xUpdatable(xController, UNO_QUERY); + if (xUpdatable.is()) + xUpdatable->update(); + } + + return xController; +} + + +Reference<frame::XToolbarController> ControllerFactory::CreateToolBarController( + const Reference<awt::XWindow>& rxToolbar, + const OUString& rsCommandName, + const Reference<frame::XFrame>& rxFrame, + const Reference<frame::XController>& rxController, + const sal_Int32 nWidth, bool bSideBar) +{ + try + { + Reference<XComponentContext> xContext = comphelper::getProcessComponentContext(); + Reference<frame::XUIControllerFactory> xFactory = frame::theToolbarControllerFactory::get( xContext ); + OUString sModuleName (Tools::GetModuleName(rxController)); + + if (xFactory.is() && xFactory->hasController(rsCommandName, sModuleName)) + { + beans::PropertyValue aPropValue; + std::vector<Any> aPropertyVector; + + aPropValue.Name = "ModuleIdentifier"; + aPropValue.Value <<= sModuleName; + aPropertyVector.push_back( makeAny( aPropValue )); + + aPropValue.Name = "Frame"; + aPropValue.Value <<= rxFrame; + aPropertyVector.push_back( makeAny( aPropValue )); + + aPropValue.Name = "ServiceManager"; + aPropValue.Value <<= comphelper::getProcessServiceFactory(); + aPropertyVector.push_back( makeAny( aPropValue )); + + aPropValue.Name = "ParentWindow"; + aPropValue.Value <<= rxToolbar; + aPropertyVector.push_back( makeAny( aPropValue )); + + aPropValue.Name = "IsSidebar"; + aPropValue.Value <<= bSideBar; + aPropertyVector.push_back( makeAny( aPropValue )); + + if (nWidth > 0) + { + aPropValue.Name = "Width"; + aPropValue.Value <<= nWidth; + aPropertyVector.push_back( makeAny( aPropValue )); + } + + Sequence<Any> aArgs (comphelper::containerToSequence(aPropertyVector)); + return Reference<frame::XToolbarController>( + xFactory->createInstanceWithArgumentsAndContext( + rsCommandName, + aArgs, + xContext), + UNO_QUERY); + } + } + catch (Exception&) + { + // Ignore exception. + } + return nullptr; +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/ControllerItem.cxx b/sfx2/source/sidebar/ControllerItem.cxx new file mode 100644 index 000000000..a362e3d8d --- /dev/null +++ b/sfx2/source/sidebar/ControllerItem.cxx @@ -0,0 +1,73 @@ +/* -*- 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 <sfx2/sidebar/ControllerItem.hxx> + +#include <sfx2/bindings.hxx> + +#include <com/sun/star/lang/XComponent.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +ControllerItem::ControllerItem ( + const sal_uInt16 nSlotId, + SfxBindings &rBindings, + ItemUpdateReceiverInterface& rItemUpdateReceiver) + : SfxControllerItem(nSlotId, rBindings), + mrItemUpdateReceiver(rItemUpdateReceiver) +{ +} + +ControllerItem::~ControllerItem() +{ + dispose(); +} + +void ControllerItem::StateChanged ( + sal_uInt16 nSID, + SfxItemState eState, + const SfxPoolItem* pState) +{ + mrItemUpdateReceiver.NotifyItemUpdate(nSID, eState, pState); +} + +void ControllerItem::GetControlState ( + sal_uInt16 nSID, + boost::property_tree::ptree& rState) +{ + mrItemUpdateReceiver.GetControlState(nSID, rState); +} + +void ControllerItem::RequestUpdate() +{ + std::unique_ptr<SfxPoolItem> pState; + const SfxItemState eState (GetBindings().QueryState(GetId(), pState)); + mrItemUpdateReceiver.NotifyItemUpdate(GetId(), eState, pState.get()); +} + +ControllerItem::ItemUpdateReceiverInterface::~ItemUpdateReceiverInterface() +{ +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/Deck.cxx b/sfx2/source/sidebar/Deck.cxx new file mode 100644 index 000000000..d96305c3e --- /dev/null +++ b/sfx2/source/sidebar/Deck.cxx @@ -0,0 +1,447 @@ +/* -*- 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 <sfx2/sidebar/Deck.hxx> +#include <sidebar/DeckDescriptor.hxx> +#include <sidebar/DeckLayouter.hxx> +#include <sidebar/DrawHelper.hxx> +#include <sidebar/DeckTitleBar.hxx> +#include <sidebar/PanelTitleBar.hxx> +#include <sidebar/Paint.hxx> +#include <sfx2/sidebar/Panel.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sfx2/lokhelper.hxx> + +#include <vcl/event.hxx> +#include <comphelper/lok.hxx> +#include <vcl/scrbar.hxx> +#include <vcl/commandevent.hxx> +#include <vcl/IDialogRenderable.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/svborder.hxx> +#include <boost/property_tree/ptree.hpp> +#include <sal/log.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Deck::Deck(const DeckDescriptor& rDeckDescriptor, vcl::Window* pParentWindow, + const std::function<void()>& rCloserAction) + : Window(pParentWindow, 0) + , msId(rDeckDescriptor.msId) + , mnMinimalWidth(0) + , mnMinimalHeight(0) + , maPanels() + , mpTitleBar(VclPtr<DeckTitleBar>::Create(rDeckDescriptor.msTitle, this, rCloserAction)) + , mpScrollClipWindow(VclPtr<vcl::Window>::Create(this)) + , mpScrollContainer(VclPtr<ScrollContainerWindow>::Create(mpScrollClipWindow.get())) + , mpFiller(VclPtr<vcl::Window>::Create(this)) + , mpVerticalScrollBar(VclPtr<ScrollBar>::Create(this)) +{ + mpScrollClipWindow->SetBackground(Wallpaper()); + mpScrollClipWindow->Show(); + + mpScrollContainer->SetStyle(mpScrollContainer->GetStyle() | WB_DIALOGCONTROL); + mpScrollContainer->SetBackground(Wallpaper()); + mpScrollContainer->Show(); + + mpVerticalScrollBar->SetScrollHdl(LINK(this, Deck, HandleVerticalScrollBarChange)); + mpVerticalScrollBar->SetLineSize(10); + mpVerticalScrollBar->SetPageSize(100); + +#ifdef DEBUG + SetText(OUString("Deck")); + mpScrollClipWindow->SetText(OUString("ScrollClipWindow")); + mpFiller->SetText(OUString("Filler")); + mpVerticalScrollBar->SetText(OUString("VerticalScrollBar")); +#endif +} + +Deck::~Deck() +{ + disposeOnce(); +} + +void Deck::dispose() +{ + SharedPanelContainer aPanels; + aPanels.swap(maPanels); + + // We have to explicitly trigger the destruction of panels. + // Otherwise that is done by one of our base class destructors + // without updating maPanels. + for (VclPtr<Panel> & rpPanel : aPanels) + rpPanel.disposeAndClear(); + + maPanels.clear(); // just to keep the loplugin:vclwidgets happy + mpTitleBar.disposeAndClear(); + mpFiller.disposeAndClear(); + mpVerticalScrollBar.disposeAndClear(); + mpScrollContainer.disposeAndClear(); + mpScrollClipWindow.disposeAndClear(); + + vcl::Window::dispose(); +} + +VclPtr<DeckTitleBar> const & Deck::GetTitleBar() const +{ + return mpTitleBar; +} + +tools::Rectangle Deck::GetContentArea() const +{ + const Size aWindowSize (GetSizePixel()); + const int nBorderSize (Theme::GetInteger(Theme::Int_DeckBorderSize)); + if (aWindowSize.IsEmpty()) + return tools::Rectangle(); + + return tools::Rectangle( + Theme::GetInteger(Theme::Int_DeckLeftPadding) + nBorderSize, + Theme::GetInteger(Theme::Int_DeckTopPadding) + nBorderSize, + aWindowSize.Width() - 1 - Theme::GetInteger(Theme::Int_DeckRightPadding) - nBorderSize, + aWindowSize.Height() - 1 - Theme::GetInteger(Theme::Int_DeckBottomPadding) - nBorderSize); +} + +void Deck::ApplySettings(vcl::RenderContext& rRenderContext) +{ + rRenderContext.SetBackground(Wallpaper()); +} + +void Deck::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rUpdateArea*/) +{ + const Size aWindowSize (GetSizePixel()); + const SvBorder aPadding(Theme::GetInteger(Theme::Int_DeckLeftPadding), + Theme::GetInteger(Theme::Int_DeckTopPadding), + Theme::GetInteger(Theme::Int_DeckRightPadding), + Theme::GetInteger(Theme::Int_DeckBottomPadding)); + + // Paint deck background outside the border. + tools::Rectangle aBox(0, 0, aWindowSize.Width() - 1, aWindowSize.Height() - 1); + DrawHelper::DrawBorder(rRenderContext, aBox, aPadding, + Theme::GetPaint(Theme::Paint_DeckBackground), + Theme::GetPaint(Theme::Paint_DeckBackground)); + + // Paint the border. + const int nBorderSize(Theme::GetInteger(Theme::Int_DeckBorderSize)); + aBox.AdjustLeft(aPadding.Left() ); + aBox.AdjustTop(aPadding.Top() ); + aBox.AdjustRight( -(aPadding.Right()) ); + aBox.AdjustBottom( -(aPadding.Bottom()) ); + const sfx2::sidebar::Paint& rHorizontalBorderPaint(Theme::GetPaint(Theme::Paint_HorizontalBorder)); + DrawHelper::DrawBorder(rRenderContext, aBox, + SvBorder(nBorderSize, nBorderSize, nBorderSize, nBorderSize), + rHorizontalBorderPaint, + Theme::GetPaint(Theme::Paint_VerticalBorder)); +} + +void Deck::DataChanged (const DataChangedEvent&) +{ + RequestLayoutInternal(); +} + +bool Deck::EventNotify(NotifyEvent& rEvent) +{ + if (rEvent.GetType() == MouseNotifyEvent::COMMAND) + { + CommandEvent* pCommandEvent = static_cast<CommandEvent*>(rEvent.GetData()); + if (pCommandEvent != nullptr) + switch (pCommandEvent->GetCommand()) + { + case CommandEventId::Wheel: + return ProcessWheelEvent(pCommandEvent); + + default: + break; + } + } + + return Window::EventNotify(rEvent); +} + +void Deck::Resize() +{ + Window::Resize(); + + if (const vcl::ILibreOfficeKitNotifier* pNotifier = GetLOKNotifier()) + { + std::vector<vcl::LOKPayloadItem> aItems; + aItems.emplace_back("type", "deck"); + aItems.emplace_back(std::make_pair("position", Point(GetOutOffXPixel(), GetOutOffYPixel()).toString())); + aItems.emplace_back(std::make_pair("size", GetSizePixel().toString())); + pNotifier->notifyWindow(GetLOKWindowId(), "size_changed", aItems); + } +} + +/* + * Get the ordering as is shown in the layout, and our type as 'deck' + * also elide nested panel windows. + */ +boost::property_tree::ptree Deck::DumpAsPropertyTree() +{ + boost::property_tree::ptree aTree; + aTree.put("id", get_id()); // TODO could be missing - sort out + aTree.put("type", "deck"); + aTree.put("text", GetText()); + aTree.put("enabled", IsEnabled()); + + boost::property_tree::ptree aPanelNodes; + for (auto &it : maPanels) + { + if (it->IsLurking()) + continue; + + // collapse the panel itself out + auto xContent = it->GetElementWindow(); + if (!xContent.is()) + continue; + VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(xContent); + if (!pWindow) + continue; + + boost::property_tree::ptree aPanel; + aPanel.put("id", it->GetId()); + aPanel.put("type", "panel"); + aPanel.put("text", it->GetText()); + aPanel.put("enabled", it->IsEnabled()); + + boost::property_tree::ptree aChildren; + aChildren.push_back(std::make_pair("", pWindow->DumpAsPropertyTree())); + aPanel.add_child("children", aChildren); + + aPanelNodes.push_back(std::make_pair("", aPanel)); + } + aTree.add_child("children", aPanelNodes); + + return aTree; +} + +bool Deck::ProcessWheelEvent(CommandEvent const * pCommandEvent) +{ + if ( ! mpVerticalScrollBar) + return false; + if ( ! mpVerticalScrollBar->IsVisible()) + return false; + + // Get the wheel data and check that it describes a valid vertical + // scroll. + const CommandWheelData* pData = pCommandEvent->GetWheelData(); + if (pData==nullptr + || pData->GetModifier() + || pData->GetMode() != CommandWheelMode::SCROLL + || pData->IsHorz()) + return false; + + // Execute the actual scroll action. + long nDelta = pData->GetDelta(); + mpVerticalScrollBar->DoScroll( + mpVerticalScrollBar->GetThumbPos() - nDelta); + return true; +} + +/** + * This container may contain existing panels that are + * being re-used, and new ones too. + */ +void Deck::ResetPanels(const SharedPanelContainer& rPanelContainer) +{ + SharedPanelContainer aHiddens; + + // First hide old panels we don't need just now. + for (VclPtr<Panel> & rpPanel : maPanels) + { + bool bFound = false; + for (const auto & i : rPanelContainer) + bFound = bFound || (rpPanel.get() == i.get()); + if (!bFound) // this one didn't survive. + { + rpPanel->SetLurkMode(true); + aHiddens.push_back(rpPanel); + } + } + maPanels = rPanelContainer; + + // Hidden ones always at the end + maPanels.insert(std::end(maPanels), std::begin(aHiddens), std::end(aHiddens)); + + RequestLayoutInternal(); +} + +void Deck::RequestLayoutInternal() +{ + mnMinimalWidth = 0; + mnMinimalHeight = 0; + + DeckLayouter::LayoutDeck(GetContentArea(), mnMinimalWidth, mnMinimalHeight, maPanels, + *GetTitleBar(), *mpScrollClipWindow, *mpScrollContainer, + *mpFiller, *mpVerticalScrollBar); +} + +void Deck::RequestLayout() +{ + RequestLayoutInternal(); + + if (comphelper::LibreOfficeKit::isActive()) + { + bool bChangeNeeded = false; + Size aParentSize = GetParent()->GetSizePixel(); + + if (mnMinimalHeight > 0 && (mnMinimalHeight != aParentSize.Height() || GetSizePixel().Height() != mnMinimalHeight)) + { + aParentSize.setHeight(mnMinimalHeight); + bChangeNeeded = true; + } + const SfxViewShell* pViewShell = SfxViewShell::Current(); + if (mnMinimalWidth > 0 && (mnMinimalWidth != aParentSize.Width() || GetSizePixel().Width() != mnMinimalWidth) + && pViewShell && pViewShell->isLOKMobilePhone()) + { + aParentSize.setWidth(mnMinimalWidth); + bChangeNeeded = true; + } + + if (bChangeNeeded) + { + GetParent()->SetSizePixel(aParentSize); + setPosSizePixel(0, 0, aParentSize.Width(), aParentSize.Height()); + } + else if (aParentSize != GetSizePixel()) //Sync parent & child sizes + setPosSizePixel(0, 0, aParentSize.Width(), aParentSize.Height()); + } +} + +vcl::Window* Deck::GetPanelParentWindow() +{ + return mpScrollContainer.get(); +} + +Panel* Deck::GetPanel(const OUString & panelId) +{ + for (const VclPtr<Panel> & pPanel : maPanels) + { + if(pPanel->GetId() == panelId) + { + return pPanel.get(); + } + } + return nullptr; + +} + +void Deck::ShowPanel(const Panel& rPanel) +{ + if (!mpVerticalScrollBar || !mpVerticalScrollBar->IsVisible()) + return; + + // Get vertical extent of the panel. + sal_Int32 nPanelTop (rPanel.GetPosPixel().Y()); + const sal_Int32 nPanelBottom (nPanelTop + rPanel.GetSizePixel().Height() - 1); + // Add the title bar into the extent. + if (rPanel.GetTitleBar() && rPanel.GetTitleBar()->IsVisible()) + nPanelTop = rPanel.GetTitleBar()->GetPosPixel().Y(); + + // Determine what the new thumb position should be like. + // When the whole panel does not fit then make its top visible + // and it off at the bottom. + sal_Int32 nNewThumbPos (mpVerticalScrollBar->GetThumbPos()); + if (nPanelBottom >= nNewThumbPos+mpVerticalScrollBar->GetVisibleSize()) + nNewThumbPos = nPanelBottom - mpVerticalScrollBar->GetVisibleSize(); + if (nPanelTop < nNewThumbPos) + nNewThumbPos = nPanelTop; + + mpVerticalScrollBar->SetThumbPos(nNewThumbPos); + mpScrollContainer->SetPosPixel( + Point( + mpScrollContainer->GetPosPixel().X(), + -nNewThumbPos)); +} + +static OUString GetWindowClassification(const vcl::Window* pWindow) +{ + const OUString& rsName (pWindow->GetText()); + if (!rsName.isEmpty()) + { + return rsName; + } + else + { + return "window"; + } +} + +void Deck::PrintWindowSubTree(vcl::Window* pRoot, int nIndentation) +{ + static const char* const sIndentation = " "; + const Point aLocation (pRoot->GetPosPixel()); + const Size aSize (pRoot->GetSizePixel()); + SAL_INFO( + "sfx.sidebar", + sIndentation + strlen(sIndentation) - nIndentation * 4 << pRoot << " " + << GetWindowClassification(pRoot) << " " + << (pRoot->IsVisible() ? "visible" : "hidden") << " +" + << aLocation.X() << "+" << aLocation.Y() << " x" << aSize.Width() + << "x" << aSize.Height()); + + const sal_uInt16 nChildCount(pRoot->GetChildCount()); + for (sal_uInt16 nIndex = 0; nIndex < nChildCount; ++nIndex) + PrintWindowSubTree(pRoot->GetChild(nIndex), nIndentation + 1); +} + +IMPL_LINK_NOARG(Deck, HandleVerticalScrollBarChange, ScrollBar*, void) +{ + const sal_Int32 nYOffset (-mpVerticalScrollBar->GetThumbPos()); + mpScrollContainer->SetPosPixel(Point(mpScrollContainer->GetPosPixel().X(), + nYOffset)); + mpScrollContainer->Invalidate(); +} + +//----- Deck::ScrollContainerWindow ------------------------------------------- + +Deck::ScrollContainerWindow::ScrollContainerWindow (vcl::Window* pParentWindow) + : Window(pParentWindow), + maSeparators() +{ +#ifdef DEBUG + SetText(OUString("ScrollContainerWindow")); +#endif +} + +void Deck::ScrollContainerWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rUpdateArea*/) +{ + // Paint the separators. + const sal_Int32 nSeparatorHeight(Theme::GetInteger(Theme::Int_DeckSeparatorHeight)); + const sal_Int32 nLeft(0); + const sal_Int32 nRight(GetSizePixel().Width() - 1); + const sfx2::sidebar::Paint& rHorizontalBorderPaint(Theme::GetPaint(Theme::Paint_HorizontalBorder)); + for (auto const& separator : maSeparators) + { + DrawHelper::DrawHorizontalLine(rRenderContext, nLeft, nRight, separator, + nSeparatorHeight, rHorizontalBorderPaint); + } +} + +void Deck::ScrollContainerWindow::SetSeparators (const ::std::vector<sal_Int32>& rSeparators) +{ + maSeparators = rSeparators; + Invalidate(); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/DeckDescriptor.cxx b/sfx2/source/sidebar/DeckDescriptor.cxx new file mode 100644 index 000000000..79bb3afda --- /dev/null +++ b/sfx2/source/sidebar/DeckDescriptor.cxx @@ -0,0 +1,62 @@ +/* -*- 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 <sidebar/DeckDescriptor.hxx> + +namespace sfx2::sidebar { + +DeckDescriptor::DeckDescriptor() + : msTitle(), + msId(), + msIconURL(), + msHighContrastIconURL(), + msTitleBarIconURL(), + msHighContrastTitleBarIconURL(), + msHelpText(), + maContextList(), + mbIsEnabled(true), + mnOrderIndex(10000), // Default value as defined in Sidebar.xcs + mbExperimental(false), + mpDeck() +{ +} + +DeckDescriptor::DeckDescriptor (const DeckDescriptor& rOther) + : msTitle(rOther.msTitle), + msId(rOther.msId), + msIconURL(rOther.msIconURL), + msHighContrastIconURL(rOther.msHighContrastIconURL), + msTitleBarIconURL(rOther.msTitleBarIconURL), + msHighContrastTitleBarIconURL(rOther.msHighContrastTitleBarIconURL), + msHelpText(rOther.msHelpText), + maContextList(rOther.maContextList), + mbIsEnabled(rOther.mbIsEnabled), + mnOrderIndex(rOther.mnOrderIndex), + mbExperimental(rOther.mbExperimental), + mpDeck(rOther.mpDeck) +{ +} + +DeckDescriptor::~DeckDescriptor() +{ +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/DeckLayouter.cxx b/sfx2/source/sidebar/DeckLayouter.cxx new file mode 100644 index 000000000..49a57bf4d --- /dev/null +++ b/sfx2/source/sidebar/DeckLayouter.cxx @@ -0,0 +1,634 @@ +/* -*- 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 <sidebar/DeckLayouter.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sfx2/sidebar/Panel.hxx> +#include <sidebar/PanelTitleBar.hxx> +#include <sfx2/sidebar/Deck.hxx> +#include <sfx2/sidebar/SidebarController.hxx> +#include <comphelper/lok.hxx> + +#include <comphelper/processfactory.hxx> +#include <vcl/window.hxx> +#include <vcl/scrbar.hxx> + +#include <com/sun/star/uno/Reference.hxx> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/XDesktop2.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/ui/XSidebarPanel.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +namespace { + static const sal_Int32 MinimalPanelHeight (25); + + enum LayoutMode + { + MinimumOrLarger, + PreferredOrLarger, + Preferred + }; + class LayoutItem + { + public: + VclPtr<Panel> mpPanel; + css::ui::LayoutSize maLayoutSize; + sal_Int32 mnDistributedHeight; + sal_Int32 mnWeight; + bool mbShowTitleBar; + + LayoutItem(const VclPtr<Panel>& rPanel) + : mpPanel(rPanel) + , maLayoutSize(0, 0, 0) + , mnDistributedHeight(0) + , mnWeight(0) + , mbShowTitleBar(true) + { + } + }; + tools::Rectangle LayoutPanels ( + const tools::Rectangle& rContentArea, + sal_Int32& rMinimalWidth, + sal_Int32& rMinimalHeight, + ::std::vector<LayoutItem>& rLayoutItems, + vcl::Window& rScrollClipWindow, + vcl::Window& rScrollContainer, + ScrollBar& pVerticalScrollBar, + const bool bShowVerticalScrollBar); + void GetRequestedSizes ( + ::std::vector<LayoutItem>& rLayoutItem, + sal_Int32& rAvailableHeight, + sal_Int32& rMinimalWidth, + const tools::Rectangle& rContentBox); + void DistributeHeights ( + ::std::vector<LayoutItem>& rLayoutItems, + const sal_Int32 nHeightToDistribute, + const sal_Int32 nContainerHeight, + const bool bMinimumHeightIsBase); + bool MoveResizePixel(const VclPtr<vcl::Window> &pWindow, + const Point &rNewPos, const Size &rNewSize); + sal_Int32 PlacePanels ( + ::std::vector<LayoutItem>& rLayoutItems, + const sal_Int32 nWidth, + const LayoutMode eMode, + vcl::Window& rScrollContainer); + tools::Rectangle PlaceDeckTitle ( + vcl::Window& rTittleBar, + const tools::Rectangle& rAvailableSpace); + tools::Rectangle PlaceVerticalScrollBar ( + ScrollBar& rVerticalScrollBar, + const tools::Rectangle& rAvailableSpace, + const bool bShowVerticalScrollBar); + void SetupVerticalScrollBar( + ScrollBar& rVerticalScrollBar, + const sal_Int32 nContentHeight, + const sal_Int32 nVisibleHeight); + void UpdateFiller ( + vcl::Window& rFiller, + const tools::Rectangle& rBox); +} + +void DeckLayouter::LayoutDeck ( + const tools::Rectangle& rContentArea, + sal_Int32& rMinimalWidth, + sal_Int32& rMinimalHeight, + SharedPanelContainer& rPanels, + vcl::Window& rDeckTitleBar, + vcl::Window& rScrollClipWindow, + vcl::Window& rScrollContainer, + vcl::Window& rFiller, + ScrollBar& rVerticalScrollBar) +{ + if (rContentArea.GetWidth()<=0 || rContentArea.GetHeight()<=0) + return; + tools::Rectangle aBox (PlaceDeckTitle(rDeckTitleBar, rContentArea)); + + if ( ! rPanels.empty()) + { + // Prepare the layout item container. + ::std::vector<LayoutItem> aLayoutItems; + aLayoutItems.reserve(rPanels.size()); + for (const auto& rPanel : rPanels) + aLayoutItems.emplace_back(rPanel); + + aBox = LayoutPanels( + aBox, + rMinimalWidth, + rMinimalHeight, + aLayoutItems, + rScrollClipWindow, + rScrollContainer, + rVerticalScrollBar, + false); + } + UpdateFiller(rFiller, aBox); +} + +namespace { + +tools::Rectangle LayoutPanels ( + const tools::Rectangle& rContentArea, + sal_Int32& rMinimalWidth, + sal_Int32& rMinimalHeight, + ::std::vector<LayoutItem>& rLayoutItems, + vcl::Window& rScrollClipWindow, + vcl::Window& rScrollContainer, + ScrollBar& rVerticalScrollBar, + const bool bShowVerticalScrollBar) +{ + tools::Rectangle aBox (PlaceVerticalScrollBar(rVerticalScrollBar, rContentArea, bShowVerticalScrollBar)); + + const sal_Int32 nWidth (aBox.GetWidth()); + + // Get the requested heights of the panels and the available + // height that is left when all panel titles and separators are + // taken into account. + sal_Int32 nAvailableHeight (aBox.GetHeight()); + GetRequestedSizes(rLayoutItems, nAvailableHeight, rMinimalWidth, aBox); + const sal_Int32 nTotalDecorationHeight (aBox.GetHeight() - nAvailableHeight); + + // Analyze the requested heights. + // Determine the height that is available for panel content + // and count the different layouts. + sal_Int32 nTotalPreferredHeight (0); + sal_Int32 nTotalMinimumHeight (0); + + for (const auto& rItem : rLayoutItems) + { + nTotalMinimumHeight += rItem.maLayoutSize.Minimum; + nTotalPreferredHeight += rItem.maLayoutSize.Preferred; + } + + if (nTotalMinimumHeight > nAvailableHeight && !bShowVerticalScrollBar + && !comphelper::LibreOfficeKit::isActive()) + { + // Not enough space, even when all panels are shrunk to their + // minimum height. + // Show a vertical scrollbar. + return LayoutPanels( + rContentArea, + rMinimalWidth, + rMinimalHeight, + rLayoutItems, + rScrollClipWindow, + rScrollContainer, + rVerticalScrollBar, + true); + } + + // We are now in one of three modes. + // - The preferred height fits into the available size: + // Use the preferred size, distribute the remaining height by + // enlarging panels. + // - The total minimum height fits into the available size: + // Use the minimum size, distribute the remaining height by + // enlarging panels. + // - The total minimum height does not fit into the available + // size: + // Use the unmodified preferred height for all panels. + + LayoutMode eMode (MinimumOrLarger); + if (bShowVerticalScrollBar) + eMode = Preferred; + else if (nTotalPreferredHeight <= nAvailableHeight) + eMode = PreferredOrLarger; + else + eMode = MinimumOrLarger; + + if (eMode != Preferred) + { + const sal_Int32 nTotalHeight (eMode==MinimumOrLarger ? nTotalMinimumHeight : nTotalPreferredHeight); + + DistributeHeights( + rLayoutItems, + nAvailableHeight-nTotalHeight, + aBox.GetHeight(), + eMode==MinimumOrLarger); + } + + // Set position and size of the mpScrollClipWindow to the available + // size. Its child, the mpScrollContainer, may have a bigger + // height. + rScrollClipWindow.setPosSizePixel(aBox.Left(), aBox.Top(), aBox.GetWidth(), aBox.GetHeight()); + + const sal_Int32 nContentHeight ( + eMode==Preferred + ? nTotalPreferredHeight + nTotalDecorationHeight + : aBox.GetHeight()); + sal_Int32 nY = rVerticalScrollBar.GetThumbPos(); + if (nContentHeight-nY < aBox.GetHeight()) + nY = nContentHeight-aBox.GetHeight(); + if (nY < 0) + nY = 0; + rScrollContainer.setPosSizePixel( + 0, + -nY, + nWidth, + nContentHeight); + + if (bShowVerticalScrollBar) + SetupVerticalScrollBar(rVerticalScrollBar, nContentHeight, aBox.GetHeight()); + + const sal_Int32 nUsedHeight (PlacePanels(rLayoutItems, nWidth, eMode, rScrollContainer)); + aBox.AdjustTop(nUsedHeight ); + rMinimalHeight = nUsedHeight; + return aBox; +} + +bool MoveResizePixel(const VclPtr<vcl::Window> &pWindow, + const Point &rNewPos, const Size &rNewSize) +{ + Point aCurPos = pWindow->GetPosPixel(); + Size aCurSize = pWindow->GetSizePixel(); + if (rNewPos == aCurPos && aCurSize == rNewSize) + return false; + pWindow->setPosSizePixel(rNewPos.X(), rNewPos.Y(), rNewSize.Width(), rNewSize.Height()); + return true; +} + +sal_Int32 PlacePanels ( + ::std::vector<LayoutItem>& rLayoutItems, + const sal_Int32 nWidth, + const LayoutMode eMode, + vcl::Window& rScrollContainer) +{ + ::std::vector<sal_Int32> aSeparators; + const sal_Int32 nDeckSeparatorHeight (Theme::GetInteger(Theme::Int_DeckSeparatorHeight)); + sal_Int32 nY (0); + + vcl::Region aInvalidRegions; + + // Assign heights and places. + for(::std::vector<LayoutItem>::const_iterator iItem(rLayoutItems.begin()), + iEnd(rLayoutItems.end()); + iItem!=iEnd; + ++iItem) + { + if (!iItem->mpPanel) + continue; + + Panel& rPanel (*iItem->mpPanel); + + // Separator above the panel title bar. + if (!rPanel.IsLurking()) + { + aSeparators.push_back(nY); + nY += nDeckSeparatorHeight; + } + + // Place the title bar. + VclPtr<PanelTitleBar> pTitleBar = rPanel.GetTitleBar(); + if (pTitleBar) + { + const sal_Int32 nPanelTitleBarHeight (Theme::GetInteger(Theme::Int_PanelTitleBarHeight) * rPanel.GetDPIScaleFactor()); + + if (iItem->mbShowTitleBar) + { + pTitleBar->setPosSizePixel(0, nY, nWidth, nPanelTitleBarHeight); + pTitleBar->Show(); + nY += nPanelTitleBarHeight; + } + else + { + pTitleBar->Hide(); + } + } + + if (rPanel.IsExpanded() && !rPanel.IsLurking()) + { + rPanel.Show(); + + // Determine the height of the panel depending on layout + // mode and distributed heights. + sal_Int32 nPanelHeight (0); + switch(eMode) + { + case MinimumOrLarger: + nPanelHeight = iItem->maLayoutSize.Minimum + iItem->mnDistributedHeight; + break; + case PreferredOrLarger: + nPanelHeight = iItem->maLayoutSize.Preferred + iItem->mnDistributedHeight; + break; + case Preferred: + nPanelHeight = iItem->maLayoutSize.Preferred; + break; + default: + OSL_ASSERT(false); + break; + } + + // Place the panel. + Point aNewPos(0, nY); + Size aNewSize(nWidth, nPanelHeight); + + // Only invalidate if we moved + if (MoveResizePixel(&rPanel, aNewPos, aNewSize)) + { + tools::Rectangle aRect(aNewPos, aNewSize); + aInvalidRegions.Union(rPanel.PixelToLogic(aRect)); + } + + nY += nPanelHeight; + } + else + { + rPanel.Hide(); + + // Add a separator below the collapsed panel, if it is the + // last panel in the deck. + if (iItem == rLayoutItems.end()-1) + { + // Separator below the panel title bar. + aSeparators.push_back(nY); + nY += nDeckSeparatorHeight; + } + } + } + + Deck::ScrollContainerWindow* pScrollContainerWindow + = dynamic_cast<Deck::ScrollContainerWindow*>(&rScrollContainer); + if (pScrollContainerWindow != nullptr) + pScrollContainerWindow->SetSeparators(aSeparators); + + rScrollContainer.Invalidate(aInvalidRegions); + + return nY; +} + +void GetRequestedSizes ( + ::std::vector<LayoutItem>& rLayoutItems, + sal_Int32& rAvailableHeight, + sal_Int32& rMinimalWidth, + const tools::Rectangle& rContentBox) +{ + rAvailableHeight = rContentBox.GetHeight(); + + const sal_Int32 nDeckSeparatorHeight (Theme::GetInteger(Theme::Int_DeckSeparatorHeight)); + + for (auto& rItem : rLayoutItems) + { + rItem.maLayoutSize = ui::LayoutSize(0,0,0); + + if (rItem.mpPanel == nullptr) + continue; + + if (rItem.mpPanel->IsLurking()) + { + rItem.mbShowTitleBar = false; + continue; + } + + if (rLayoutItems.size() == 1 + && rItem.mpPanel->IsTitleBarOptional()) + { + // There is only one panel and its title bar is + // optional => hide it. + rAvailableHeight -= nDeckSeparatorHeight; + rItem.mbShowTitleBar = false; + } + else + { + // Show the title bar and a separator above and below + // the title bar. + const sal_Int32 nPanelTitleBarHeight (Theme::GetInteger(Theme::Int_PanelTitleBarHeight) * rItem.mpPanel->GetDPIScaleFactor()); + + rAvailableHeight -= nPanelTitleBarHeight; + rAvailableHeight -= nDeckSeparatorHeight; + } + + if (rItem.mpPanel->IsExpanded() && rItem.mpPanel->GetPanelComponent().is()) + { + Reference<ui::XSidebarPanel> xPanel (rItem.mpPanel->GetPanelComponent()); + + rItem.maLayoutSize = xPanel->getHeightForWidth(rContentBox.GetWidth()); + if (!(0 <= rItem.maLayoutSize.Minimum && rItem.maLayoutSize.Minimum <= rItem.maLayoutSize.Preferred + && rItem.maLayoutSize.Preferred <= rItem.maLayoutSize.Maximum)) + { + SAL_WARN("sfx.sidebar", "Please follow LayoutSize constraints: 0 ≤ " + "Minimum ≤ Preferred ≤ Maximum." + " Currently: Minimum: " + << rItem.maLayoutSize.Minimum + << " Preferred: " << rItem.maLayoutSize.Preferred + << " Maximum: " << rItem.maLayoutSize.Maximum); + } + + sal_Int32 nWidth = xPanel->getMinimalWidth(); + + uno::Reference<frame::XDesktop2> xDesktop + = frame::Desktop::create(comphelper::getProcessComponentContext()); + uno::Reference<frame::XFrame> xFrame = xDesktop->getActiveFrame(); + if (xFrame.is()) + { + SidebarController* pController + = SidebarController::GetSidebarControllerForFrame(xFrame); + if (pController && pController->getMaximumWidth() < nWidth) + { + // Add 100 extra pixels to still have the sidebar resizable + // (See also documentation of XSidebarPanel::getMinimalWidth) + pController->setMaximumWidth(nWidth + 100); + } + } + + if (nWidth > rMinimalWidth) + rMinimalWidth = nWidth; + } + else + rItem.maLayoutSize = ui::LayoutSize(MinimalPanelHeight, -1, 0); + } +} + +void DistributeHeights ( + ::std::vector<LayoutItem>& rLayoutItems, + const sal_Int32 nHeightToDistribute, + const sal_Int32 nContainerHeight, + const bool bMinimumHeightIsBase) +{ + if (nHeightToDistribute <= 0) + return; + + sal_Int32 nRemainingHeightToDistribute (nHeightToDistribute); + + // Compute the weights as difference between panel base height + // (either its minimum or preferred height) and the container height. + sal_Int32 nTotalWeight (0); + sal_Int32 nNoMaximumCount (0); + + for (auto& rItem : rLayoutItems) + { + if (rItem.maLayoutSize.Maximum == 0) + continue; + if (rItem.maLayoutSize.Maximum < 0) + ++nNoMaximumCount; + + const sal_Int32 nBaseHeight ( + bMinimumHeightIsBase + ? rItem.maLayoutSize.Minimum + : rItem.maLayoutSize.Preferred); + if (nBaseHeight < nContainerHeight) + { + rItem.mnWeight = nContainerHeight - nBaseHeight; + nTotalWeight += rItem.mnWeight; + } + } + + if (nTotalWeight == 0) + return; + + // First pass of height distribution. + for (auto& rItem : rLayoutItems) + { + const sal_Int32 nBaseHeight ( + bMinimumHeightIsBase + ? rItem.maLayoutSize.Minimum + : rItem.maLayoutSize.Preferred); + sal_Int32 nDistributedHeight (rItem.mnWeight * nHeightToDistribute / nTotalWeight); + if (nBaseHeight+nDistributedHeight > rItem.maLayoutSize.Maximum + && rItem.maLayoutSize.Maximum >= 0) + { + nDistributedHeight = ::std::max<sal_Int32>(0, rItem.maLayoutSize.Maximum - nBaseHeight); + } + rItem.mnDistributedHeight = nDistributedHeight; + nRemainingHeightToDistribute -= nDistributedHeight; + } + + if (nRemainingHeightToDistribute == 0) + return; + OSL_ASSERT(nRemainingHeightToDistribute > 0); + + // It is possible that not all of the height could be distributed + // because of Maximum heights being smaller than expected. + // Distribute the remaining height between the panels that have no + // Maximum (ie Maximum==-1). + if (nNoMaximumCount == 0) + { + // There are no panels with unrestricted height. + return; + } + + const sal_Int32 nAdditionalHeightPerPanel(nRemainingHeightToDistribute / nNoMaximumCount); + // Handle rounding error. + sal_Int32 nAdditionalHeightForFirstPanel (nRemainingHeightToDistribute + - nNoMaximumCount*nAdditionalHeightPerPanel); + + for (auto& rItem : rLayoutItems) + { + if (rItem.maLayoutSize.Maximum < 0) + { + rItem.mnDistributedHeight += nAdditionalHeightPerPanel + nAdditionalHeightForFirstPanel; + nRemainingHeightToDistribute -= nAdditionalHeightPerPanel + nAdditionalHeightForFirstPanel; + } + } + + OSL_ASSERT(nRemainingHeightToDistribute==0); +} + +tools::Rectangle PlaceDeckTitle ( + vcl::Window& rDeckTitleBar, + const tools::Rectangle& rAvailableSpace) +{ + if (static_cast<DockingWindow*>(rDeckTitleBar.GetParent()->GetParent())->IsFloatingMode()) + { + // When the side bar is undocked then the outer system window displays the deck title. + rDeckTitleBar.Hide(); + return rAvailableSpace; + } + else + { + const sal_Int32 nDeckTitleBarHeight (Theme::GetInteger(Theme::Int_DeckTitleBarHeight) * rDeckTitleBar.GetDPIScaleFactor()); + rDeckTitleBar.setPosSizePixel( + rAvailableSpace.Left(), + rAvailableSpace.Top(), + rAvailableSpace.GetWidth(), + nDeckTitleBarHeight); + rDeckTitleBar.Show(); + return tools::Rectangle( + rAvailableSpace.Left(), + rAvailableSpace.Top() + nDeckTitleBarHeight, + rAvailableSpace.Right(), + rAvailableSpace.Bottom()); + } +} + +tools::Rectangle PlaceVerticalScrollBar ( + ScrollBar& rVerticalScrollBar, + const tools::Rectangle& rAvailableSpace, + const bool bShowVerticalScrollBar) +{ + if (bShowVerticalScrollBar) + { + const sal_Int32 nScrollBarWidth (rVerticalScrollBar.GetSizePixel().Width()); + rVerticalScrollBar.setPosSizePixel( + rAvailableSpace.Right() - nScrollBarWidth + 1, + rAvailableSpace.Top(), + nScrollBarWidth, + rAvailableSpace.GetHeight()); + rVerticalScrollBar.Show(); + return tools::Rectangle( + rAvailableSpace.Left(), + rAvailableSpace.Top(), + rAvailableSpace.Right() - nScrollBarWidth, + rAvailableSpace.Bottom()); + } + else + { + rVerticalScrollBar.Hide(); + return rAvailableSpace; + } +} + +void SetupVerticalScrollBar( + ScrollBar& rVerticalScrollBar, + const sal_Int32 nContentHeight, + const sal_Int32 nVisibleHeight) +{ + OSL_ASSERT(nContentHeight > nVisibleHeight); + + rVerticalScrollBar.SetRangeMin(0); + rVerticalScrollBar.SetRangeMax(nContentHeight-1); + rVerticalScrollBar.SetVisibleSize(nVisibleHeight); +} + +void UpdateFiller ( + vcl::Window& rFiller, + const tools::Rectangle& rBox) +{ + if (rBox.GetHeight() > 0) + { + // Show the filler. + rFiller.SetBackground(Theme::GetPaint(Theme::Paint_PanelBackground).GetWallpaper()); + rFiller.SetPosSizePixel(rBox.TopLeft(), rBox.GetSize()); + rFiller.Show(); + } + else + { + // Hide the filler. + rFiller.Hide(); + } +} + +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/DeckTitleBar.cxx b/sfx2/source/sidebar/DeckTitleBar.cxx new file mode 100644 index 000000000..4c2f833a4 --- /dev/null +++ b/sfx2/source/sidebar/DeckTitleBar.cxx @@ -0,0 +1,145 @@ +/* -*- 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 <sidebar/DeckTitleBar.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/strings.hrc> + +#include <vcl/event.hxx> +#include <vcl/image.hxx> +#include <vcl/ptrstyle.hxx> + +#ifdef DEBUG +#include <sfx2/sidebar/Tools.hxx> +#endif + +namespace sfx2::sidebar { + +namespace +{ +static const sal_Int32 gaLeftGripPadding (3); +static const sal_Int32 gaRightGripPadding (6); +} + +DeckTitleBar::DeckTitleBar (const OUString& rsTitle, + vcl::Window* pParentWindow, + const std::function<void()>& rCloserAction) + : TitleBar(rsTitle, pParentWindow, GetBackgroundPaint()) + , maCloserAction(rCloserAction) + , mbIsCloserVisible(false) +{ + OSL_ASSERT(pParentWindow != nullptr); + + if (maCloserAction) + SetCloserVisible(true); + +#ifdef DEBUG + SetText(OUString("DeckTitleBar")); +#endif +} + +void DeckTitleBar::SetCloserVisible (const bool bIsCloserVisible) +{ + if (mbIsCloserVisible == bIsCloserVisible) + return; + + mbIsCloserVisible = bIsCloserVisible; + + if (mbIsCloserVisible) + { + maToolBox->InsertItem(mnCloserItemIndex, + Theme::GetImage(Theme::Image_Closer)); + maToolBox->SetQuickHelpText(mnCloserItemIndex, + SfxResId(SFX_STR_SIDEBAR_CLOSE_DECK)); + } + else + maToolBox->RemoveItem(maToolBox->GetItemPos(mnCloserItemIndex)); +} + +tools::Rectangle DeckTitleBar::GetTitleArea (const tools::Rectangle& rTitleBarBox) +{ + Image aGripImage (Theme::GetImage(Theme::Image_Grip)); + return tools::Rectangle( + aGripImage.GetSizePixel().Width() + gaLeftGripPadding + gaRightGripPadding, + rTitleBarBox.Top(), + rTitleBarBox.Right(), + rTitleBarBox.Bottom()); +} + +tools::Rectangle DeckTitleBar::GetDragArea() +{ + Image aGripImage (Theme::GetImage(Theme::Image_Grip)); + return tools::Rectangle(0,0, + aGripImage.GetSizePixel().Width() + gaLeftGripPadding + gaRightGripPadding, + aGripImage.GetSizePixel().Height() + ); +} + +void DeckTitleBar::PaintDecoration(vcl::RenderContext& rRenderContext) +{ + Image aImage (Theme::GetImage(Theme::Image_Grip)); + const Point aTopLeft(gaLeftGripPadding, + (GetSizePixel().Height() - aImage.GetSizePixel().Height()) / 2); + rRenderContext.DrawImage(aTopLeft, aImage); +} + +sidebar::Paint DeckTitleBar::GetBackgroundPaint() +{ + return Theme::GetPaint(Theme::Paint_DeckTitleBarBackground); +} + +void DeckTitleBar::HandleToolBoxItemClick (const sal_uInt16 nItemIndex) +{ + if (nItemIndex == mnCloserItemIndex && maCloserAction) + maCloserAction(); +} + +css::uno::Reference<css::accessibility::XAccessible> DeckTitleBar::CreateAccessible() +{ + SetAccessibleName(msTitle); + SetAccessibleDescription(msTitle); + return TitleBar::CreateAccessible(); +} + +void DeckTitleBar::DataChanged (const DataChangedEvent& rEvent) +{ + maToolBox->SetItemImage( + mnCloserItemIndex, + Theme::GetImage(Theme::Image_Closer)); + TitleBar::DataChanged(rEvent); +} + + +void DeckTitleBar::MouseMove (const MouseEvent& rMouseEvent) +{ + tools::Rectangle aGrip = GetDragArea(); + PointerStyle eStyle = PointerStyle::Arrow; + + if ( aGrip.IsInside( rMouseEvent.GetPosPixel() ) ) + eStyle = PointerStyle::Move; + + SetPointer( eStyle ); + + Window::MouseMove( rMouseEvent ); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/DrawHelper.cxx b/sfx2/source/sidebar/DrawHelper.cxx new file mode 100644 index 000000000..4c9f193ba --- /dev/null +++ b/sfx2/source/sidebar/DrawHelper.cxx @@ -0,0 +1,127 @@ +/* -*- 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 <sidebar/DrawHelper.hxx> +#include <sidebar/Paint.hxx> + +#include <tools/svborder.hxx> + +namespace sfx2::sidebar { + +void DrawHelper::DrawBorder(vcl::RenderContext& rRenderContext, const tools::Rectangle& rBox, const SvBorder& rBorderSize, + const Paint& rHorizontalPaint, const Paint& rVerticalPaint) +{ + // Draw top line. + DrawHorizontalLine(rRenderContext, rBox.Left(), rBox.Right(), + rBox.Top(), rBorderSize.Top(), rHorizontalPaint); + + // Draw bottom line. + DrawHorizontalLine(rRenderContext, rBox.Left() + rBorderSize.Left(), rBox.Right(), + rBox.Bottom() - rBorderSize.Bottom() + 1, rBorderSize.Bottom(), + rHorizontalPaint); + // Draw left line. + DrawVerticalLine(rRenderContext, rBox.Top() + rBorderSize.Top(), rBox.Bottom(), + rBox.Left(), rBorderSize.Left(), rVerticalPaint); + // Draw right line. + DrawVerticalLine(rRenderContext, rBox.Top() + rBorderSize.Top(), rBox.Bottom() - rBorderSize.Bottom(), + rBox.Right() - rBorderSize.Right() + 1, rBorderSize.Right(), rVerticalPaint); +} + +void DrawHelper::DrawHorizontalLine(vcl::RenderContext& rRenderContext, const sal_Int32 nLeft, const sal_Int32 nRight, + const sal_Int32 nY, const sal_Int32 nHeight, const Paint& rPaint) +{ + switch (rPaint.GetType()) + { + case Paint::ColorPaint: + { + const Color aColor(rPaint.GetColor()); + rRenderContext.SetLineColor(aColor); + for (sal_Int32 nYOffset = 0; nYOffset < nHeight; ++nYOffset) + { + rRenderContext.DrawLine(Point(nLeft, nY + nYOffset), + Point(nRight, nY + nYOffset)); + } + break; + } + case Paint::GradientPaint: + rRenderContext.DrawGradient(tools::Rectangle(nLeft, nY, nRight, nY + nHeight - 1), + rPaint.GetGradient()); + break; + + case Paint::NoPaint: + default: + break; + } +} + +void DrawHelper::DrawVerticalLine(vcl::RenderContext& rRenderContext, const sal_Int32 nTop, const sal_Int32 nBottom, + const sal_Int32 nX, const sal_Int32 nWidth, const Paint& rPaint) +{ + switch (rPaint.GetType()) + { + case Paint::ColorPaint: + { + const Color aColor(rPaint.GetColor()); + rRenderContext.SetLineColor(aColor); + for (sal_Int32 nXOffset = 0; nXOffset < nWidth; ++nXOffset) + { + rRenderContext.DrawLine(Point(nX + nXOffset, nTop), + Point(nX + nXOffset, nBottom)); + } + break; + } + case Paint::GradientPaint: + rRenderContext.DrawGradient(tools::Rectangle(nX, nTop, nX + nWidth - 1, nBottom), + rPaint.GetGradient()); + break; + + case Paint::NoPaint: + default: + break; + } +} + +void DrawHelper::DrawRoundedRectangle(vcl::RenderContext& rRenderContext, const tools::Rectangle& rBox, const sal_Int32 nCornerRadius, + const Color& rBorderColor, const Paint& rFillPaint) +{ + rRenderContext.SetLineColor(rBorderColor); + switch (rFillPaint.GetType()) + { + case Paint::ColorPaint: + rRenderContext.SetFillColor(rFillPaint.GetColor()); + rRenderContext.DrawRect(rBox, nCornerRadius, nCornerRadius); + break; + + case Paint::GradientPaint: + rRenderContext.DrawGradient(rBox, rFillPaint.GetGradient()); + rRenderContext.SetFillColor(); + rRenderContext.DrawRect(rBox, nCornerRadius, nCornerRadius); + break; + + case Paint::NoPaint: + default: + rRenderContext.SetFillColor(); + rRenderContext.DrawRect(rBox, nCornerRadius, nCornerRadius); + break; + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/FocusManager.cxx b/sfx2/source/sidebar/FocusManager.cxx new file mode 100644 index 000000000..4a5140c1a --- /dev/null +++ b/sfx2/source/sidebar/FocusManager.cxx @@ -0,0 +1,633 @@ +/* -*- 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 <sfx2/sidebar/FocusManager.hxx> +#include <sfx2/sidebar/Panel.hxx> +#include <sidebar/DeckTitleBar.hxx> +#include <sidebar/PanelTitleBar.hxx> +#include <sidebar/TitleBar.hxx> +#include <vcl/button.hxx> +#include <vcl/event.hxx> +#include <vcl/toolbox.hxx> +#include <vcl/svapp.hxx> +#include <toolkit/helper/vclunohelper.hxx> + +namespace sfx2::sidebar { + +FocusManager::FocusLocation::FocusLocation (const PanelComponent eComponent, const sal_Int32 nIndex) + : meComponent(eComponent), + mnIndex(nIndex) +{ +} + +FocusManager::FocusManager(const std::function<void(const Panel&)>& rShowPanelFunctor, + const std::function<bool(const sal_Int32)>& rIsDeckOpenFunctor) + : mpDeckTitleBar(), + maPanels(), + maButtons(), + maShowPanelFunctor(rShowPanelFunctor), + mbIsDeckOpenFunctor(rIsDeckOpenFunctor) +{ +} + +FocusManager::~FocusManager() +{ + Clear(); +} + +void FocusManager::GrabFocus() +{ + FocusDeckTitle(); +} + +void FocusManager::GrabFocusPanel() +{ + FocusPanel(0, false); +} + +void FocusManager::Clear() +{ + SetDeckTitle(nullptr); + ClearPanels(); + ClearButtons(); +} + +void FocusManager::ClearPanels() +{ + std::vector<VclPtr<Panel> > aPanels; + aPanels.swap(maPanels); + for (auto const& panel : aPanels) + { + UnregisterWindow(*panel); + if (panel->GetTitleBar()) + { + UnregisterWindow(*panel->GetTitleBar()); + UnregisterWindow(panel->GetTitleBar()->GetToolBox()); + } + + panel->RemoveChildEventListener(LINK(this, FocusManager, ChildEventListener)); + } +} + +void FocusManager::ClearButtons() +{ + std::vector<VclPtr<Button> > aButtons; + aButtons.swap(maButtons); + for (auto const& button : aButtons) + { + UnregisterWindow(*button); + } +} + +void FocusManager::SetDeckTitle (DeckTitleBar* pDeckTitleBar) +{ + if (mpDeckTitleBar != nullptr) + { + UnregisterWindow(*mpDeckTitleBar); + UnregisterWindow(mpDeckTitleBar->GetToolBox()); + } + mpDeckTitleBar = pDeckTitleBar; + + if (mpDeckTitleBar != nullptr) + { + RegisterWindow(*mpDeckTitleBar); + RegisterWindow(mpDeckTitleBar->GetToolBox()); + } +} + +void FocusManager::SetPanels (const SharedPanelContainer& rPanels) +{ + ClearPanels(); + for (auto const& panel : rPanels) + { + RegisterWindow(*panel); + if (panel->GetTitleBar()) + { + RegisterWindow(*panel->GetTitleBar()); + RegisterWindow(panel->GetTitleBar()->GetToolBox()); + } + + // Register also as child event listener at the panel. + panel->AddChildEventListener(LINK(this, FocusManager, ChildEventListener)); + + maPanels.emplace_back(panel.get()); + } +} + +void FocusManager::SetButtons (const ::std::vector<Button*>& rButtons) +{ + ClearButtons(); + for (auto const& button : rButtons) + { + RegisterWindow(*button); + maButtons.emplace_back(button); + } +} + +void FocusManager::RegisterWindow (vcl::Window& rWindow) +{ + rWindow.AddEventListener(LINK(this, FocusManager, WindowEventListener)); +} + +void FocusManager::UnregisterWindow (vcl::Window& rWindow) +{ + rWindow.RemoveEventListener(LINK(this, FocusManager, WindowEventListener)); +} + +FocusManager::FocusLocation FocusManager::GetFocusLocation (const vcl::Window& rWindow) const +{ + // Check the deck title. + if (mpDeckTitleBar != nullptr) + { + if (mpDeckTitleBar == &rWindow) + return FocusLocation(PC_DeckTitle, -1); + else if (&mpDeckTitleBar->GetToolBox() == &rWindow) + return FocusLocation(PC_DeckToolBox, -1); + } + + // Search the panels. + for (size_t nIndex = 0; nIndex < maPanels.size(); ++nIndex) + { + if (maPanels[nIndex] == &rWindow) + return FocusLocation(PC_PanelContent, nIndex); + VclPtr<TitleBar> pTitleBar = maPanels[nIndex]->GetTitleBar(); + if (pTitleBar == &rWindow) + return FocusLocation(PC_PanelTitle, nIndex); + if (pTitleBar!=nullptr && &pTitleBar->GetToolBox()==&rWindow) + return FocusLocation(PC_PanelToolBox, nIndex); + } + + // Search the buttons. + for (size_t nIndex=0; nIndex < maButtons.size(); ++nIndex) + { + if (maButtons[nIndex] == &rWindow) + return FocusLocation(PC_TabBar, nIndex); + } + return FocusLocation(PC_None, -1); +} + +void FocusManager::FocusDeckTitle() +{ + if (mpDeckTitleBar != nullptr) + { + if (IsDeckTitleVisible()) + { + mpDeckTitleBar->GrabFocus(); + } + else if (mpDeckTitleBar->GetToolBox().GetItemCount() > 0) + { + ToolBox& rToolBox = mpDeckTitleBar->GetToolBox(); + rToolBox.GrabFocus(); + rToolBox.Invalidate(); + } + else + FocusPanel(0, false); + } + else + FocusPanel(0, false); +} + +bool FocusManager::IsDeckTitleVisible() const +{ + return mpDeckTitleBar != nullptr && mpDeckTitleBar->IsVisible(); +} + +bool FocusManager::IsPanelTitleVisible (const sal_Int32 nPanelIndex) const +{ + if (nPanelIndex<0 || nPanelIndex>=static_cast<sal_Int32>(maPanels.size())) + return false; + + VclPtr<TitleBar> pTitleBar = maPanels[nPanelIndex]->GetTitleBar(); + if (!pTitleBar) + return false; + return pTitleBar->IsVisible(); +} + +void FocusManager::FocusPanel ( + const sal_Int32 nPanelIndex, + const bool bFallbackToDeckTitle) +{ + if (nPanelIndex<0 || nPanelIndex>=static_cast<sal_Int32>(maPanels.size())) + { + if (bFallbackToDeckTitle) + FocusDeckTitle(); + return; + } + + Panel& rPanel (*maPanels[nPanelIndex]); + VclPtr<TitleBar> pTitleBar = rPanel.GetTitleBar(); + if (pTitleBar && pTitleBar->IsVisible()) + { + rPanel.SetExpanded(true); + pTitleBar->GrabFocus(); + } + else if (bFallbackToDeckTitle) + { + // The panel title is not visible, fall back to the deck + // title. + // Make sure that the desk title is visible here to prevent a + // loop when both the title of panel 0 and the deck title are + // not present. + if (IsDeckTitleVisible()) + FocusDeckTitle(); + else + FocusPanelContent(nPanelIndex); + } + else + FocusPanelContent(nPanelIndex); + + if (maShowPanelFunctor) + maShowPanelFunctor(rPanel); +} + +void FocusManager::FocusPanelContent (const sal_Int32 nPanelIndex) +{ + if (!maPanels[nPanelIndex]->IsExpanded()) + maPanels[nPanelIndex]->SetExpanded(true); + + VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(maPanels[nPanelIndex]->GetElementWindow()); + if (pWindow) + pWindow->GrabFocus(); +} + +void FocusManager::FocusButton (const sal_Int32 nButtonIndex) +{ + maButtons[nButtonIndex]->GrabFocus(); + maButtons[nButtonIndex]->Invalidate(); +} + +void FocusManager::ClickButton (const sal_Int32 nButtonIndex) +{ + if (mbIsDeckOpenFunctor) + { + if (!mbIsDeckOpenFunctor(-1) || !mbIsDeckOpenFunctor(nButtonIndex-1)) + maButtons[nButtonIndex]->Click(); + } + if (nButtonIndex > 0) + FocusPanel(0, true); + maButtons[nButtonIndex]->GetParent()->Invalidate(); +} + +void FocusManager::RemoveWindow (vcl::Window& rWindow) +{ + auto iPanel (::std::find(maPanels.begin(), maPanels.end(), &rWindow)); + if (iPanel != maPanels.end()) + { + UnregisterWindow(rWindow); + if ((*iPanel)->GetTitleBar() != nullptr) + { + UnregisterWindow(*(*iPanel)->GetTitleBar()); + UnregisterWindow((*iPanel)->GetTitleBar()->GetToolBox()); + } + maPanels.erase(iPanel); + return; + } + + auto iButton (::std::find(maButtons.begin(), maButtons.end(), &rWindow)); + if (iButton != maButtons.end()) + { + UnregisterWindow(rWindow); + maButtons.erase(iButton); + return; + } +} + +void FocusManager::MoveFocusInsidePanel ( + const FocusLocation& rFocusLocation, + const sal_Int32 nDirection) +{ + const bool bHasToolBoxItem ( + maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().GetItemCount() > 0); + switch (rFocusLocation.meComponent) + { + case PC_PanelTitle: + if (nDirection > 0 && bHasToolBoxItem) + maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GetToolBox().GrabFocus(); + else + FocusPanelContent(rFocusLocation.mnIndex); + break; + + case PC_PanelToolBox: + if (nDirection < 0 && bHasToolBoxItem) + maPanels[rFocusLocation.mnIndex]->GetTitleBar()->GrabFocus(); + else + FocusPanelContent(rFocusLocation.mnIndex); + break; + + default: break; + } +} + +void FocusManager::MoveFocusInsideDeckTitle ( + const FocusLocation& rFocusLocation, + const sal_Int32 nDirection) +{ + // Note that when the title bar of the first (and only) panel is + // not visible then the deck title takes its place and the focus + // is moved between a) deck title, b) deck closer and c) content + // of panel 0. + const bool bHasToolBoxItem ( + mpDeckTitleBar->GetToolBox().GetItemCount() > 0); + switch (rFocusLocation.meComponent) + { + case PC_DeckTitle: + if (nDirection<0 && ! IsPanelTitleVisible(0)) + FocusPanelContent(0); + else if (bHasToolBoxItem) + mpDeckTitleBar->GetToolBox().GrabFocus(); + break; + + case PC_DeckToolBox: + if (nDirection>0 && ! IsPanelTitleVisible(0)) + FocusPanelContent(0); + else + mpDeckTitleBar->GrabFocus(); + break; + + default: break; + } +} + +void FocusManager::HandleKeyEvent ( + const vcl::KeyCode& rKeyCode, + const vcl::Window& rWindow) +{ + const FocusLocation aLocation (GetFocusLocation(rWindow)); + + switch (rKeyCode.GetCode()) + { + case KEY_ESCAPE: + switch (aLocation.meComponent) + { + case PC_TabBar: + case PC_DeckTitle: + case PC_DeckToolBox: + case PC_PanelTitle: + case PC_PanelToolBox: + { + vcl::Window* pFocusWin = Application::GetFocusWindow(); + if (pFocusWin) + pFocusWin->GrabFocusToDocument(); + break; + } + + default: + break; + } + return; + + case KEY_SPACE: + switch (aLocation.meComponent) + { + case PC_PanelTitle: + // Toggle panel between expanded and collapsed. + maPanels[aLocation.mnIndex]->SetExpanded( ! maPanels[aLocation.mnIndex]->IsExpanded()); + maPanels[aLocation.mnIndex]->GetTitleBar()->Invalidate(); + break; + + default: + break; + } + return; + + case KEY_RETURN: + switch (aLocation.meComponent) + { + case PC_DeckToolBox: + FocusButton(0); + break; + + case PC_PanelTitle: + // Enter the panel. + FocusPanelContent(aLocation.mnIndex); + break; + + case PC_TabBar: + // Activate the button. + ClickButton(aLocation.mnIndex); + break; + + default: + break; + } + return; + + case KEY_TAB: + { + const sal_Int32 nDirection ( + rKeyCode.IsShift() + ? -1 + : +1); + switch (aLocation.meComponent) + { + case PC_PanelTitle: + case PC_PanelToolBox: + case PC_PanelContent: + MoveFocusInsidePanel(aLocation, nDirection); + break; + + case PC_DeckTitle: + case PC_DeckToolBox: + MoveFocusInsideDeckTitle(aLocation, nDirection); + break; + + default: + break; + } + break; + } + + case KEY_LEFT: + case KEY_UP: + switch (aLocation.meComponent) + { + case PC_PanelTitle: + case PC_PanelToolBox: + case PC_PanelContent: + // Go to previous panel or the deck title. + if (aLocation.mnIndex > 0) + FocusPanel(aLocation.mnIndex-1, true); + else if (IsDeckTitleVisible()) + FocusDeckTitle(); + else + { + // Focus the last button. + sal_Int32 nIndex(maButtons.size()-1); + while(!maButtons[nIndex]->IsVisible() && --nIndex > 0); + FocusButton(nIndex); + } + break; + + case PC_DeckTitle: + case PC_DeckToolBox: + { + // Focus the last button. + sal_Int32 nIndex(maButtons.size()-1); + while(!maButtons[nIndex]->IsVisible() && --nIndex > 0); + FocusButton(nIndex); + break; + } + + case PC_TabBar: + // Go to previous tab bar item. + if (aLocation.mnIndex == 0) + FocusPanel(maPanels.size()-1, true); + else + { + sal_Int32 nIndex((aLocation.mnIndex + maButtons.size() - 1) % maButtons.size()); + while(!maButtons[nIndex]->IsVisible() && --nIndex > 0); + FocusButton(nIndex); + } + break; + + default: + break; + } + break; + + case KEY_RIGHT: + case KEY_DOWN: + switch(aLocation.meComponent) + { + case PC_PanelTitle: + case PC_PanelToolBox: + case PC_PanelContent: + // Go to next panel. + if (aLocation.mnIndex < static_cast<sal_Int32>(maPanels.size())-1) + FocusPanel(aLocation.mnIndex+1, false); + else + FocusButton(0); + break; + + case PC_DeckTitle: + case PC_DeckToolBox: + // Focus the first panel. + if (IsPanelTitleVisible(0)) + FocusPanel(0, false); + else + FocusButton(0); + break; + + case PC_TabBar: + // Go to next tab bar item. + if (aLocation.mnIndex < static_cast<sal_Int32>(maButtons.size())-1) + { + sal_Int32 nIndex(aLocation.mnIndex + 1); + while(!maButtons[nIndex]->IsVisible() && ++nIndex < static_cast<sal_Int32>(maButtons.size())); + if (nIndex < static_cast<sal_Int32>(maButtons.size())) + { + FocusButton(nIndex); + break; + } + } + if (IsDeckTitleVisible()) + FocusDeckTitle(); + else + FocusPanel(0, true); + break; + + default: + break; + } + break; + } +} + +IMPL_LINK(FocusManager, WindowEventListener, VclWindowEvent&, rWindowEvent, void) +{ + vcl::Window* pSource = rWindowEvent.GetWindow(); + if (pSource == nullptr) + return; + + switch (rWindowEvent.GetId()) + { + case VclEventId::WindowKeyInput: + { + KeyEvent* pKeyEvent = static_cast<KeyEvent*>(rWindowEvent.GetData()); + HandleKeyEvent(pKeyEvent->GetKeyCode(), *pSource); + break; + } + + case VclEventId::ObjectDying: + RemoveWindow(*pSource); + break; + + case VclEventId::WindowGetFocus: + case VclEventId::WindowLoseFocus: + pSource->Invalidate(); + break; + + default: + break; + } +} + +IMPL_LINK(FocusManager, ChildEventListener, VclWindowEvent&, rEvent, void) +{ + vcl::Window* pSource = rEvent.GetWindow(); + if (pSource == nullptr) + return; + + switch (rEvent.GetId()) + { + case VclEventId::WindowKeyInput: + { + KeyEvent* pKeyEvent = static_cast<KeyEvent*>(rEvent.GetData()); + + // Go up the window hierarchy to find out whether the + // parent of the event source is known to us. + vcl::Window* pWindow = pSource; + FocusLocation aLocation (PC_None, -1); + while (true) + { + if (pWindow == nullptr) + break; + aLocation = GetFocusLocation(*pWindow); + if (aLocation.meComponent != PC_None) + break; + pWindow = pWindow->GetParent(); + } + + if (aLocation.meComponent != PC_None) + { + switch (pKeyEvent->GetKeyCode().GetCode()) + { + case KEY_ESCAPE: + // Return focus to tab bar sidebar settings button or panel title. + if (!IsDeckTitleVisible() && maPanels.size() == 1) + FocusButton(0); + else + FocusPanel(aLocation.mnIndex, true); + break; + + default: + break; + } + } + return; + } + + default: + break; + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/IContextChangeReceiver.cxx b/sfx2/source/sidebar/IContextChangeReceiver.cxx new file mode 100644 index 000000000..6fc053921 --- /dev/null +++ b/sfx2/source/sidebar/IContextChangeReceiver.cxx @@ -0,0 +1,29 @@ +/* -*- 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 <sfx2/sidebar/IContextChangeReceiver.hxx> + +namespace sfx2::sidebar { + +IContextChangeReceiver::~IContextChangeReceiver() +{ +} + +} // end of namespace ::sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/ILayoutableWindow.cxx b/sfx2/source/sidebar/ILayoutableWindow.cxx new file mode 100644 index 000000000..6a24cadbf --- /dev/null +++ b/sfx2/source/sidebar/ILayoutableWindow.cxx @@ -0,0 +1,29 @@ +/* -*- 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 <sfx2/sidebar/ILayoutableWindow.hxx> + +namespace sfx2::sidebar { + +ILayoutableWindow::~ILayoutableWindow() +{ +} + +} // end of namespace ::sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/MenuButton.cxx b/sfx2/source/sidebar/MenuButton.cxx new file mode 100644 index 000000000..36be7fcfc --- /dev/null +++ b/sfx2/source/sidebar/MenuButton.cxx @@ -0,0 +1,102 @@ +/* -*- 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 <sidebar/MenuButton.hxx> + +#include <sidebar/DrawHelper.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <vcl/event.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +MenuButton::MenuButton (vcl::Window* pParentWindow) + : CheckBox(pParentWindow), + mbIsLeftButtonDown(false) +{ +#ifdef DEBUG + SetText(OUString("MenuButton")); +#endif +} + +void MenuButton::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rUpdateArea*/) +{ + const bool bIsSelected (IsChecked()); + const bool bIsHighlighted (IsMouseOver() || HasFocus()); + DrawHelper::DrawRoundedRectangle( + rRenderContext, + tools::Rectangle(Point(0,0), GetSizePixel()), + 3, + (bIsHighlighted || bIsSelected + ? Theme::GetColor(Theme::Color_TabItemBorder) + : Color(0xffffffff)), + (bIsHighlighted + ? Theme::GetPaint(Theme::Paint_TabItemBackgroundHighlight) + : Theme::GetPaint(Theme::Paint_TabItemBackgroundNormal))); + + const Image aIcon(Button::GetModeImage()); + const Size aIconSize(aIcon.GetSizePixel()); + const Point aIconLocation((GetSizePixel().Width() - aIconSize.Width()) / 2, + (GetSizePixel().Height() - aIconSize.Height()) / 2); + rRenderContext.DrawImage(aIconLocation, aIcon); +} + +void MenuButton::MouseMove (const MouseEvent& rEvent) +{ + if (rEvent.IsEnterWindow() || rEvent.IsLeaveWindow()) + Invalidate(); + CheckBox::MouseMove(rEvent); +} + +void MenuButton::MouseButtonDown (const MouseEvent& rMouseEvent) +{ + if (rMouseEvent.IsLeft()) + { + mbIsLeftButtonDown = true; + CaptureMouse(); + Invalidate(); + } +} + +void MenuButton::MouseButtonUp (const MouseEvent& rMouseEvent) +{ + if (IsMouseCaptured()) + ReleaseMouse(); + + if (rMouseEvent.IsLeft()) + { + if (mbIsLeftButtonDown) + { + Check(); + Click(); + GetParent()->Invalidate(); + } + } + if (mbIsLeftButtonDown) + { + mbIsLeftButtonDown = false; + Invalidate(); + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/Paint.cxx b/sfx2/source/sidebar/Paint.cxx new file mode 100644 index 000000000..1ab8b5d6d --- /dev/null +++ b/sfx2/source/sidebar/Paint.cxx @@ -0,0 +1,102 @@ +/* -*- 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 <sidebar/Paint.hxx> +#include <sidebar/Tools.hxx> +#include <com/sun/star/awt/Gradient.hpp> + +using namespace css; + +namespace sfx2::sidebar { + +Paint::Paint() + : meType(NoPaint) +{ +} + +Paint::Paint (const Color& rColor) + : meType(ColorPaint), + maValue(rColor) +{ +} + +Paint::Paint (const Gradient& rGradient) + : meType(GradientPaint), + maValue(rGradient) +{ +} + +Paint Paint::Create (const css::uno::Any& rValue) +{ + Color aColor (0); + if (rValue >>= aColor) + return Paint(aColor); + + awt::Gradient aAwtGradient; + if (rValue >>= aAwtGradient) + return Paint(Tools::AwtToVclGradient(aAwtGradient)); + + return Paint(); +} + +const Color& Paint::GetColor() const +{ + if (meType != ColorPaint) + { + assert(meType==ColorPaint); + static const Color aErrorColor; + return aErrorColor; + } + else + return ::boost::get<Color>(maValue); +} + +const Gradient& Paint::GetGradient() const +{ + if (meType != GradientPaint) + { + assert(meType==GradientPaint); + static Gradient aErrorGradient; + return aErrorGradient; + } + else + return ::boost::get<Gradient>(maValue); +} + +Wallpaper Paint::GetWallpaper() const +{ + switch (meType) + { + case Paint::NoPaint: + default: + return Wallpaper(); + break; + + case Paint::ColorPaint: + return Wallpaper(GetColor()); + break; + + case Paint::GradientPaint: + return Wallpaper(GetGradient()); + break; + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/Panel.cxx b/sfx2/source/sidebar/Panel.cxx new file mode 100644 index 000000000..85b6ebf14 --- /dev/null +++ b/sfx2/source/sidebar/Panel.cxx @@ -0,0 +1,191 @@ +/* -*- 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 <sfx2/sidebar/Panel.hxx> +#include <sidebar/PanelTitleBar.hxx> +#include <sidebar/PanelDescriptor.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sidebar/Paint.hxx> +#include <sfx2/sidebar/ResourceManager.hxx> + +#include <sfx2/sidebar/SidebarController.hxx> + + +#ifdef DEBUG +#include <sfx2/sidebar/Tools.hxx> +#include <sfx2/sidebar/Deck.hxx> +#endif + +#include <com/sun/star/awt/PosSize.hpp> +#include <com/sun/star/ui/XToolPanel.hpp> +#include <com/sun/star/ui/XSidebarPanel.hpp> +#include <com/sun/star/ui/XUIElement.hpp> + +#include <boost/property_tree/ptree.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Panel::Panel(const PanelDescriptor& rPanelDescriptor, + vcl::Window* pParentWindow, + const bool bIsInitiallyExpanded, + const std::function<void()>& rDeckLayoutTrigger, + const std::function<Context()>& rContextAccess, + const css::uno::Reference<css::frame::XFrame>& rxFrame + ) + : Window(pParentWindow) + , msPanelId(rPanelDescriptor.msId) + , mpTitleBar(VclPtr<PanelTitleBar>::Create(rPanelDescriptor.msTitle, pParentWindow, this)) + , mbIsTitleBarOptional(rPanelDescriptor.mbIsTitleBarOptional) + , mxElement() + , mxPanelComponent() + , mbIsExpanded(bIsInitiallyExpanded) + , mbLurking(false) + , maDeckLayoutTrigger(rDeckLayoutTrigger) + , maContextAccess(rContextAccess) + , mxFrame(rxFrame) +{ + SetText(rPanelDescriptor.msTitle); +} + +Panel::~Panel() +{ + disposeOnce(); + assert(!mpTitleBar); +} + +void Panel::SetLurkMode(bool bLurk) +{ + // cf. DeckLayouter + mbLurking = bLurk; +} + +void Panel::ApplySettings(vcl::RenderContext& rRenderContext) +{ + rRenderContext.SetBackground(Theme::GetPaint(Theme::Paint_PanelBackground).GetWallpaper()); +} + +boost::property_tree::ptree Panel::DumpAsPropertyTree() +{ + if (!IsLurking()) + { + boost::property_tree::ptree aTree(vcl::Window::DumpAsPropertyTree()); + aTree.put("type", "panel"); + return aTree; + } + else + return boost::property_tree::ptree(); +} + +void Panel::dispose() +{ + mxPanelComponent = nullptr; + + { + Reference<lang::XComponent> xComponent (mxElement, UNO_QUERY); + mxElement = nullptr; + if (xComponent.is()) + xComponent->dispose(); + } + + { + Reference<lang::XComponent> xComponent = GetElementWindow(); + if (xComponent.is()) + xComponent->dispose(); + } + + mpTitleBar.disposeAndClear(); + + vcl::Window::dispose(); +} + +VclPtr<PanelTitleBar> const & Panel::GetTitleBar() const +{ + return mpTitleBar; +} + +void Panel::SetUIElement (const Reference<ui::XUIElement>& rxElement) +{ + mxElement = rxElement; + if (mxElement.is()) + { + mxPanelComponent.set(mxElement->getRealInterface(), UNO_QUERY); + } +} + +void Panel::SetExpanded (const bool bIsExpanded) +{ + SidebarController* pSidebarController = SidebarController::GetSidebarControllerForFrame(mxFrame); + + if (mbIsExpanded == bIsExpanded) + return; + + mbIsExpanded = bIsExpanded; + maDeckLayoutTrigger(); + + if (maContextAccess && pSidebarController) + { + pSidebarController->GetResourceManager()->StorePanelExpansionState( + msPanelId, + bIsExpanded, + maContextAccess()); + } +} + +bool Panel::HasIdPredicate (const OUString& rsId) const +{ + return msPanelId == rsId; +} + +void Panel::Resize() +{ + Window::Resize(); + + // Forward new size to window of XUIElement. + Reference<awt::XWindow> xElementWindow (GetElementWindow()); + if(xElementWindow.is()) + { + const Size aSize(GetSizePixel()); + xElementWindow->setPosSize(0, 0, aSize.Width(), aSize.Height(), + awt::PosSize::POSSIZE); + } +} + +void Panel::DataChanged (const DataChangedEvent&) +{ + Invalidate(); +} + +Reference<awt::XWindow> Panel::GetElementWindow() +{ + if (mxElement.is()) + { + Reference<ui::XToolPanel> xToolPanel(mxElement->getRealInterface(), UNO_QUERY); + if (xToolPanel.is()) + return xToolPanel->getWindow(); + } + + return nullptr; +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/PanelDescriptor.cxx b/sfx2/source/sidebar/PanelDescriptor.cxx new file mode 100644 index 000000000..bdbec773f --- /dev/null +++ b/sfx2/source/sidebar/PanelDescriptor.cxx @@ -0,0 +1,62 @@ +/* -*- 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 <sidebar/PanelDescriptor.hxx> + +namespace sfx2::sidebar { + +PanelDescriptor::PanelDescriptor() + : msTitle(), + mbIsTitleBarOptional(false), + msId(), + msDeckId(), + msTitleBarIconURL(), + msHighContrastTitleBarIconURL(), + maContextList(), + msImplementationURL(), + mnOrderIndex(10000), // Default value as defined in Sidebar.xcs + mbShowForReadOnlyDocuments(false), + mbWantsCanvas(false), + mbExperimental(false) +{ +} + +PanelDescriptor::PanelDescriptor (const PanelDescriptor& rOther) + : msTitle(rOther.msTitle), + mbIsTitleBarOptional(rOther.mbIsTitleBarOptional), + msId(rOther.msId), + msDeckId(rOther.msDeckId), + msTitleBarIconURL(rOther.msTitleBarIconURL), + msHighContrastTitleBarIconURL(rOther.msHighContrastTitleBarIconURL), + maContextList(rOther.maContextList), + msImplementationURL(rOther.msImplementationURL), + mnOrderIndex(rOther.mnOrderIndex), + mbShowForReadOnlyDocuments(rOther.mbShowForReadOnlyDocuments), + mbWantsCanvas(rOther.mbWantsCanvas), + mbExperimental(rOther.mbExperimental) +{ +} + +PanelDescriptor::~PanelDescriptor() +{ +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/PanelLayout.cxx b/sfx2/source/sidebar/PanelLayout.cxx new file mode 100644 index 000000000..6a3338192 --- /dev/null +++ b/sfx2/source/sidebar/PanelLayout.cxx @@ -0,0 +1,121 @@ +/* -*- 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/. + */ + +#include <sfx2/sidebar/SidebarController.hxx> +#include <sfx2/sidebar/TabBar.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> +#include <vcl/layout.hxx> +#include <vcl/accel.hxx> + +using namespace sfx2::sidebar; + +PanelLayout::PanelLayout(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription, + const css::uno::Reference<css::frame::XFrame> &rFrame) + : Control(pParent) + , m_bInClose(false) + , mxFrame(rFrame) +{ + m_aPanelLayoutIdle.SetPriority(TaskPriority::RESIZE); + m_aPanelLayoutIdle.SetInvokeHandler( LINK( this, PanelLayout, ImplHandlePanelLayoutTimerHdl ) ); + m_aPanelLayoutIdle.SetDebugName("sfx2::PanelLayout m_aPanelLayoutIdle"); + + SetStyle(GetStyle() | WB_DIALOGCONTROL); + + // Builder will trigger resize and start Idle + m_xVclContentArea = VclPtr<VclVBox>::Create(this); + m_xVclContentArea->Show(); + m_xBuilder.reset(Application::CreateInterimBuilder(m_xVclContentArea, rUIXMLDescription)); + m_xContainer = m_xBuilder->weld_container(rID); +} + +PanelLayout::~PanelLayout() +{ + disposeOnce(); +} + +void PanelLayout::dispose() +{ + m_bInClose = true; + m_aPanelLayoutIdle.Stop(); + m_xContainer.reset(); + m_xBuilder.reset(); + m_xVclContentArea.disposeAndClear(); + Control::dispose(); +} + +Size PanelLayout::GetOptimalSize() const +{ + Size aSize = m_xContainer->get_preferred_size(); + + if (mxFrame) + { + SidebarController* pController + = SidebarController::GetSidebarControllerForFrame(mxFrame); + if (pController) + aSize.setWidth(std::min<long>( + aSize.Width(), (pController->getMaximumWidth() - TabBar::GetDefaultWidth()) + * GetDPIScaleFactor())); + } + + return aSize; +} + +void PanelLayout::queue_resize(StateChangedType /*eReason*/) +{ + if (m_bInClose) + return; + if (m_aPanelLayoutIdle.IsActive()) + return; + InvalidateSizeCache(); + m_aPanelLayoutIdle.Start(); +} + +IMPL_LINK_NOARG( PanelLayout, ImplHandlePanelLayoutTimerHdl, Timer*, void ) +{ + vcl::Window *pChild = GetWindow(GetWindowType::FirstChild); + assert(pChild); + VclContainer::setLayoutAllocation(*pChild, Point(0, 0), GetSizePixel()); +} + +void PanelLayout::setPosSizePixel(long nX, long nY, long nWidth, long nHeight, PosSizeFlags nFlags) +{ + bool bCanHandleSmallerWidth = false; + bool bCanHandleSmallerHeight = false; + + vcl::Window *pChild = GetWindow(GetWindowType::FirstChild); + + if (pChild->GetType() == WindowType::SCROLLWINDOW) + { + WinBits nStyle = pChild->GetStyle(); + if (nStyle & (WB_AUTOHSCROLL | WB_HSCROLL)) + bCanHandleSmallerWidth = true; + if (nStyle & (WB_AUTOVSCROLL | WB_VSCROLL)) + bCanHandleSmallerHeight = true; + } + + Size aSize(GetOptimalSize()); + if (!bCanHandleSmallerWidth) + nWidth = std::max(nWidth,aSize.Width()); + if (!bCanHandleSmallerHeight) + nHeight = std::max(nHeight,aSize.Height()); + + Control::setPosSizePixel(nX, nY, nWidth, nHeight, nFlags); + + if (nFlags & PosSizeFlags::Size) + VclContainer::setLayoutAllocation(*pChild, Point(0, 0), Size(nWidth, nHeight)); +} + +bool PanelLayout::EventNotify(NotifyEvent& rNEvt) +{ + if (rNEvt.GetType() == MouseNotifyEvent::COMMAND) + Accelerator::ToggleMnemonicsOnHierarchy(*rNEvt.GetCommandEvent(), this); + return Control::EventNotify( rNEvt ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/PanelTitleBar.cxx b/sfx2/source/sidebar/PanelTitleBar.cxx new file mode 100644 index 000000000..e8613f6f9 --- /dev/null +++ b/sfx2/source/sidebar/PanelTitleBar.cxx @@ -0,0 +1,207 @@ +/* -*- 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 <sidebar/PanelTitleBar.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/strings.hrc> +#include <sidebar/Paint.hxx> +#include <sfx2/sidebar/Panel.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sidebar/ControllerFactory.hxx> +#include <sidebar/Tools.hxx> +#include <vcl/event.hxx> +#include <vcl/image.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/diagnose_ex.h> + +#include <com/sun/star/frame/XDispatch.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +static const sal_Int32 gaLeftIconPadding (5); +static const sal_Int32 gaRightIconPadding (5); + +PanelTitleBar::PanelTitleBar(const OUString& rsTitle, + vcl::Window* pParentWindow, + Panel* pPanel) + : TitleBar(rsTitle, pParentWindow, GetBackgroundPaint()), + mbIsLeftButtonDown(false), + mpPanel(pPanel), + mxFrame(), + msMoreOptionsCommand() +{ + OSL_ASSERT(mpPanel != nullptr); + +#ifdef DEBUG + SetText(OUString("PanelTitleBar")); +#endif +} + +PanelTitleBar::~PanelTitleBar() +{ + disposeOnce(); +} + +void PanelTitleBar::dispose() +{ + mpPanel.clear(); + TitleBar::dispose(); +} + +void PanelTitleBar::SetMoreOptionsCommand(const OUString& rsCommandName, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + const css::uno::Reference<css::frame::XController>& rxController) +{ + if (rsCommandName == msMoreOptionsCommand) + return; + + if (msMoreOptionsCommand.getLength() > 0) + maToolBox->RemoveItem(maToolBox->GetItemPos(mnMenuItemIndex)); + + msMoreOptionsCommand = rsCommandName; + mxFrame = rxFrame; + + if (msMoreOptionsCommand.getLength() <= 0) + return; + + maToolBox->InsertItem( + mnMenuItemIndex, + Theme::GetImage(Theme::Image_PanelMenu)); + Reference<frame::XToolbarController> xController ( + ControllerFactory::CreateToolBoxController( + maToolBox.get(), + mnMenuItemIndex, + msMoreOptionsCommand, + rxFrame, rxController, + VCLUnoHelper::GetInterface(maToolBox.get()), + 0, true)); + maToolBox->SetController(mnMenuItemIndex, xController); + maToolBox->SetOutStyle(TOOLBOX_STYLE_FLAT); + maToolBox->SetQuickHelpText( + mnMenuItemIndex, + SfxResId(SFX_STR_SIDEBAR_MORE_OPTIONS)); +} + +tools::Rectangle PanelTitleBar::GetTitleArea (const tools::Rectangle& rTitleBarBox) +{ + if (mpPanel != nullptr) + { + Image aImage (mpPanel->IsExpanded() + ? Theme::GetImage(Theme::Image_Expand) + : Theme::GetImage(Theme::Image_Collapse)); + return tools::Rectangle( + aImage.GetSizePixel().Width() + gaLeftIconPadding + gaRightIconPadding, + rTitleBarBox.Top(), + rTitleBarBox.Right(), + rTitleBarBox.Bottom()); + } + else + return rTitleBarBox; +} + +void PanelTitleBar::PaintDecoration (vcl::RenderContext& rRenderContext) +{ + if (mpPanel != nullptr) + { + Image aImage (mpPanel->IsExpanded() + ? Theme::GetImage(Theme::Image_Collapse) + : Theme::GetImage(Theme::Image_Expand)); + const Point aTopLeft(gaLeftIconPadding, + (GetSizePixel().Height() - aImage.GetSizePixel().Height()) / 2); + rRenderContext.DrawImage(aTopLeft, aImage); + } +} + +Paint PanelTitleBar::GetBackgroundPaint() +{ + return Theme::GetPaint(Theme::Paint_PanelTitleBarBackground); +} + +void PanelTitleBar::HandleToolBoxItemClick (const sal_uInt16 nItemIndex) +{ + if (nItemIndex != mnMenuItemIndex) + return; + + if (msMoreOptionsCommand.getLength() <= 0) + return; + + try + { + const util::URL aURL (Tools::GetURL(msMoreOptionsCommand)); + Reference<frame::XDispatch> xDispatch (Tools::GetDispatch(mxFrame, aURL)); + if (xDispatch.is()) + xDispatch->dispatch(aURL, Sequence<beans::PropertyValue>()); + } + catch(Exception const &) + { + DBG_UNHANDLED_EXCEPTION("sfx"); + } +} + +Reference<accessibility::XAccessible> PanelTitleBar::CreateAccessible() +{ + SetAccessibleName(msTitle); + SetAccessibleDescription(msTitle); + return TitleBar::CreateAccessible(); +} + +void PanelTitleBar::MouseButtonDown (const MouseEvent& rMouseEvent) +{ + if (rMouseEvent.IsLeft()) + { + mbIsLeftButtonDown = true; + CaptureMouse(); + } +} + +void PanelTitleBar::MouseButtonUp (const MouseEvent& rMouseEvent) +{ + if (IsMouseCaptured()) + ReleaseMouse(); + + if (rMouseEvent.IsLeft()) + { + if (mbIsLeftButtonDown) + { + if (mpPanel != nullptr) + { + mpPanel->SetExpanded( ! mpPanel->IsExpanded()); + Invalidate(); + GrabFocus(); + } + } + } + if (mbIsLeftButtonDown) + mbIsLeftButtonDown = false; +} + +void PanelTitleBar::DataChanged (const DataChangedEvent& rEvent) +{ + maToolBox->SetItemImage( + mnMenuItemIndex, + Theme::GetImage(Theme::Image_PanelMenu)); + TitleBar::DataChanged(rEvent); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/ResourceManager.cxx b/sfx2/source/sidebar/ResourceManager.cxx new file mode 100644 index 000000000..f3440e6dc --- /dev/null +++ b/sfx2/source/sidebar/ResourceManager.cxx @@ -0,0 +1,789 @@ +/* -*- 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 <sidebar/DeckDescriptor.hxx> +#include <sidebar/PanelDescriptor.hxx> +#include <sfx2/sidebar/ResourceManager.hxx> +#include <sidebar/Tools.hxx> + +#include <officecfg/Office/UI/Sidebar.hxx> +#include <unotools/confignode.hxx> +#include <comphelper/lok.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/namedvaluecollection.hxx> +#include <comphelper/sequence.hxx> +#include <comphelper/types.hxx> + +#include <tools/diagnose_ex.h> +#include <sal/log.hxx> +#include <vcl/EnumContext.hxx> + +#include <com/sun/star/frame/ModuleManager.hpp> +#include <com/sun/star/ui/XSidebarPanel.hpp> +#include <com/sun/star/ui/XUpdateModel.hpp> + +#include <map> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +namespace +{ + +OUString getString(utl::OConfigurationNode const & aNode, const char* pNodeName) +{ + return comphelper::getString(aNode.getNodeValue(pNodeName)); +} +sal_Int32 getInt32(utl::OConfigurationNode const & aNode, const char* pNodeName) +{ + return comphelper::getINT32(aNode.getNodeValue(pNodeName)); +} +bool getBool(utl::OConfigurationNode const & aNode, const char* pNodeName) +{ + return comphelper::getBOOL(aNode.getNodeValue(pNodeName)); +} + +css::uno::Sequence<OUString> BuildContextList (const ContextList& rContextList) +{ + const ::std::vector<ContextList::Entry>& entries = rContextList.GetEntries(); + + css::uno::Sequence<OUString> result(entries.size()); + long i = 0; + + for (auto const& entry : entries) + { + OUString appName = entry.maContext.msApplication; + OUString contextName = entry.maContext.msContext; + OUString menuCommand = entry.msMenuCommand; + + OUString visibility; + if (entry.mbIsInitiallyVisible) + visibility = "visible"; + else + visibility = "hidden"; + + OUString element = appName + ", " + contextName +", " + visibility; + + if (!menuCommand.isEmpty()) + element += ", "+menuCommand; + + result[i] = element; + + ++i; + } + + return result; + +} + +} //end anonymous namespace + +ResourceManager::ResourceManager() + : maDecks(), + maPanels(), + maProcessedApplications(), + maMiscOptions() +{ + ReadDeckList(); + ReadPanelList(); + ReadLastActive(); +} + +ResourceManager::~ResourceManager() +{ +} + +void ResourceManager::InitDeckContext(const Context& rContext) +{ + for (auto const& deck : maDecks) + { + const ContextList::Entry* pMatchingEntry = deck->maContextList.GetMatch(rContext); + + bool bIsEnabled; + if (pMatchingEntry) + bIsEnabled = pMatchingEntry->mbIsInitiallyVisible; + else + bIsEnabled = false; + + deck->mbIsEnabled = bIsEnabled; + } +} + +std::shared_ptr<DeckDescriptor> ResourceManager::ImplGetDeckDescriptor(const OUString& rsDeckId) const +{ + for (auto const& deck : maDecks) + { + if (deck->mbExperimental && !maMiscOptions.IsExperimentalMode()) + continue; + if (deck->msId == rsDeckId) + return deck; + } + return nullptr; +} + +std::shared_ptr<DeckDescriptor> ResourceManager::GetDeckDescriptor(const OUString& rsDeckId) const +{ + return ImplGetDeckDescriptor( rsDeckId ); +} + +std::shared_ptr<PanelDescriptor> ResourceManager::ImplGetPanelDescriptor(const OUString& rsPanelId) const +{ + for (auto const& panel : maPanels) + { + if (panel->msId == rsPanelId) + return panel; + } + return nullptr; +} + +std::shared_ptr<PanelDescriptor> ResourceManager::GetPanelDescriptor(const OUString& rsPanelId) const +{ + return ImplGetPanelDescriptor( rsPanelId ); +} + +const ResourceManager::DeckContextDescriptorContainer& ResourceManager::GetMatchingDecks ( + DeckContextDescriptorContainer& rDecks, + const Context& rContext, + const bool bIsDocumentReadOnly, + const Reference<frame::XController>& rxController) +{ + ReadLegacyAddons(rxController); + + std::multimap<sal_Int32,DeckContextDescriptor> aOrderedIds; + for (auto const& deck : maDecks) + { + if (deck->mbExperimental && !maMiscOptions.IsExperimentalMode()) + continue; + + const DeckDescriptor& rDeckDescriptor (*deck); + if (rDeckDescriptor.maContextList.GetMatch(rContext) == nullptr) + continue; + + DeckContextDescriptor aDeckContextDescriptor; + aDeckContextDescriptor.msId = rDeckDescriptor.msId; + + aDeckContextDescriptor.mbIsEnabled = (! bIsDocumentReadOnly || IsDeckEnabled(rDeckDescriptor.msId, rContext, rxController) ) + && rDeckDescriptor.mbIsEnabled; + + + aOrderedIds.emplace(rDeckDescriptor.mnOrderIndex, aDeckContextDescriptor); + } + + for (auto const& orderId : aOrderedIds) + { + rDecks.push_back(orderId.second); + } + + return rDecks; +} + +const ResourceManager::PanelContextDescriptorContainer& ResourceManager::GetMatchingPanels ( + PanelContextDescriptorContainer& rPanelIds, + const Context& rContext, + const OUString& sDeckId, + const Reference<frame::XController>& rxController) +{ + ReadLegacyAddons(rxController); + + std::multimap<sal_Int32, PanelContextDescriptor> aOrderedIds; + for (auto const& panel : maPanels) + { + const PanelDescriptor& rPanelDescriptor (*panel); + if (rPanelDescriptor.mbExperimental && !maMiscOptions.IsExperimentalMode()) + continue; + if ( rPanelDescriptor.msDeckId != sDeckId ) + continue; + + const ContextList::Entry* pEntry = rPanelDescriptor.maContextList.GetMatch(rContext); + if (pEntry == nullptr) + continue; + + PanelContextDescriptor aPanelContextDescriptor; + aPanelContextDescriptor.msId = rPanelDescriptor.msId; + aPanelContextDescriptor.msMenuCommand = pEntry->msMenuCommand; + aPanelContextDescriptor.mbIsInitiallyVisible = pEntry->mbIsInitiallyVisible; + aPanelContextDescriptor.mbShowForReadOnlyDocuments = rPanelDescriptor.mbShowForReadOnlyDocuments; + aOrderedIds.emplace(rPanelDescriptor.mnOrderIndex, aPanelContextDescriptor); + } + + for (auto const& orderId : aOrderedIds) + { + rPanelIds.push_back(orderId.second); + } + + return rPanelIds; +} + +const OUString& ResourceManager::GetLastActiveDeck( const Context& rContext ) +{ + if( maLastActiveDecks.find( rContext.msApplication ) == maLastActiveDecks.end()) + return maLastActiveDecks["any"]; + else + return maLastActiveDecks[rContext.msApplication]; +} + +void ResourceManager::SetLastActiveDeck( const Context& rContext, const OUString &rsDeckId ) +{ + maLastActiveDecks[rContext.msApplication] = rsDeckId; +} + +void ResourceManager::ReadDeckList() +{ + const utl::OConfigurationTreeRoot aDeckRootNode( + comphelper::getProcessComponentContext(), + "org.openoffice.Office.UI.Sidebar/Content/DeckList", + false); + if (!aDeckRootNode.isValid()) + return; + + const Sequence<OUString> aDeckNodeNames (aDeckRootNode.getNodeNames()); + maDecks.clear(); + for (const OUString& aDeckName : aDeckNodeNames) + { + if (comphelper::LibreOfficeKit::isActive()) + { + // Hide these decks in LOK as they aren't fully functional. + if (aDeckName == "GalleryDeck" || aDeckName == "NavigatorDeck" + || aDeckName == "StyleListDeck") + continue; + } + + const utl::OConfigurationNode aDeckNode(aDeckRootNode.openNode(aDeckName)); + if (!aDeckNode.isValid()) + continue; + + maDecks.push_back(std::make_shared<DeckDescriptor>()); + DeckDescriptor& rDeckDescriptor (*maDecks.back()); + + rDeckDescriptor.msTitle = getString(aDeckNode, "Title"); + rDeckDescriptor.msId = getString(aDeckNode, "Id"); + rDeckDescriptor.msIconURL = getString(aDeckNode, "IconURL"); + rDeckDescriptor.msHighContrastIconURL = getString(aDeckNode, "HighContrastIconURL"); + rDeckDescriptor.msTitleBarIconURL = getString(aDeckNode, "TitleBarIconURL"); + rDeckDescriptor.msHighContrastTitleBarIconURL = getString(aDeckNode, "HighContrastTitleBarIconURL"); + rDeckDescriptor.msHelpText = rDeckDescriptor.msTitle; + rDeckDescriptor.mnOrderIndex = getInt32(aDeckNode, "OrderIndex"); + rDeckDescriptor.mbExperimental = getBool(aDeckNode, "IsExperimental"); + + rDeckDescriptor.msNodeName = aDeckName; + + ReadContextList( + aDeckNode, + rDeckDescriptor.maContextList, + OUString()); + + } +} + +void ResourceManager::SaveDecksSettings(const Context& rContext) +{ + for (auto const& deck : maDecks) + { + const ContextList::Entry* pMatchingEntry = deck->maContextList.GetMatch(rContext); + if (pMatchingEntry) + { + std::shared_ptr<DeckDescriptor> xDeckDesc = GetDeckDescriptor(deck->msId); + if (xDeckDesc) + SaveDeckSettings(xDeckDesc.get()); + } + + } +} + +void ResourceManager::SaveDeckSettings(const DeckDescriptor* pDeckDesc) +{ + const utl::OConfigurationTreeRoot aDeckRootNode( + comphelper::getProcessComponentContext(), + "org.openoffice.Office.UI.Sidebar/Content/DeckList", + true); + if (!aDeckRootNode.isValid()) + return; + + // save deck settings + + ::uno::Sequence< OUString > sContextList = BuildContextList(pDeckDesc->maContextList); + + utl::OConfigurationNode aDeckNode (aDeckRootNode.openNode(pDeckDesc->msNodeName)); + + css::uno::Any aTitle(makeAny(pDeckDesc->msTitle)); + css::uno::Any aOrder(makeAny(pDeckDesc->mnOrderIndex)); + css::uno::Any aContextList(makeAny(sContextList)); + + bool bChanged = false; + if (aTitle != aDeckNode.getNodeValue("Title")) + { + aDeckNode.setNodeValue("Title", aTitle); + bChanged = true; + } + if (aOrder != aDeckNode.getNodeValue("OrderIndex")) + { + aDeckNode.setNodeValue("OrderIndex", aOrder); + bChanged = true; + } + if (aContextList != aDeckNode.getNodeValue("ContextList")) + { + aDeckNode.setNodeValue("ContextList", aContextList); + bChanged = true; + } + + if (bChanged) + aDeckRootNode.commit(); + + // save panel settings + + const utl::OConfigurationTreeRoot aPanelRootNode( + comphelper::getProcessComponentContext(), + "org.openoffice.Office.UI.Sidebar/Content/PanelList", + true); + + if (!aPanelRootNode.isValid()) + return; + + if (!pDeckDesc->mpDeck) // the deck has not been edited + return; + + SharedPanelContainer rPanels = pDeckDesc->mpDeck->GetPanels(); + + bChanged = false; + for (auto const& panel : rPanels) + { + OUString panelId = panel->GetId(); + std::shared_ptr<PanelDescriptor> xPanelDesc = GetPanelDescriptor(panelId); + + ::uno::Sequence< OUString > sPanelContextList = BuildContextList(xPanelDesc->maContextList); + + utl::OConfigurationNode aPanelNode (aPanelRootNode.openNode(xPanelDesc->msNodeName)); + + aTitle <<= xPanelDesc->msTitle; + aOrder <<= xPanelDesc->mnOrderIndex; + aContextList <<= sPanelContextList; + + if (aTitle != aPanelNode.getNodeValue("Title")) + { + aPanelNode.setNodeValue("Title", aTitle); + bChanged = true; + } + if (aOrder != aPanelNode.getNodeValue("OrderIndex")) + { + aPanelNode.setNodeValue("OrderIndex", aOrder); + bChanged = true; + } + if (aContextList != aPanelNode.getNodeValue("ContextList")) + { + aPanelNode.setNodeValue("ContextList", aContextList); + bChanged = true; + } + } + + if (bChanged) + aPanelRootNode.commit(); +} + +void ResourceManager::SaveLastActiveDeck(const Context& rContext, const OUString& rActiveDeck) +{ + maLastActiveDecks[rContext.msApplication] = rActiveDeck; + + std::set<OUString> aLastActiveDecks; + for ( auto const & rEntry : maLastActiveDecks ) + aLastActiveDecks.insert( rEntry.first + "," + rEntry.second); + + std::shared_ptr<comphelper::ConfigurationChanges> cfgWriter( comphelper::ConfigurationChanges::create() ); + + officecfg::Office::UI::Sidebar::Content::LastActiveDeck::set(comphelper::containerToSequence(aLastActiveDecks), cfgWriter); + cfgWriter->commit(); + +} + +void ResourceManager::ReadPanelList() +{ + const utl::OConfigurationTreeRoot aPanelRootNode( + comphelper::getProcessComponentContext(), + "org.openoffice.Office.UI.Sidebar/Content/PanelList", + false); + if (!aPanelRootNode.isValid()) + return; + + const Sequence<OUString> aPanelNodeNames (aPanelRootNode.getNodeNames()); + maPanels.clear(); + for (const auto& rPanelNodeName : aPanelNodeNames) + { + const utl::OConfigurationNode aPanelNode (aPanelRootNode.openNode(rPanelNodeName)); + if (!aPanelNode.isValid()) + continue; + + maPanels.push_back(std::make_shared<PanelDescriptor>()); + PanelDescriptor& rPanelDescriptor(*maPanels.back()); + + rPanelDescriptor.msTitle = getString(aPanelNode, "Title"); + rPanelDescriptor.mbIsTitleBarOptional = getBool(aPanelNode, "TitleBarIsOptional"); + rPanelDescriptor.msId = getString(aPanelNode, "Id"); + rPanelDescriptor.msDeckId = getString(aPanelNode, "DeckId"); + rPanelDescriptor.msTitleBarIconURL = getString(aPanelNode, "TitleBarIconURL"); + rPanelDescriptor.msHighContrastTitleBarIconURL = getString(aPanelNode, "HighContrastTitleBarIconURL"); + rPanelDescriptor.msImplementationURL = getString(aPanelNode, "ImplementationURL"); + rPanelDescriptor.mnOrderIndex = getInt32(aPanelNode, "OrderIndex"); + rPanelDescriptor.mbShowForReadOnlyDocuments = getBool(aPanelNode, "ShowForReadOnlyDocument"); + rPanelDescriptor.mbWantsCanvas = getBool(aPanelNode, "WantsCanvas"); + rPanelDescriptor.mbExperimental = getBool(aPanelNode, "IsExperimental"); + const OUString sDefaultMenuCommand(getString(aPanelNode, "DefaultMenuCommand")); + + rPanelDescriptor.msNodeName = rPanelNodeName; + + ReadContextList(aPanelNode, rPanelDescriptor.maContextList, sDefaultMenuCommand); + } +} + +void ResourceManager::ReadLastActive() +{ + const Sequence <OUString> aLastActive (officecfg::Office::UI::Sidebar::Content::LastActiveDeck::get()); + + for (const auto& rDeckInfo : aLastActive) + { + sal_Int32 nCharIdx = rDeckInfo.lastIndexOf(','); + if ( nCharIdx <= 0 || (nCharIdx == rDeckInfo.getLength() - 1) ) + { + SAL_WARN("sfx.sidebar", "Expecting 2 values separated by comma"); + continue; + } + + const OUString sApplicationName = rDeckInfo.copy( 0, nCharIdx ); + vcl::EnumContext::Application eApplication (vcl::EnumContext::GetApplicationEnum(sApplicationName)); + const OUString sLastUsed = rDeckInfo.copy( nCharIdx + 1 ); + + // guard against garbage in place of application + if (eApplication != vcl::EnumContext::Application::NONE) + maLastActiveDecks.insert( std::make_pair(sApplicationName, sLastUsed ) ); + } +} + +void ResourceManager::ReadContextList ( + const utl::OConfigurationNode& rParentNode, + ContextList& rContextList, + const OUString& rsDefaultMenuCommand) +{ + const Any aValue = rParentNode.getNodeValue("ContextList"); + Sequence<OUString> aValues; + if (!(aValue >>= aValues)) + return; + + for (const OUString& sValue : std::as_const(aValues)) + { + sal_Int32 nCharacterIndex (0); + const OUString sApplicationName (sValue.getToken(0, ',', nCharacterIndex).trim()); + if (nCharacterIndex < 0) + { + if (sApplicationName.getLength() == 0) + { + // This is a valid case: in the XML file the separator + // was used as terminator. Using it in the last line + // creates an additional but empty entry. + break; + } + else + { + OSL_FAIL("expecting three or four values per ContextList entry, separated by comma"); + continue; + } + } + + const OUString sContextName(sValue.getToken(0, ',', nCharacterIndex).trim()); + if (nCharacterIndex < 0) + { + OSL_FAIL("expecting three or four values per ContextList entry, separated by comma"); + continue; + } + + const OUString sInitialState(sValue.getToken(0, ',', nCharacterIndex).trim()); + + // The fourth argument is optional. + const OUString sMenuCommandOverride( + nCharacterIndex < 0 + ? OUString() + : sValue.getToken(0, ',', nCharacterIndex).trim()); + + const OUString sMenuCommand( + sMenuCommandOverride.getLength() > 0 + ? (sMenuCommandOverride == "none" + ? OUString() + : sMenuCommandOverride) + : rsDefaultMenuCommand); + + // Setup a list of application enums. Note that the + // application name may result in more than one value (eg + // DrawImpress will result in two enums, one for Draw and one + // for Impress). + std::vector<vcl::EnumContext::Application> aApplications; + vcl::EnumContext::Application eApplication (vcl::EnumContext::GetApplicationEnum(sApplicationName)); + + if (eApplication == vcl::EnumContext::Application::NONE + && sApplicationName != vcl::EnumContext::GetApplicationName(vcl::EnumContext::Application::NONE)) + { + // Handle some special names: abbreviations that make + // context descriptions more readable. + if (sApplicationName == "Writer") + aApplications.push_back(vcl::EnumContext::Application::Writer); + else if (sApplicationName == "Calc") + aApplications.push_back(vcl::EnumContext::Application::Calc); + else if (sApplicationName == "Draw") + aApplications.push_back(vcl::EnumContext::Application::Draw); + else if (sApplicationName == "Impress") + aApplications.push_back(vcl::EnumContext::Application::Impress); + else if (sApplicationName == "Chart") + aApplications.push_back(vcl::EnumContext::Application::Chart); + else if (sApplicationName == "DrawImpress") + { + // A special case among the special names: it is + // common to use the same context descriptions for + // both Draw and Impress. This special case helps to + // avoid duplication in the .xcu file. + aApplications.push_back(vcl::EnumContext::Application::Draw); + aApplications.push_back(vcl::EnumContext::Application::Impress); + } + else if (sApplicationName == "WriterVariants") + { + // Another special case for all Writer variants. + aApplications.push_back(vcl::EnumContext::Application::Writer); + aApplications.push_back(vcl::EnumContext::Application::WriterGlobal); + aApplications.push_back(vcl::EnumContext::Application::WriterWeb); + aApplications.push_back(vcl::EnumContext::Application::WriterXML); + aApplications.push_back(vcl::EnumContext::Application::WriterForm); + aApplications.push_back(vcl::EnumContext::Application::WriterReport); + } + else + { + SAL_WARN("sfx.sidebar", "application name " << sApplicationName << " not recognized"); + continue; + } + } + else + { + // No conversion of the application name necessary. + aApplications.push_back(eApplication); + } + + // Setup the actual context enum. + const vcl::EnumContext::Context eContext (vcl::EnumContext::GetContextEnum(sContextName)); + if (eContext == vcl::EnumContext::Context::Unknown) + { + SAL_WARN("sfx.sidebar", "context name " << sContextName << " not recognized"); + continue; + } + + // Setup the flag that controls whether a deck/pane is + // initially visible/expanded. + bool bIsInitiallyVisible; + if (sInitialState == "visible") + bIsInitiallyVisible = true; + else if (sInitialState == "hidden") + bIsInitiallyVisible = false; + else + { + OSL_FAIL("unrecognized state"); + continue; + } + + + // Add context descriptors. + for (auto const& application : aApplications) + { + if (application != vcl::EnumContext::Application::NONE) + { + rContextList.AddContextDescription( + Context( + vcl::EnumContext::GetApplicationName(application), + vcl::EnumContext::GetContextName(eContext)), + bIsInitiallyVisible, + sMenuCommand); + } + } + } +} + +void ResourceManager::ReadLegacyAddons (const Reference<frame::XController>& rxController) +{ + // Get module name for given frame. + OUString sModuleName (Tools::GetModuleName(rxController)); + if (sModuleName.getLength() == 0) + return; + if (maProcessedApplications.find(sModuleName) != maProcessedApplications.end()) + { + // Addons for this application have already been read. + // There is nothing more to do. + return; + } + + // Mark module as processed. Even when there is an error that + // prevents the configuration data from being read, this error + // will not be triggered a second time. + maProcessedApplications.insert(sModuleName); + + // Get access to the configuration root node for the application. + utl::OConfigurationTreeRoot aLegacyRootNode (GetLegacyAddonRootNode(sModuleName)); + if (!aLegacyRootNode.isValid()) + return; + + // Process child nodes. + std::vector<OUString> aMatchingNodeNames; + GetToolPanelNodeNames(aMatchingNodeNames, aLegacyRootNode); + const sal_Int32 nCount (aMatchingNodeNames.size()); + for (sal_Int32 nReadIndex(0); nReadIndex<nCount; ++nReadIndex) + { + const OUString& rsNodeName (aMatchingNodeNames[nReadIndex]); + const utl::OConfigurationNode aChildNode (aLegacyRootNode.openNode(rsNodeName)); + if (!aChildNode.isValid()) + continue; + + if ( rsNodeName == "private:resource/toolpanel/DrawingFramework/CustomAnimations" || + rsNodeName == "private:resource/toolpanel/DrawingFramework/Layouts" || + rsNodeName == "private:resource/toolpanel/DrawingFramework/MasterPages" || + rsNodeName == "private:resource/toolpanel/DrawingFramework/SlideTransitions" || + rsNodeName == "private:resource/toolpanel/DrawingFramework/TableDesign" ) + continue; + + maDecks.push_back(std::make_shared<DeckDescriptor>()); + DeckDescriptor& rDeckDescriptor(*maDecks.back()); + rDeckDescriptor.msTitle = getString(aChildNode, "UIName"); + rDeckDescriptor.msId = rsNodeName; + rDeckDescriptor.msIconURL = getString(aChildNode, "ImageURL"); + rDeckDescriptor.msHighContrastIconURL = rDeckDescriptor.msIconURL; + rDeckDescriptor.msTitleBarIconURL.clear(); + rDeckDescriptor.msHighContrastTitleBarIconURL.clear(); + rDeckDescriptor.msHelpText = rDeckDescriptor.msTitle; + rDeckDescriptor.mbIsEnabled = true; + rDeckDescriptor.mnOrderIndex = 100000 + nReadIndex; + rDeckDescriptor.maContextList.AddContextDescription(Context(sModuleName, "any"), true, OUString()); + + maPanels.push_back(std::make_shared<PanelDescriptor>()); + PanelDescriptor& rPanelDescriptor(*maPanels.back()); + rPanelDescriptor.msTitle = getString(aChildNode, "UIName"); + rPanelDescriptor.mbIsTitleBarOptional = true; + rPanelDescriptor.msId = rsNodeName; + rPanelDescriptor.msDeckId = rsNodeName; + rPanelDescriptor.msTitleBarIconURL.clear(); + rPanelDescriptor.msHighContrastTitleBarIconURL.clear(); + rPanelDescriptor.msImplementationURL = rsNodeName; + rPanelDescriptor.mnOrderIndex = 100000 + nReadIndex; + rPanelDescriptor.mbShowForReadOnlyDocuments = false; + rPanelDescriptor.mbWantsCanvas = false; + rPanelDescriptor.maContextList.AddContextDescription(Context(sModuleName, "any"), true, OUString()); + } +} + +void ResourceManager::StorePanelExpansionState ( + const OUString& rsPanelId, + const bool bExpansionState, + const Context& rContext) +{ + for (auto const& panel : maPanels) + { + if (panel->msId == rsPanelId) + { + ContextList::Entry* pEntry(panel->maContextList.GetMatch(rContext)); + if (pEntry != nullptr) + pEntry->mbIsInitiallyVisible = bExpansionState; + } + } +} + +utl::OConfigurationTreeRoot ResourceManager::GetLegacyAddonRootNode (const OUString& rsModuleName) +{ + try + { + const Reference<XComponentContext> xContext(comphelper::getProcessComponentContext()); + const Reference<frame::XModuleManager2> xModuleAccess = frame::ModuleManager::create(xContext); + const comphelper::NamedValueCollection aModuleProperties(xModuleAccess->getByName(rsModuleName)); + const OUString sWindowStateRef(aModuleProperties.getOrDefault( + "ooSetupFactoryWindowStateConfigRef", + OUString())); + + OUString aPathComposer = "org.openoffice.Office.UI." + sWindowStateRef + + "/UIElements/States"; + + return utl::OConfigurationTreeRoot(xContext, aPathComposer, false); + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("sfx.sidebar"); + } + + return utl::OConfigurationTreeRoot(); +} + +void ResourceManager::GetToolPanelNodeNames ( + std::vector<OUString>& rMatchingNames, + const utl::OConfigurationTreeRoot& aRoot) +{ + Sequence<OUString> aChildNodeNames (aRoot.getNodeNames()); + std::copy_if(aChildNodeNames.begin(), aChildNodeNames.end(), std::back_inserter(rMatchingNames), + [](const OUString& rChildNodeName) { return rChildNodeName.startsWith( "private:resource/toolpanel/" ); }); +} + +bool ResourceManager::IsDeckEnabled ( + const OUString& rsDeckId, + const Context& rContext, + const Reference<frame::XController>& rxController) +{ + + // Check if any panel that matches the current context can be + // displayed. + PanelContextDescriptorContainer aPanelContextDescriptors; + + GetMatchingPanels(aPanelContextDescriptors, rContext, rsDeckId, rxController); + + for (auto const& panelContextDescriptor : aPanelContextDescriptors) + { + if (panelContextDescriptor.mbShowForReadOnlyDocuments) + return true; + } + return false; +} + +void ResourceManager::UpdateModel(const css::uno::Reference<css::frame::XModel>& xModel) +{ + for (auto const& deck : maDecks) + { + if (!deck->mpDeck) + continue; + + const SharedPanelContainer& rContainer = deck->mpDeck->GetPanels(); + + for (auto const& elem : rContainer) + { + css::uno::Reference<css::ui::XUpdateModel> xPanel(elem->GetPanelComponent(), css::uno::UNO_QUERY); + if (xPanel.is()) // tdf#108814 interface is optional + { + xPanel->updateModel(xModel); + } + } + } +} + +void ResourceManager::disposeDecks() +{ + for (auto const& deck : maDecks) + { + deck->mpDeck.disposeAndClear(); + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/Sidebar.cxx b/sfx2/source/sidebar/Sidebar.cxx new file mode 100644 index 000000000..6f205389e --- /dev/null +++ b/sfx2/source/sidebar/Sidebar.cxx @@ -0,0 +1,93 @@ +/* -*- 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 <sfx2/sidebar/Sidebar.hxx> +#include <sfx2/sidebar/SidebarController.hxx> +#include <sfx2/sidebar/ResourceManager.hxx> +#include <sidebar/PanelDescriptor.hxx> + +using namespace css; + +namespace sfx2::sidebar { + +void Sidebar::ShowPanel ( + const OUString& rsPanelId, + const css::uno::Reference<frame::XFrame>& rxFrame, bool bFocus) +{ + SidebarController* pController = SidebarController::GetSidebarControllerForFrame(rxFrame); + if (!pController) + return; + + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pController->GetResourceManager()->GetPanelDescriptor(rsPanelId); + + if (!xPanelDescriptor) + return; + + // This should be a lot more sophisticated: + // - Make the deck switching asynchronous + // - Make sure to use a context that really shows the panel + + // All that is not necessary for the current use cases so lets + // keep it simple for the time being. + pController->OpenThenSwitchToDeck(xPanelDescriptor->msDeckId); + + if (bFocus) + pController->GetFocusManager().GrabFocusPanel(); +} + +void Sidebar::TogglePanel ( + const OUString& rsPanelId, + const css::uno::Reference<frame::XFrame>& rxFrame) +{ + SidebarController* pController = SidebarController::GetSidebarControllerForFrame(rxFrame); + if (!pController) + return; + + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pController->GetResourceManager()->GetPanelDescriptor(rsPanelId); + + if (!xPanelDescriptor) + return; + + // This should be a lot more sophisticated: + // - Make the deck switching asynchronous + // - Make sure to use a context that really shows the panel + + // All that is not necessary for the current use cases so lets + // keep it simple for the time being. + pController->OpenThenToggleDeck(xPanelDescriptor->msDeckId); +} + +bool Sidebar::IsPanelVisible( + const OUString& rsPanelId, + const css::uno::Reference<frame::XFrame>& rxFrame) +{ + SidebarController* pController = SidebarController::GetSidebarControllerForFrame(rxFrame); + if (!pController) + return false; + + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pController->GetResourceManager()->GetPanelDescriptor(rsPanelId); + if (!xPanelDescriptor) + return false; + + return pController->IsDeckVisible(xPanelDescriptor->msDeckId); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/SidebarChildWindow.cxx b/sfx2/source/sidebar/SidebarChildWindow.cxx new file mode 100644 index 000000000..e75687dfe --- /dev/null +++ b/sfx2/source/sidebar/SidebarChildWindow.cxx @@ -0,0 +1,95 @@ +/* -*- 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 <sfx2/sidebar/TabBar.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/sidebar/SidebarChildWindow.hxx> +#include <sfx2/sidebar/SidebarDockingWindow.hxx> +#include <sfx2/sfxsids.hrc> +#include <helpids.h> +#include <comphelper/lok.hxx> + +namespace sfx2::sidebar { + +SFX_IMPL_DOCKINGWINDOW_WITHID(SidebarChildWindow, SID_SIDEBAR); + +SidebarChildWindow::SidebarChildWindow(vcl::Window* pParentWindow, sal_uInt16 nId, + SfxBindings* pBindings, SfxChildWinInfo* pInfo) + : SfxChildWindow(pParentWindow, nId) +{ + auto pDockWin = VclPtr<SidebarDockingWindow>::Create( + pBindings, *this, pParentWindow, WB_STDDOCKWIN | WB_OWNERDRAWDECORATION | WB_CLIPCHILDREN + | WB_SIZEABLE | WB_3DLOOK | WB_ROLLABLE); + SetWindow(pDockWin); + SetAlignment(SfxChildAlignment::RIGHT); + + pDockWin->SetHelpId(HID_SIDEBAR_WINDOW); + pDockWin->SetOutputSizePixel(Size(GetDefaultWidth(pDockWin), 450)); + + if (pInfo && pInfo->aExtraString.isEmpty() && pInfo->aModule != "sdraw" + && pInfo->aModule != "simpress") + { + // When this is the first start (never had the sidebar open yet), + // default to non-expanded sidebars in Writer and Calc. + // + // HACK: unfortunately I haven't found a clean solution to do + // this, so do it this way: + // + if (!comphelper::LibreOfficeKit::isActive()) + { + pDockWin->SetSizePixel( + Size(TabBar::GetDefaultWidth() * GetWindow()->GetDPIScaleFactor(), + pDockWin->GetSizePixel().Height())); + } + } + + pDockWin->Initialize(pInfo); + + if (comphelper::LibreOfficeKit::isActive()) + { + // Undock sidebar in LOK to allow for resizing freely + // (i.e. when the client window is resized) and collapse + // it so the client can open it on demand. + pDockWin->SetFloatingSize(Size(pDockWin->GetSizePixel().Width() * GetWindow()->GetDPIScaleFactor(), + pDockWin->GetSizePixel().Height())); + pDockWin->SetFloatingMode(true); + } + + SetHideNotDelete(true); + + pDockWin->Show(); +} + +sal_Int32 SidebarChildWindow::GetDefaultWidth(vcl::Window const* pWindow) +{ + if (pWindow != nullptr) + { + // Width of the paragraph panel. + const static sal_Int32 nMaxPropertyPageWidth(146); + + return pWindow->LogicToPixel(Point(nMaxPropertyPageWidth,1), MapMode(MapUnit::MapAppFont)).X() + + TabBar::GetDefaultWidth() * pWindow->GetDPIScaleFactor(); + } + else + return 0; +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/SidebarController.cxx b/sfx2/source/sidebar/SidebarController.cxx new file mode 100644 index 000000000..08606a83f --- /dev/null +++ b/sfx2/source/sidebar/SidebarController.cxx @@ -0,0 +1,1617 @@ +/* -*- 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 <sfx2/sidebar/SidebarController.hxx> +#include <sfx2/sidebar/Deck.hxx> +#include <sidebar/DeckDescriptor.hxx> +#include <sidebar/DeckTitleBar.hxx> +#include <sfx2/sidebar/Panel.hxx> +#include <sidebar/PanelDescriptor.hxx> +#include <sidebar/PanelTitleBar.hxx> +#include <sfx2/sidebar/TabBar.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sfx2/sidebar/SidebarChildWindow.hxx> +#include <sidebar/Tools.hxx> +#include <sfx2/sidebar/SidebarDockingWindow.hxx> +#include <sfx2/sidebar/Context.hxx> + + +#include <sfx2/lokhelper.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/strings.hrc> +#include <framework/ContextChangeEventMultiplexerTunnel.hxx> +#include <vcl/floatwin.hxx> +#include <vcl/fixed.hxx> +#include <vcl/uitest/logger.hxx> +#include <vcl/uitest/eventdescription.hxx> +#include <vcl/svapp.hxx> +#include <splitwin.hxx> +#include <tools/diagnose_ex.h> +#include <tools/link.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/namedvaluecollection.hxx> +#include <comphelper/lok.hxx> +#include <sal/log.hxx> +#include <officecfg/Office/UI/Sidebar.hxx> +#include <LibreOfficeKit/LibreOfficeKitEnums.h> +#include <boost/property_tree/ptree.hpp> +#include <boost/property_tree/json_parser.hpp> + +#include <com/sun/star/awt/XWindowPeer.hpp> +#include <com/sun/star/frame/XDispatch.hpp> +#include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp> +#include <com/sun/star/ui/ContextChangeEventObject.hpp> +#include <com/sun/star/ui/theUIElementFactoryManager.hpp> +#include <com/sun/star/util/URL.hpp> +#include <com/sun/star/rendering/XSpriteCanvas.hpp> + + +using namespace css; +using namespace css::uno; + +namespace +{ + const static char gsReadOnlyCommandName[] = ".uno:EditDoc"; + const static sal_Int32 gnWidthCloseThreshold (70); + const static sal_Int32 gnWidthOpenThreshold (40); + + std::string UnoNameFromDeckId(const OUString& rsDeckId, bool isImpress = false) + { + if (rsDeckId == "SdCustomAnimationDeck") + return ".uno:CustomAnimation"; + + if (rsDeckId == "PropertyDeck") + return isImpress ? ".uno:ModifyPage" : ".uno:Sidebar"; + + if (rsDeckId == "SdLayoutsDeck") + return ".uno:ModifyPage"; + + if (rsDeckId == "SdSlideTransitionDeck") + return ".uno:SlideChangeWindow"; + + if (rsDeckId == "SdAllMasterPagesDeck") + return ".uno:MasterSlidesPanel"; + + if (rsDeckId == "SdMasterPagesDeck") + return ".uno:MasterSlidesPanel"; + + if (rsDeckId == "GalleryDeck") + return ".uno:Gallery"; + + return ""; + } +} + +namespace sfx2::sidebar { + +namespace { + enum MenuId + { + MID_UNLOCK_TASK_PANEL = 1, + MID_LOCK_TASK_PANEL, + MID_HIDE_SIDEBAR, + MID_CUSTOMIZATION, + MID_RESTORE_DEFAULT, + MID_FIRST_PANEL, + MID_FIRST_HIDE = 1000 + }; + + /** When in doubt, show this deck. + */ + static const char gsDefaultDeckId[] = "PropertyDeck"; +} + +SidebarController::SidebarController ( + SidebarDockingWindow* pParentWindow, + const SfxViewFrame* pViewFrame) + : SidebarControllerInterfaceBase(m_aMutex), + mpCurrentDeck(), + mpParentWindow(pParentWindow), + mpViewFrame(pViewFrame), + mxFrame(pViewFrame->GetFrame().GetFrameInterface()), + mpTabBar(VclPtr<TabBar>::Create( + mpParentWindow, + mxFrame, + [this](const OUString& rsDeckId) { return this->OpenThenToggleDeck(rsDeckId); }, + [this](const tools::Rectangle& rButtonBox,const ::std::vector<TabBar::DeckMenuData>& rMenuData) { return this->ShowPopupMenu(rButtonBox,rMenuData); }, + this)), + maCurrentContext(OUString(), OUString()), + maRequestedContext(), + mnRequestedForceFlags(SwitchFlag_NoForce), + mnMaximumSidebarWidth(officecfg::Office::UI::Sidebar::General::MaximumWidth::get()), + msCurrentDeckId(gsDefaultDeckId), + maPropertyChangeForwarder([this](){ return this->BroadcastPropertyChange(); }), + maContextChangeUpdate([this](){ return this->UpdateConfigurations(); }), + mbIsDeckRequestedOpen(), + mbIsDeckOpen(), + mbFloatingDeckClosed(!pParentWindow->IsFloatingMode()), + mnSavedSidebarWidth(pParentWindow->GetSizePixel().Width()), + maFocusManager([this](const Panel& rPanel){ return this->ShowPanel(rPanel); }, + [this](const sal_Int32 nIndex){ return this->IsDeckOpen(nIndex); }), + mxReadOnlyModeDispatch(), + mbIsDocumentReadOnly(false), + mpSplitWindow(nullptr), + mnWidthOnSplitterButtonDown(0), + mpResourceManager() +{ + // Decks and panel collections for this sidebar + mpResourceManager = std::make_unique<ResourceManager>(); +} + +rtl::Reference<SidebarController> SidebarController::create(SidebarDockingWindow* pParentWindow, + const SfxViewFrame* pViewFrame) +{ + rtl::Reference<SidebarController> instance(new SidebarController(pParentWindow, pViewFrame)); + + const css::uno::Reference<css::frame::XFrame>& rxFrame = pViewFrame->GetFrame().GetFrameInterface(); + registerSidebarForFrame(instance.get(), rxFrame->getController()); + rxFrame->addFrameActionListener(instance.get()); + // Listen for window events. + instance->mpParentWindow->AddEventListener(LINK(instance.get(), SidebarController, WindowEventHandler)); + + // Listen for theme property changes. + Theme::GetPropertySet()->addPropertyChangeListener( + "", + static_cast<css::beans::XPropertyChangeListener*>(instance.get())); + + // Get the dispatch object as preparation to listen for changes of + // the read-only state. + const util::URL aURL (Tools::GetURL(gsReadOnlyCommandName)); + instance->mxReadOnlyModeDispatch = Tools::GetDispatch(rxFrame, aURL); + if (instance->mxReadOnlyModeDispatch.is()) + instance->mxReadOnlyModeDispatch->addStatusListener(instance.get(), aURL); + + //first UpdateConfigurations call will SwitchToDeck + + return instance; +} + +SidebarController::~SidebarController() +{ +} + +SidebarController* SidebarController::GetSidebarControllerForFrame ( + const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + uno::Reference<frame::XController> const xController(rxFrame->getController()); + if (!xController.is()) // this may happen during dispose of Draw controller but perhaps it's a bug + { + SAL_WARN("sfx.sidebar", "GetSidebarControllerForFrame: frame has no XController"); + return nullptr; + } + uno::Reference<ui::XContextChangeEventListener> const xListener( + framework::GetFirstListenerWith(xController, + [] (uno::Reference<uno::XInterface> const& xRef) + { return nullptr != dynamic_cast<SidebarController*>(xRef.get()); } + )); + + return dynamic_cast<SidebarController*>(xListener.get()); +} + +void SidebarController::registerSidebarForFrame(SidebarController* pController, const css::uno::Reference<css::frame::XController>& xController) +{ + // Listen for context change events. + css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer ( + css::ui::ContextChangeEventMultiplexer::get( + ::comphelper::getProcessComponentContext())); + xMultiplexer->addContextChangeEventListener( + static_cast<css::ui::XContextChangeEventListener*>(pController), + xController); +} + +void SidebarController::unregisterSidebarForFrame(SidebarController* pController, const css::uno::Reference<css::frame::XController>& xController) +{ + pController->saveDeckState(); + pController->disposeDecks(); + + css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer ( + css::ui::ContextChangeEventMultiplexer::get( + ::comphelper::getProcessComponentContext())); + xMultiplexer->removeContextChangeEventListener( + static_cast<css::ui::XContextChangeEventListener*>(pController), + xController); +} + +void SidebarController::disposeDecks() +{ + SolarMutexGuard aSolarMutexGuard; + + if (comphelper::LibreOfficeKit::isActive()) + { + if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell()) + { + const std::string hide = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication)); + if (!hide.empty()) + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, + (hide + "=false").c_str()); + } + + mpParentWindow->ReleaseLOKNotifier(); + } + + mpCurrentDeck.clear(); + maFocusManager.Clear(); + mpResourceManager->disposeDecks(); +} + +void SAL_CALL SidebarController::disposing() +{ + mpCloseIndicator.disposeAndClear(); + + maFocusManager.Clear(); + mpTabBar.disposeAndClear(); + + saveDeckState(); + + // clear decks + ResourceManager::DeckContextDescriptorContainer aDecks; + + mpResourceManager->GetMatchingDecks ( + aDecks, + GetCurrentContext(), + IsDocumentReadOnly(), + mxFrame->getController()); + + for (const auto& rDeck : aDecks) + { + std::shared_ptr<DeckDescriptor> deckDesc = mpResourceManager->GetDeckDescriptor(rDeck.msId); + + VclPtr<Deck> aDeck = deckDesc->mpDeck; + if (aDeck) + aDeck.disposeAndClear(); + } + + uno::Reference<css::frame::XController> xController = mxFrame->getController(); + if (!xController.is()) + xController = mxCurrentController; + + mxFrame->removeFrameActionListener(this); + unregisterSidebarForFrame(this, xController); + + if (mxReadOnlyModeDispatch.is()) + mxReadOnlyModeDispatch->removeStatusListener(this, Tools::GetURL(gsReadOnlyCommandName)); + if (mpSplitWindow != nullptr) + { + mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler)); + mpSplitWindow = nullptr; + } + + if (mpParentWindow != nullptr) + { + mpParentWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler)); + mpParentWindow = nullptr; + } + + Theme::GetPropertySet()->removePropertyChangeListener( + "", + static_cast<css::beans::XPropertyChangeListener*>(this)); + + maContextChangeUpdate.CancelRequest(); +} + +void SAL_CALL SidebarController::notifyContextChangeEvent (const css::ui::ContextChangeEventObject& rEvent) +{ + // Update to the requested new context asynchronously to avoid + // subtle errors caused by SFX2 which in rare cases can not + // properly handle a synchronous update. + + maRequestedContext = Context( + rEvent.ApplicationName, + rEvent.ContextName); + + if (maRequestedContext != maCurrentContext) + { + mxCurrentController.set(rEvent.Source, css::uno::UNO_QUERY); + maContextChangeUpdate.RequestCall(); + // TODO: this call is redundant but mandatory for unit test to update context on document loading + UpdateConfigurations(); + } +} + +void SAL_CALL SidebarController::disposing (const css::lang::EventObject& ) +{ + dispose(); +} + +void SAL_CALL SidebarController::propertyChange (const css::beans::PropertyChangeEvent& ) +{ + maPropertyChangeForwarder.RequestCall(); +} + +void SAL_CALL SidebarController::statusChanged (const css::frame::FeatureStateEvent& rEvent) +{ + bool bIsReadWrite (true); + if (rEvent.IsEnabled) + rEvent.State >>= bIsReadWrite; + + if (mbIsDocumentReadOnly != !bIsReadWrite) + { + mbIsDocumentReadOnly = !bIsReadWrite; + + // Force the current deck to update its panel list. + if ( ! mbIsDocumentReadOnly) + SwitchToDefaultDeck(); + + mnRequestedForceFlags |= SwitchFlag_ForceSwitch; + maContextChangeUpdate.RequestCall(); + } +} + +void SAL_CALL SidebarController::requestLayout() +{ + sal_Int32 nMinimalWidth = 0; + if (mpCurrentDeck && !mpCurrentDeck->isDisposed()) + { + mpCurrentDeck->RequestLayout(); + nMinimalWidth = mpCurrentDeck->GetMinimalWidth(); + } + RestrictWidth(nMinimalWidth); +} + +void SidebarController::BroadcastPropertyChange() +{ + mpParentWindow->Invalidate(InvalidateFlags::Children); +} + +void SidebarController::NotifyResize() +{ + if (!mpTabBar) + { + OSL_ASSERT(mpTabBar!=nullptr); + return; + } + + vcl::Window* pParentWindow = mpTabBar->GetParent(); + const sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor(); + + const sal_Int32 nWidth (pParentWindow->GetSizePixel().Width()); + const sal_Int32 nHeight (pParentWindow->GetSizePixel().Height()); + + mbIsDeckOpen = (nWidth > nTabBarDefaultWidth); + + if (mnSavedSidebarWidth <= 0) + mnSavedSidebarWidth = nWidth; + + bool bIsDeckVisible; + const bool bIsOpening (nWidth > mnWidthOnSplitterButtonDown); + if (bIsOpening) + bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthOpenThreshold; + else + bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthCloseThreshold; + mbIsDeckRequestedOpen = bIsDeckVisible; + UpdateCloseIndicator(!bIsDeckVisible); + + if (mpCurrentDeck && !mpCurrentDeck->isDisposed()) + { + SfxSplitWindow* pSplitWindow = GetSplitWindow(); + WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WindowAlign::Right; + long nDeckX, nTabX; + if (eAlign == WindowAlign::Left) // attach the Sidebar towards the left-side of screen + { + nDeckX = nTabBarDefaultWidth; + nTabX = 0; + } + else // attach the Sidebar towards the right-side of screen + { + nDeckX = 0; + nTabX = nWidth - nTabBarDefaultWidth; + } + + // Place the deck first. + if (bIsDeckVisible) + { + if (comphelper::LibreOfficeKit::isActive()) + { + // We want to let the layouter use up as much of the + // height as necessary to make sure no scrollbar is + // visible. This only works when there are no greedy + // panes that fill up all available area. So we only + // use this for the PropertyDeck, which has no such + // panes, while most other do. This is fine, since + // it's the PropertyDeck that really has many panes + // that can collapse or expand. For others, limit + // the height to something sensible. + // tdf#130348: Add special case for ChartDeck, too. + const sal_Int32 nExtHeight = (msCurrentDeckId == "PropertyDeck" ? 2000 : + (msCurrentDeckId == "ChartDeck" ? 1200 : 600)); + // No TabBar in LOK (use nWidth in full). + mpCurrentDeck->setPosSizePixel(nDeckX, 0, nWidth, nExtHeight); + } + else + mpCurrentDeck->setPosSizePixel(nDeckX, 0, nWidth - nTabBarDefaultWidth, nHeight); + mpCurrentDeck->Show(); + mpCurrentDeck->RequestLayout(); + } + else + mpCurrentDeck->Hide(); + + // Now place the tab bar. + mpTabBar->setPosSizePixel(nTabX, 0, nTabBarDefaultWidth, nHeight); + if (!comphelper::LibreOfficeKit::isActive()) + mpTabBar->Show(); // Don't show TabBar in LOK. + } + + // Determine if the closer of the deck can be shown. + sal_Int32 nMinimalWidth = 0; + if (mpCurrentDeck && !mpCurrentDeck->isDisposed()) + { + VclPtr<DeckTitleBar> pTitleBar = mpCurrentDeck->GetTitleBar(); + if (pTitleBar && pTitleBar->IsVisible()) + pTitleBar->SetCloserVisible(CanModifyChildWindowWidth()); + nMinimalWidth = mpCurrentDeck->GetMinimalWidth(); + } + + RestrictWidth(nMinimalWidth); + + mpParentWindow->NotifyResize(); +} + +void SidebarController::ProcessNewWidth (const sal_Int32 nNewWidth) +{ + if ( ! mbIsDeckRequestedOpen) + return; + + if (*mbIsDeckRequestedOpen) + { + // Deck became large enough to be shown. Show it. + mnSavedSidebarWidth = nNewWidth; + if (!*mbIsDeckOpen) + RequestOpenDeck(); + } + else + { + // Deck became too small. Close it completely. + // If window is wider than the tab bar then mark the deck as being visible, even when it is not. + // This is to trigger an adjustment of the width to the width of the tab bar. + mbIsDeckOpen = true; + RequestCloseDeck(); + + if (mnWidthOnSplitterButtonDown > TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor()) + mnSavedSidebarWidth = mnWidthOnSplitterButtonDown; + } +} + +void SidebarController::SyncUpdate() +{ + maPropertyChangeForwarder.Sync(); + maContextChangeUpdate.Sync(); +} + +void SidebarController::UpdateConfigurations() +{ + if (maCurrentContext == maRequestedContext + && mnRequestedForceFlags == SwitchFlag_NoForce) + return; + + if ((maCurrentContext.msApplication != "none") && + !maCurrentContext.msApplication.isEmpty()) + { + mpResourceManager->SaveDecksSettings(maCurrentContext); + mpResourceManager->SetLastActiveDeck(maCurrentContext, msCurrentDeckId); + } + + // get last active deck for this application on first update + if (!maRequestedContext.msApplication.isEmpty() && + (maCurrentContext.msApplication != maRequestedContext.msApplication)) + { + OUString sLastActiveDeck = mpResourceManager->GetLastActiveDeck( maRequestedContext ); + if (!sLastActiveDeck.isEmpty()) + msCurrentDeckId = sLastActiveDeck; + } + + maCurrentContext = maRequestedContext; + + mpResourceManager->InitDeckContext(GetCurrentContext()); + + // Find the set of decks that could be displayed for the new context. + ResourceManager::DeckContextDescriptorContainer aDecks; + + css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController(); + + mpResourceManager->GetMatchingDecks ( + aDecks, + maCurrentContext, + mbIsDocumentReadOnly, + xController); + + // Notify the tab bar about the updated set of decks. + mpTabBar->SetDecks(aDecks); + + // Find the new deck. By default that is the same as the old + // one. If that is not set or not enabled, then choose the + // first enabled deck (which is PropertyDeck). + OUString sNewDeckId; + for (const auto& rDeck : aDecks) + { + if (rDeck.mbIsEnabled) + { + if (rDeck.msId == msCurrentDeckId) + { + sNewDeckId = msCurrentDeckId; + break; + } + else if (sNewDeckId.getLength() == 0) + sNewDeckId = rDeck.msId; + } + } + + if (sNewDeckId.getLength() == 0) + { + // We did not find a valid deck. + RequestCloseDeck(); + return; + } + + // Tell the tab bar to highlight the button associated + // with the deck. + mpTabBar->HighlightDeck(sNewDeckId); + + std::shared_ptr<DeckDescriptor> xDescriptor = mpResourceManager->GetDeckDescriptor(sNewDeckId); + + if (xDescriptor) + { + SwitchToDeck(*xDescriptor, maCurrentContext); + } +} + +namespace { + +void collectUIInformation(const OUString& rDeckId) +{ + EventDescription aDescription; + aDescription.aAction = "SIDEBAR"; + aDescription.aParent = "MainWindow"; + aDescription.aParameters = {{"PANEL", rDeckId}}; + aDescription.aKeyWord = "CurrentApp"; + + UITestLogger::getInstance().logEvent(aDescription); +} + +} + +void SidebarController::OpenThenToggleDeck ( + const OUString& rsDeckId) +{ + SfxSplitWindow* pSplitWindow = GetSplitWindow(); + if ( pSplitWindow && !pSplitWindow->IsFadeIn() ) + // tdf#83546 Collapsed sidebar should expand first + pSplitWindow->FadeIn(); + else if ( IsDeckVisible( rsDeckId ) ) + { + if( !WasFloatingDeckClosed() ) + { + // tdf#88241 Summoning an undocked sidebar a second time should close sidebar + mpParentWindow->Close(); + return; + } + else + { + // tdf#67627 Clicking a second time on a Deck icon will close the Deck + RequestCloseDeck(); + return; + } + } + RequestOpenDeck(); + SwitchToDeck(rsDeckId); + + // Make sure the sidebar is wide enough to fit the requested content + sal_Int32 nRequestedWidth = (mpCurrentDeck->GetMinimalWidth() + TabBar::GetDefaultWidth()) + * mpTabBar->GetDPIScaleFactor(); + if (mnSavedSidebarWidth < nRequestedWidth) + SetChildWindowWidth(nRequestedWidth); + + collectUIInformation(rsDeckId); +} + +void SidebarController::OpenThenSwitchToDeck ( + const OUString& rsDeckId) +{ + RequestOpenDeck(); + SwitchToDeck(rsDeckId); + +} + +void SidebarController::SwitchToDefaultDeck() +{ + SwitchToDeck(gsDefaultDeckId); +} + +void SidebarController::SwitchToDeck ( + const OUString& rsDeckId) +{ + if ( msCurrentDeckId != rsDeckId + || ! mbIsDeckOpen + || mnRequestedForceFlags!=SwitchFlag_NoForce) + { + std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rsDeckId); + + if (xDeckDescriptor) + SwitchToDeck(*xDeckDescriptor, maCurrentContext); + } +} + +void SidebarController::CreateDeck(const OUString& rDeckId) { + CreateDeck(rDeckId, maCurrentContext); +} + +void SidebarController::CreateDeck(const OUString& rDeckId, const Context& rContext, bool bForceCreate) +{ + std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rDeckId); + + if (!xDeckDescriptor) + return; + + VclPtr<Deck> aDeck = xDeckDescriptor->mpDeck; + if (aDeck.get()==nullptr || bForceCreate) + { + if (aDeck.get()!=nullptr) + aDeck.disposeAndClear(); + + aDeck = VclPtr<Deck>::Create( + *xDeckDescriptor, + mpParentWindow, + [this]() { return this->RequestCloseDeck(); }); + } + xDeckDescriptor->mpDeck = aDeck; + CreatePanels(rDeckId, rContext); +} + +void SidebarController::CreatePanels(const OUString& rDeckId, const Context& rContext) +{ + std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rDeckId); + + // init panels bounded to that deck, do not wait them being displayed as may be accessed through API + + VclPtr<Deck> pDeck = xDeckDescriptor->mpDeck; + + ResourceManager::PanelContextDescriptorContainer aPanelContextDescriptors; + + css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController(); + + mpResourceManager->GetMatchingPanels( + aPanelContextDescriptors, + rContext, + rDeckId, + xController); + + // Update the panel list. + const sal_Int32 nNewPanelCount (aPanelContextDescriptors.size()); + SharedPanelContainer aNewPanels; + sal_Int32 nWriteIndex (0); + + aNewPanels.resize(nNewPanelCount); + + for (sal_Int32 nReadIndex=0; nReadIndex<nNewPanelCount; ++nReadIndex) + { + const ResourceManager::PanelContextDescriptor& rPanelContexDescriptor ( + aPanelContextDescriptors[nReadIndex]); + + // Determine if the panel can be displayed. + const bool bIsPanelVisible (!mbIsDocumentReadOnly || rPanelContexDescriptor.mbShowForReadOnlyDocuments); + if ( ! bIsPanelVisible) + continue; + + Panel *const pPanel(pDeck->GetPanel(rPanelContexDescriptor.msId)); + if (pPanel != nullptr) + { + pPanel->SetLurkMode(false); + aNewPanels[nWriteIndex] = pPanel; + pPanel->SetExpanded( rPanelContexDescriptor.mbIsInitiallyVisible ); + ++nWriteIndex; + } + else + { + VclPtr<Panel> aPanel = CreatePanel( + rPanelContexDescriptor.msId, + pDeck->GetPanelParentWindow(), + rPanelContexDescriptor.mbIsInitiallyVisible, + rContext, + pDeck); + if (aPanel.get()!=nullptr ) + { + aNewPanels[nWriteIndex] = aPanel; + + // Depending on the context we have to change the command + // for the "more options" dialog. + VclPtr<PanelTitleBar> pTitleBar = aNewPanels[nWriteIndex]->GetTitleBar(); + if (pTitleBar) + { + pTitleBar->SetMoreOptionsCommand( + rPanelContexDescriptor.msMenuCommand, + mxFrame, xController); + } + ++nWriteIndex; + } + } + } + + // mpCurrentPanels - may miss stuff (?) + aNewPanels.resize(nWriteIndex); + pDeck->ResetPanels(aNewPanels); +} + +void SidebarController::SwitchToDeck ( + const DeckDescriptor& rDeckDescriptor, + const Context& rContext) +{ + if (comphelper::LibreOfficeKit::isActive()) + { + if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell()) + { + if (msCurrentDeckId != rDeckDescriptor.msId) + { + const std::string hide = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication)); + if (!hide.empty()) + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, + (hide + "=false").c_str()); + } + + const std::string show = UnoNameFromDeckId(rDeckDescriptor.msId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication)); + if (!show.empty()) + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, + (show + "=true").c_str()); + } + } + + maFocusManager.Clear(); + + const bool bForceNewDeck ((mnRequestedForceFlags&SwitchFlag_ForceNewDeck)!=0); + const bool bForceNewPanels ((mnRequestedForceFlags&SwitchFlag_ForceNewPanels)!=0); + mnRequestedForceFlags = SwitchFlag_NoForce; + + if ( msCurrentDeckId != rDeckDescriptor.msId + || bForceNewDeck) + { + if (mpCurrentDeck) + mpCurrentDeck->Hide(); + + msCurrentDeckId = rDeckDescriptor.msId; + } + mpTabBar->Invalidate(); + mpTabBar->HighlightDeck(msCurrentDeckId); + + // Determine the panels to display in the deck. + ResourceManager::PanelContextDescriptorContainer aPanelContextDescriptors; + + css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController(); + + mpResourceManager->GetMatchingPanels( + aPanelContextDescriptors, + rContext, + rDeckDescriptor.msId, + xController); + + if (aPanelContextDescriptors.empty()) + { + // There are no panels to be displayed in the current context. + if (vcl::EnumContext::GetContextEnum(rContext.msContext) != vcl::EnumContext::Context::Empty) + { + // Switch to the "empty" context and try again. + SwitchToDeck( + rDeckDescriptor, + Context( + rContext.msApplication, + vcl::EnumContext::GetContextName(vcl::EnumContext::Context::Empty))); + return; + } + else + { + // This is already the "empty" context. Looks like we have + // to live with an empty deck. + } + } + + // Provide a configuration and Deck object. + + CreateDeck(rDeckDescriptor.msId, rContext, bForceNewDeck); + + if (bForceNewPanels && !bForceNewDeck) // already forced if bForceNewDeck + CreatePanels(rDeckDescriptor.msId, rContext); + + if (mpCurrentDeck && mpCurrentDeck != rDeckDescriptor.mpDeck) + mpCurrentDeck->Hide(); + mpCurrentDeck.reset(rDeckDescriptor.mpDeck); + + if ( ! mpCurrentDeck) + return; + +#ifdef DEBUG + // Show the context name in the deck title bar. + VclPtr<DeckTitleBar> pDebugTitleBar = mpCurrentDeck->GetTitleBar(); + if (pDebugTitleBar) + pDebugTitleBar->SetTitle(rDeckDescriptor.msTitle + " (" + maCurrentContext.msContext + ")"); +#endif + + SfxSplitWindow* pSplitWindow = GetSplitWindow(); + sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor(); + WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WindowAlign::Right; + long nDeckX; + if (eAlign == WindowAlign::Left) // attach the Sidebar towards the left-side of screen + { + nDeckX = nTabBarDefaultWidth; + } + else // attach the Sidebar towards the right-side of screen + { + nDeckX = 0; + } + + // Activate the deck and the new set of panels. + mpCurrentDeck->setPosSizePixel( + nDeckX, + 0, + mpParentWindow->GetSizePixel().Width() - nTabBarDefaultWidth, + mpParentWindow->GetSizePixel().Height()); + + mpCurrentDeck->Show(); + + mpParentWindow->SetText(rDeckDescriptor.msTitle); + + NotifyResize(); + + // Tell the focus manager about the new panels and tab bar + // buttons. + maFocusManager.SetDeckTitle(mpCurrentDeck->GetTitleBar()); + maFocusManager.SetPanels(mpCurrentDeck->GetPanels()); + + mpTabBar->UpdateFocusManager(maFocusManager); + UpdateTitleBarIcons(); +} + +void SidebarController::notifyDeckTitle(const OUString& targetDeckId) +{ + if (msCurrentDeckId == targetDeckId) + { + maFocusManager.SetDeckTitle(mpCurrentDeck->GetTitleBar()); + mpTabBar->UpdateFocusManager(maFocusManager); + UpdateTitleBarIcons(); + } +} + +VclPtr<Panel> SidebarController::CreatePanel ( + const OUString& rsPanelId, + vcl::Window* pParentWindow, + const bool bIsInitiallyExpanded, + const Context& rContext, + const VclPtr<Deck>& pDeck) +{ + std::shared_ptr<PanelDescriptor> xPanelDescriptor = mpResourceManager->GetPanelDescriptor(rsPanelId); + + if (!xPanelDescriptor) + return nullptr; + + // Create the panel which is the parent window of the UIElement. + VclPtr<Panel> pPanel = VclPtr<Panel>::Create( + *xPanelDescriptor, + pParentWindow, + bIsInitiallyExpanded, + [pDeck]() { return pDeck->RequestLayout(); }, + [this]() { return this->GetCurrentContext(); }, + mxFrame); + + // Create the XUIElement. + Reference<ui::XUIElement> xUIElement (CreateUIElement( + pPanel->GetComponentInterface(), + xPanelDescriptor->msImplementationURL, + xPanelDescriptor->mbWantsCanvas, + rContext)); + if (xUIElement.is()) + { + // Initialize the panel and add it to the active deck. + pPanel->SetUIElement(xUIElement); + } + else + { + pPanel.disposeAndClear(); + } + + return pPanel; +} + +Reference<ui::XUIElement> SidebarController::CreateUIElement ( + const Reference<awt::XWindowPeer>& rxWindow, + const OUString& rsImplementationURL, + const bool bWantsCanvas, + const Context& rContext) +{ + try + { + const Reference<XComponentContext> xComponentContext (::comphelper::getProcessComponentContext() ); + const Reference<ui::XUIElementFactory> xUIElementFactory = + ui::theUIElementFactoryManager::get( xComponentContext ); + + // Create the XUIElement. + ::comphelper::NamedValueCollection aCreationArguments; + aCreationArguments.put("Frame", makeAny(mxFrame)); + aCreationArguments.put("ParentWindow", makeAny(rxWindow)); + SfxDockingWindow* pSfxDockingWindow = dynamic_cast<SfxDockingWindow*>(mpParentWindow.get()); + if (pSfxDockingWindow != nullptr) + aCreationArguments.put("SfxBindings", makeAny(reinterpret_cast<sal_uInt64>(&pSfxDockingWindow->GetBindings()))); + aCreationArguments.put("Theme", Theme::GetPropertySet()); + aCreationArguments.put("Sidebar", makeAny(Reference<ui::XSidebar>(static_cast<ui::XSidebar*>(this)))); + if (bWantsCanvas) + { + Reference<rendering::XSpriteCanvas> xCanvas (VCLUnoHelper::GetWindow(rxWindow)->GetSpriteCanvas()); + aCreationArguments.put("Canvas", makeAny(xCanvas)); + } + + if (mxCurrentController.is()) + { + OUString aModule = Tools::GetModuleName(mxCurrentController); + if (!aModule.isEmpty()) + { + aCreationArguments.put("Module", makeAny(aModule)); + } + aCreationArguments.put("Controller", makeAny(mxCurrentController)); + } + + aCreationArguments.put("ApplicationName", makeAny(rContext.msApplication)); + aCreationArguments.put("ContextName", makeAny(rContext.msContext)); + + Reference<ui::XUIElement> xUIElement( + xUIElementFactory->createUIElement( + rsImplementationURL, + aCreationArguments.getPropertyValues()), + UNO_SET_THROW); + + return xUIElement; + } + catch(const Exception&) + { + TOOLS_WARN_EXCEPTION("sfx.sidebar", "Cannot create panel " << rsImplementationURL); + return nullptr; + } +} + +IMPL_LINK(SidebarController, WindowEventHandler, VclWindowEvent&, rEvent, void) +{ + if (rEvent.GetWindow() == mpParentWindow) + { + switch (rEvent.GetId()) + { + case VclEventId::WindowShow: + case VclEventId::WindowResize: + NotifyResize(); + break; + + case VclEventId::WindowDataChanged: + // Force an update of deck and tab bar to reflect + // changes in theme (high contrast mode). + Theme::HandleDataChange(); + UpdateTitleBarIcons(); + mpParentWindow->Invalidate(); + mnRequestedForceFlags |= SwitchFlag_ForceNewDeck | SwitchFlag_ForceNewPanels; + maContextChangeUpdate.RequestCall(); + break; + + case VclEventId::ObjectDying: + dispose(); + break; + + case VclEventId::WindowPaint: + SAL_INFO("sfx.sidebar", "Paint"); + break; + + default: + break; + } + } + else if (rEvent.GetWindow()==mpSplitWindow && mpSplitWindow!=nullptr) + { + switch (rEvent.GetId()) + { + case VclEventId::WindowMouseButtonDown: + mnWidthOnSplitterButtonDown = mpParentWindow->GetSizePixel().Width(); + break; + + case VclEventId::WindowMouseButtonUp: + { + ProcessNewWidth(mpParentWindow->GetSizePixel().Width()); + mnWidthOnSplitterButtonDown = 0; + break; + } + + case VclEventId::ObjectDying: + dispose(); + break; + + default: break; + } + } +} + +void SidebarController::ShowPopupMenu ( + const tools::Rectangle& rButtonBox, + const ::std::vector<TabBar::DeckMenuData>& rMenuData) const +{ + VclPtr<PopupMenu> pMenu = CreatePopupMenu(rMenuData); + pMenu->SetSelectHdl(LINK(const_cast<SidebarController*>(this), SidebarController, OnMenuItemSelected)); + + // pass toolbox button rect so the menu can stay open on button up + tools::Rectangle aBox (rButtonBox); + aBox.Move(mpTabBar->GetPosPixel().X(), 0); + const PopupMenuFlags aMenuDirection + = (comphelper::LibreOfficeKit::isActive() ? PopupMenuFlags::ExecuteLeft + : PopupMenuFlags::ExecuteDown); + pMenu->Execute(mpParentWindow, aBox, aMenuDirection); + pMenu.disposeAndClear(); +} + +VclPtr<PopupMenu> +SidebarController::CreatePopupMenu(const ::std::vector<TabBar::DeckMenuData>& rMenuData) const +{ + // Create the top level popup menu. + auto pMenu = VclPtr<PopupMenu>::Create(); + FloatingWindow* pMenuWindow = dynamic_cast<FloatingWindow*>(pMenu->GetWindow()); + if (pMenuWindow != nullptr) + { + pMenuWindow->SetPopupModeFlags(pMenuWindow->GetPopupModeFlags() + | FloatWinPopupFlags::NoMouseUpClose); + } + + // Create sub menu for customization (hiding of deck tabs), only on desktop. + VclPtr<PopupMenu> pCustomizationMenu + = (comphelper::LibreOfficeKit::isActive() ? nullptr : VclPtr<PopupMenu>::Create()); + + // Add one entry for every tool panel element to individually make + // them visible or hide them. + sal_Int32 nIndex (0); + for (const auto& rItem : rMenuData) + { + const sal_Int32 nMenuIndex (nIndex+MID_FIRST_PANEL); + pMenu->InsertItem(nMenuIndex, rItem.msDisplayName, MenuItemBits::RADIOCHECK); + pMenu->CheckItem(nMenuIndex, rItem.mbIsCurrentDeck); + pMenu->EnableItem(nMenuIndex, rItem.mbIsEnabled && rItem.mbIsActive); + + if (!comphelper::LibreOfficeKit::isActive()) + { + const sal_Int32 nSubMenuIndex(nIndex + MID_FIRST_HIDE); + if (rItem.mbIsCurrentDeck) + { + // Don't allow the currently visible deck to be disabled. + pCustomizationMenu->InsertItem(nSubMenuIndex, rItem.msDisplayName, + MenuItemBits::RADIOCHECK); + pCustomizationMenu->CheckItem(nSubMenuIndex); + } + else + { + pCustomizationMenu->InsertItem(nSubMenuIndex, rItem.msDisplayName, + MenuItemBits::CHECKABLE); + pCustomizationMenu->CheckItem(nSubMenuIndex, rItem.mbIsEnabled && rItem.mbIsActive); + } + } + + ++nIndex; + } + + pMenu->InsertSeparator(); + + // LOK doesn't support docked/undocked; Sidebar is floating but rendered docked in browser. + if (!comphelper::LibreOfficeKit::isActive()) + { + // Add entry for docking or un-docking the tool panel. + if (mpParentWindow->IsFloatingMode()) + { + pMenu->InsertItem(MID_LOCK_TASK_PANEL, SfxResId(STR_SFX_DOCK)); + pMenu->SetAccelKey(MID_LOCK_TASK_PANEL, vcl::KeyCode(KEY_F10, true, true, false, false)); + } + else + { + pMenu->InsertItem(MID_UNLOCK_TASK_PANEL, SfxResId(STR_SFX_UNDOCK)); + pMenu->SetAccelKey(MID_UNLOCK_TASK_PANEL, vcl::KeyCode(KEY_F10, true, true, false, false)); + } + } + + pMenu->InsertItem(MID_HIDE_SIDEBAR, SfxResId(SFX_STR_SIDEBAR_HIDE_SIDEBAR)); + + // No Restore or Customize options for LoKit. + if (!comphelper::LibreOfficeKit::isActive()) + { + pCustomizationMenu->InsertSeparator(); + pCustomizationMenu->InsertItem(MID_RESTORE_DEFAULT, SfxResId(SFX_STR_SIDEBAR_RESTORE)); + + pMenu->InsertItem(MID_CUSTOMIZATION, SfxResId(SFX_STR_SIDEBAR_CUSTOMIZATION)); + pMenu->SetPopupMenu(MID_CUSTOMIZATION, pCustomizationMenu); + } + + pMenu->RemoveDisabledEntries(false); + + return pMenu; +} + +IMPL_LINK(SidebarController, OnMenuItemSelected, Menu*, pMenu, bool) +{ + if (pMenu == nullptr) + { + OSL_ENSURE(pMenu!=nullptr, "sfx2::sidebar::SidebarController::OnMenuItemSelected: illegal menu!"); + return false; + } + + pMenu->Deactivate(); + const sal_Int32 nIndex (pMenu->GetCurItemId()); + switch (nIndex) + { + case MID_UNLOCK_TASK_PANEL: + mpParentWindow->SetFloatingMode(true); + if (mpParentWindow->IsFloatingMode()) + mpParentWindow->ToTop(ToTopFlags::GrabFocusOnly); + break; + + case MID_LOCK_TASK_PANEL: + mpParentWindow->SetFloatingMode(false); + break; + + case MID_RESTORE_DEFAULT: + mpTabBar->RestoreHideFlags(); + break; + + case MID_HIDE_SIDEBAR: + { + if (!comphelper::LibreOfficeKit::isActive()) + { + const util::URL aURL(Tools::GetURL(".uno:Sidebar")); + Reference<frame::XDispatch> xDispatch(Tools::GetDispatch(mxFrame, aURL)); + if (xDispatch.is()) + xDispatch->dispatch(aURL, Sequence<beans::PropertyValue>()); + } + else + { + // In LOK we don't really destroy the sidebar when "closing"; + // we simply hide it. This is because recreating it is problematic + // See notes in SidebarDockingWindow::NotifyResize(). + RequestCloseDeck(); + } + break; + } + default: + { + try + { + if (nIndex >= MID_FIRST_PANEL && nIndex<MID_FIRST_HIDE) + { + RequestOpenDeck(); + SwitchToDeck(mpTabBar->GetDeckIdForIndex(nIndex - MID_FIRST_PANEL)); + } + else if (nIndex >=MID_FIRST_HIDE) + if (pMenu->GetItemBits(nIndex) == MenuItemBits::CHECKABLE) + { + mpTabBar->ToggleHideFlag(nIndex-MID_FIRST_HIDE); + + // Find the set of decks that could be displayed for the new context. + ResourceManager::DeckContextDescriptorContainer aDecks; + mpResourceManager->GetMatchingDecks ( + aDecks, + GetCurrentContext(), + IsDocumentReadOnly(), + mxFrame->getController()); + // Notify the tab bar about the updated set of decks. + mpTabBar->SetDecks(aDecks); + mpTabBar->HighlightDeck(mpCurrentDeck->GetId()); + mpTabBar->UpdateFocusManager(maFocusManager); + } + mpParentWindow->GrabFocusToDocument(); + } + catch (RuntimeException&) + { + } + } + break; + } + + return true; +} + +void SidebarController::RequestCloseDeck() +{ + if (comphelper::LibreOfficeKit::isActive() && mpCurrentDeck) + { + const vcl::ILibreOfficeKitNotifier* pNotifier = mpCurrentDeck->GetLOKNotifier(); + auto pMobileNotifier = SfxViewShell::Current(); + const SfxViewShell* pViewShell = SfxViewShell::Current(); + if (pMobileNotifier && pViewShell && pViewShell->isLOKMobilePhone()) + { + // Mobile phone. + std::stringstream aStream; + boost::property_tree::ptree aTree; + aTree.put("id", mpParentWindow->get_id()); // TODO could be missing - sort out + aTree.put("type", "dockingwindow"); + aTree.put("text", mpParentWindow->GetText()); + aTree.put("enabled", false); + boost::property_tree::write_json(aStream, aTree); + const std::string message = aStream.str(); + pMobileNotifier->libreOfficeKitViewCallback(LOK_CALLBACK_JSDIALOG, message.c_str()); + } + else if (pNotifier) + pNotifier->notifyWindow(mpCurrentDeck->GetLOKWindowId(), "close"); + } + + mbIsDeckRequestedOpen = false; + UpdateDeckOpenState(); + + if (!mpCurrentDeck) + mpTabBar->RemoveDeckHighlight(); +} + +void SidebarController::RequestOpenDeck() +{ + SfxSplitWindow* pSplitWindow = GetSplitWindow(); + if ( pSplitWindow && !pSplitWindow->IsFadeIn() ) + // tdf#83546 Collapsed sidebar should expand first + pSplitWindow->FadeIn(); + + mbIsDeckRequestedOpen = true; + UpdateDeckOpenState(); +} + +bool SidebarController::IsDeckOpen(const sal_Int32 nIndex) +{ + if (nIndex >= 0) + { + OUString asDeckId(mpTabBar->GetDeckIdForIndex(nIndex)); + return IsDeckVisible(asDeckId); + } + return mbIsDeckOpen && *mbIsDeckOpen; +} + +bool SidebarController::IsDeckVisible(const OUString& rsDeckId) +{ + return mbIsDeckOpen && *mbIsDeckOpen && msCurrentDeckId == rsDeckId; +} + +void SidebarController::UpdateDeckOpenState() +{ + if ( ! mbIsDeckRequestedOpen) + // No state requested. + return; + + const sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor(); + + // Update (change) the open state when it either has not yet been initialized + // or when its value differs from the requested state. + if ( mbIsDeckOpen && *mbIsDeckOpen == *mbIsDeckRequestedOpen ) + return; + + if (*mbIsDeckRequestedOpen) + { + if (!mpParentWindow->IsFloatingMode()) + { + if (mnSavedSidebarWidth <= nTabBarDefaultWidth) + SetChildWindowWidth(SidebarChildWindow::GetDefaultWidth(mpParentWindow)); + else + SetChildWindowWidth(mnSavedSidebarWidth); + } + else + { + // Show the Deck by resizing back to the original size (before hiding). + Size aNewSize(mpParentWindow->GetFloatingWindow()->GetSizePixel()); + Point aNewPos(mpParentWindow->GetFloatingWindow()->GetPosPixel()); + + aNewPos.setX(aNewPos.X() - mnSavedSidebarWidth + nTabBarDefaultWidth); + aNewSize.setWidth(mnSavedSidebarWidth); + + mpParentWindow->GetFloatingWindow()->SetPosSizePixel(aNewPos, aNewSize); + + if (comphelper::LibreOfficeKit::isActive()) + { + // Sidebar wide enough to render the menu; enable it. + mpTabBar->EnableMenuButton(true); + + if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell()) + { + const std::string uno = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication)); + if (!uno.empty()) + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, + (uno + "=true").c_str()); + } + } + } + } + else + { + if ( ! mpParentWindow->IsFloatingMode()) + mnSavedSidebarWidth = SetChildWindowWidth(nTabBarDefaultWidth); + else + { + // Hide the Deck by resizing to the width of the TabBar. + Size aNewSize(mpParentWindow->GetFloatingWindow()->GetSizePixel()); + Point aNewPos(mpParentWindow->GetFloatingWindow()->GetPosPixel()); + mnSavedSidebarWidth = aNewSize.Width(); // Save the current width to restore. + + aNewPos.setX(aNewPos.X() + mnSavedSidebarWidth - nTabBarDefaultWidth); + if (comphelper::LibreOfficeKit::isActive()) + { + // Hide by collapsing, otherwise with 0x0 the client might expect + // to get valid dimensions on rendering and not collapse the sidebar. + aNewSize.setWidth(1); + } + else + aNewSize.setWidth(nTabBarDefaultWidth); + + mpParentWindow->GetFloatingWindow()->SetPosSizePixel(aNewPos, aNewSize); + + if (comphelper::LibreOfficeKit::isActive()) + { + // Sidebar too narrow to render the menu; disable it. + mpTabBar->EnableMenuButton(false); + + if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell()) + { + const std::string uno = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication)); + if (!uno.empty()) + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, + (uno + "=false").c_str()); + } + } + } + + if (mnWidthOnSplitterButtonDown > nTabBarDefaultWidth) + mnSavedSidebarWidth = mnWidthOnSplitterButtonDown; + mpParentWindow->SetStyle(mpParentWindow->GetStyle() & ~WB_SIZEABLE); + } + + mbIsDeckOpen = *mbIsDeckRequestedOpen; + if (*mbIsDeckOpen && mpCurrentDeck) + mpCurrentDeck->Show(*mbIsDeckOpen); + NotifyResize(); +} + +bool SidebarController::CanModifyChildWindowWidth() +{ + SfxSplitWindow* pSplitWindow = GetSplitWindow(); + if (pSplitWindow == nullptr) + return false; + + sal_uInt16 nRow (0xffff); + sal_uInt16 nColumn (0xffff); + if (pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow)) + { + sal_uInt16 nRowCount (pSplitWindow->GetWindowCount(nColumn)); + return nRowCount==1; + } + else + return false; +} + +sal_Int32 SidebarController::SetChildWindowWidth (const sal_Int32 nNewWidth) +{ + SfxSplitWindow* pSplitWindow = GetSplitWindow(); + if (pSplitWindow == nullptr) + return 0; + + sal_uInt16 nRow (0xffff); + sal_uInt16 nColumn (0xffff); + pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow); + const long nColumnWidth (pSplitWindow->GetLineSize(nColumn)); + + vcl::Window* pWindow = mpParentWindow; + const Size aWindowSize (pWindow->GetSizePixel()); + + pSplitWindow->MoveWindow( + mpParentWindow, + Size(nNewWidth, aWindowSize.Height()), + nColumn, + nRow, + false); + static_cast<SplitWindow*>(pSplitWindow)->Split(); + + return static_cast<sal_Int32>(nColumnWidth); +} + +void SidebarController::RestrictWidth (sal_Int32 nWidth) +{ + SfxSplitWindow* pSplitWindow = GetSplitWindow(); + if (pSplitWindow != nullptr) + { + const sal_uInt16 nId (pSplitWindow->GetItemId(mpParentWindow.get())); + const sal_uInt16 nSetId (pSplitWindow->GetSet(nId)); + const sal_Int32 nRequestedWidth + = (TabBar::GetDefaultWidth() + nWidth) * mpTabBar->GetDPIScaleFactor(); + + pSplitWindow->SetItemSizeRange( + nSetId, + Range(nRequestedWidth, + getMaximumWidth() * mpTabBar->GetDPIScaleFactor())); + } +} + +SfxSplitWindow* SidebarController::GetSplitWindow() +{ + if (mpParentWindow != nullptr) + { + SfxSplitWindow* pSplitWindow = dynamic_cast<SfxSplitWindow*>(mpParentWindow->GetParent()); + if (pSplitWindow != mpSplitWindow) + { + if (mpSplitWindow != nullptr) + mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler)); + + mpSplitWindow = pSplitWindow; + + if (mpSplitWindow != nullptr) + mpSplitWindow->AddEventListener(LINK(this, SidebarController, WindowEventHandler)); + } + return mpSplitWindow; + } + else + return nullptr; +} + +void SidebarController::UpdateCloseIndicator (const bool bCloseAfterDrag) +{ + if (mpParentWindow == nullptr) + return; + + if (bCloseAfterDrag) + { + // Make sure that the indicator exists. + if ( ! mpCloseIndicator) + { + mpCloseIndicator.reset(VclPtr<FixedImage>::Create(mpParentWindow)); + FixedImage* pFixedImage = static_cast<FixedImage*>(mpCloseIndicator.get()); + const Image aImage (Theme::GetImage(Theme::Image_CloseIndicator)); + pFixedImage->SetImage(aImage); + pFixedImage->SetSizePixel(aImage.GetSizePixel()); + pFixedImage->SetBackground(Theme::GetWallpaper(Theme::Paint_DeckBackground)); + } + + // Place and show the indicator. + const Size aWindowSize (mpParentWindow->GetSizePixel()); + const Size aImageSize (mpCloseIndicator->GetSizePixel()); + mpCloseIndicator->SetPosPixel( + Point( + aWindowSize.Width() - TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor() - aImageSize.Width(), + (aWindowSize.Height() - aImageSize.Height())/2)); + mpCloseIndicator->Show(); + } + else + { + // Hide but don't delete the indicator. + if (mpCloseIndicator) + mpCloseIndicator->Hide(); + } +} + +void SidebarController::UpdateTitleBarIcons() +{ + if ( ! mpCurrentDeck) + return; + + const bool bIsHighContrastModeActive (Theme::IsHighContrastMode()); + + const ResourceManager& rResourceManager = *mpResourceManager; + + // Update the deck icon. + std::shared_ptr<DeckDescriptor> xDeckDescriptor = rResourceManager.GetDeckDescriptor(mpCurrentDeck->GetId()); + if (xDeckDescriptor && mpCurrentDeck->GetTitleBar()) + { + const OUString sIconURL( + bIsHighContrastModeActive + ? xDeckDescriptor->msHighContrastTitleBarIconURL + : xDeckDescriptor->msTitleBarIconURL); + mpCurrentDeck->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame)); + } + + // Update the panel icons. + const SharedPanelContainer& rPanels (mpCurrentDeck->GetPanels()); + for (const auto& rxPanel : rPanels) + { + if ( ! rxPanel) + continue; + if (!rxPanel->GetTitleBar()) + continue; + std::shared_ptr<PanelDescriptor> xPanelDescriptor = rResourceManager.GetPanelDescriptor(rxPanel->GetId()); + if (!xPanelDescriptor) + continue; + const OUString sIconURL ( + bIsHighContrastModeActive + ? xPanelDescriptor->msHighContrastTitleBarIconURL + : xPanelDescriptor->msTitleBarIconURL); + rxPanel->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame)); + } +} + +void SidebarController::ShowPanel (const Panel& rPanel) +{ + if (mpCurrentDeck) + { + if (!IsDeckOpen()) + RequestOpenDeck(); + mpCurrentDeck->ShowPanel(rPanel); + } +} + +ResourceManager::DeckContextDescriptorContainer SidebarController::GetMatchingDecks() +{ + ResourceManager::DeckContextDescriptorContainer aDecks; + mpResourceManager->GetMatchingDecks (aDecks, + GetCurrentContext(), + IsDocumentReadOnly(), + mxFrame->getController()); + return aDecks; +} + +ResourceManager::PanelContextDescriptorContainer SidebarController::GetMatchingPanels(const OUString& rDeckId) +{ + ResourceManager::PanelContextDescriptorContainer aPanels; + + mpResourceManager->GetMatchingPanels(aPanels, + GetCurrentContext(), + rDeckId, + mxFrame->getController()); + return aPanels; +} + +void SidebarController::updateModel(const css::uno::Reference<css::frame::XModel>& xModel) +{ + mpResourceManager->UpdateModel(xModel); +} + +void SidebarController::FadeOut() +{ + if (mpSplitWindow) + mpSplitWindow->FadeOut(); +} + +void SidebarController::FadeIn() +{ + if (mpSplitWindow) + mpSplitWindow->FadeIn(); +} + +tools::Rectangle SidebarController::GetDeckDragArea() const +{ + tools::Rectangle aRect; + + if(mpCurrentDeck) + { + VclPtr<DeckTitleBar> pTitleBar(mpCurrentDeck->GetTitleBar()); + + if(pTitleBar) + { + aRect = DeckTitleBar::GetDragArea(); + } + } + + return aRect; +} + +void SidebarController::frameAction(const css::frame::FrameActionEvent& rEvent) +{ + if (rEvent.Frame == mxFrame) + { + if (rEvent.Action == css::frame::FrameAction_COMPONENT_DETACHING) + unregisterSidebarForFrame(this, mxFrame->getController()); + else if (rEvent.Action == css::frame::FrameAction_COMPONENT_REATTACHED) + registerSidebarForFrame(this, mxFrame->getController()); + } +} + +void SidebarController::saveDeckState() +{ + // Impress shutdown : context (frame) is disposed before sidebar disposing + // calc writer : context (frame) is disposed after sidebar disposing + // so need to test if GetCurrentContext is still valid regarding msApplication + if (GetCurrentContext().msApplication != "none") + { + mpResourceManager->SaveDecksSettings(GetCurrentContext()); + mpResourceManager->SaveLastActiveDeck(GetCurrentContext(), msCurrentDeckId); + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/SidebarDockingWindow.cxx b/sfx2/source/sidebar/SidebarDockingWindow.cxx new file mode 100644 index 000000000..7039983f9 --- /dev/null +++ b/sfx2/source/sidebar/SidebarDockingWindow.cxx @@ -0,0 +1,318 @@ +/* -*- 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 <sfx2/sidebar/SidebarDockingWindow.hxx> +#include <sfx2/sidebar/SidebarChildWindow.hxx> +#include <sfx2/sidebar/SidebarController.hxx> +#include <sidebar/PanelDescriptor.hxx> + +#include <comphelper/dispatchcommand.hxx> +#include <comphelper/processfactory.hxx> +#include <sfx2/lokhelper.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> +#include <svtools/acceleratorexecute.hxx> +#include <tools/gen.hxx> +#include <vcl/event.hxx> +#include <comphelper/lok.hxx> +#include <LibreOfficeKit/LibreOfficeKitEnums.h> + +#include <boost/property_tree/json_parser.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +class SidebarNotifyIdle : public Idle +{ + SidebarDockingWindow& m_rSidebarDockingWin; + std::string m_LastNotificationMessage; + vcl::LOKWindowId m_LastLOKWindowId; + +public: + SidebarNotifyIdle(SidebarDockingWindow &rSidebarDockingWin) : + Idle("Sidebar notify"), + m_rSidebarDockingWin(rSidebarDockingWin), + m_LastNotificationMessage(), + m_LastLOKWindowId(0) + { + SetPriority(TaskPriority::POST_PAINT); + } + + void Invoke() override + { + auto pNotifier = m_rSidebarDockingWin.GetLOKNotifier(); + auto pMobileNotifier = SfxViewShell::Current(); + if (!pNotifier || (!pMobileNotifier && !comphelper::LibreOfficeKit::isActive())) + return; + + try + { + if (pMobileNotifier && pMobileNotifier->isLOKMobilePhone()) + { + // Mobile phone. + std::stringstream aStream; + boost::property_tree::ptree aTree = m_rSidebarDockingWin.DumpAsPropertyTree(); + aTree.put("id", m_rSidebarDockingWin.GetLOKWindowId()); + boost::property_tree::write_json(aStream, aTree); + const std::string message = aStream.str(); + if (message != m_LastNotificationMessage) + { + m_LastNotificationMessage = message; + pMobileNotifier->libreOfficeKitViewCallback(LOK_CALLBACK_JSDIALOG, message.c_str()); + } + } + + // Notify the sidebar is created, and its LOKWindowId, which + // is needed on mobile phones, tablets, and desktop. + const Point pos(m_rSidebarDockingWin.GetOutOffXPixel(), + m_rSidebarDockingWin.GetOutOffYPixel()); + const OString posMessage = pos.toString(); + const OString sizeMessage = m_rSidebarDockingWin.GetSizePixel().toString(); + + const std::string message = OString(posMessage + sizeMessage).getStr(); + const vcl::LOKWindowId lokWindowId = m_rSidebarDockingWin.GetLOKWindowId(); + + if (lokWindowId != m_LastLOKWindowId || message != m_LastNotificationMessage) + { + m_LastLOKWindowId = lokWindowId; + m_LastNotificationMessage = message; + + std::vector<vcl::LOKPayloadItem> aItems; + aItems.emplace_back("type", "deck"); + aItems.emplace_back("position", posMessage); + aItems.emplace_back("size", sizeMessage); + pNotifier->notifyWindow(lokWindowId, "created", aItems); + } + } + catch (boost::property_tree::json_parser::json_parser_error& rError) + { + SAL_WARN("sfx.sidebar", rError.message()); + } + } +}; + +SidebarDockingWindow::SidebarDockingWindow(SfxBindings* pSfxBindings, SidebarChildWindow& rChildWindow, + vcl::Window* pParentWindow, WinBits nBits) + : SfxDockingWindow(pSfxBindings, &rChildWindow, pParentWindow, nBits) + , mpSidebarController() + , mbIsReadyToDrag(false) + , mpIdleNotify(new SidebarNotifyIdle(*this)) +{ + // Get the XFrame from the bindings. + if (pSfxBindings==nullptr || pSfxBindings->GetDispatcher()==nullptr) + { + OSL_ASSERT(pSfxBindings!=nullptr); + OSL_ASSERT(pSfxBindings->GetDispatcher()!=nullptr); + } + else + { + const SfxViewFrame* pViewFrame = pSfxBindings->GetDispatcher()->GetFrame(); + mpSidebarController.set(sfx2::sidebar::SidebarController::create(this, pViewFrame).get()); + } +} + +SidebarDockingWindow::~SidebarDockingWindow() +{ + disposeOnce(); +} + +void SidebarDockingWindow::dispose() +{ + if (comphelper::LibreOfficeKit::isActive()) + LOKClose(); + + Reference<lang::XComponent> xComponent (static_cast<XWeak*>(mpSidebarController.get()), UNO_QUERY); + mpSidebarController.clear(); + if (xComponent.is()) + xComponent->dispose(); + + SfxDockingWindow::dispose(); +} + +void SidebarDockingWindow::LOKClose() +{ + assert(comphelper::LibreOfficeKit::isActive()); + if (const vcl::ILibreOfficeKitNotifier* pNotifier = GetLOKNotifier()) + { + mpIdleNotify->Stop(); + + pNotifier->notifyWindow(GetLOKWindowId(), "close"); + ReleaseLOKNotifier(); + } +} + +void SidebarDockingWindow::GetFocus() +{ + if (mpSidebarController.is()) + { + mpSidebarController->RequestOpenDeck(); + mpSidebarController->GetFocusManager().GrabFocus(); + } + else + SfxDockingWindow::GetFocus(); +} + +bool SidebarDockingWindow::Close() +{ + if (mpSidebarController.is()) + mpSidebarController->SetFloatingDeckClosed(true); + + return SfxDockingWindow::Close(); +} + +void SidebarDockingWindow::Resize() +{ + SfxDockingWindow::Resize(); + + NotifyResize(); +} + +void SidebarDockingWindow::SyncUpdate() +{ + if (mpSidebarController.is()) + mpSidebarController->SyncUpdate(); +} + +void SidebarDockingWindow::NotifyResize() +{ + if (comphelper::LibreOfficeKit::isActive() && mpSidebarController.is() && SfxViewShell::Current()) + { + const vcl::ILibreOfficeKitNotifier* pCurrentView = SfxViewShell::Current(); + if (GetLOKNotifier() != pCurrentView) + { + // ViewShell not yet set, or has changed. Reset it. + // Note GetLOKWindowId will return a new value after resetting, so we must notify clients. + LOKClose(); + + SetLOKNotifier(pCurrentView); + } + + mpIdleNotify->Start(); + } +} + +SfxChildAlignment SidebarDockingWindow::CheckAlignment ( + SfxChildAlignment eCurrentAlignment, + SfxChildAlignment eRequestedAlignment) +{ + switch (eRequestedAlignment) + { + case SfxChildAlignment::TOP: + case SfxChildAlignment::HIGHESTTOP: + case SfxChildAlignment::LOWESTTOP: + case SfxChildAlignment::BOTTOM: + case SfxChildAlignment::LOWESTBOTTOM: + case SfxChildAlignment::HIGHESTBOTTOM: + return eCurrentAlignment; + + case SfxChildAlignment::LEFT: + case SfxChildAlignment::RIGHT: + case SfxChildAlignment::FIRSTLEFT: + case SfxChildAlignment::LASTLEFT: + case SfxChildAlignment::FIRSTRIGHT: + case SfxChildAlignment::LASTRIGHT: + return eRequestedAlignment; + + default: + return eRequestedAlignment; + } +} + +bool SidebarDockingWindow::EventNotify(NotifyEvent& rEvent) +{ + MouseNotifyEvent nType = rEvent.GetType(); + if (MouseNotifyEvent::KEYINPUT == nType) + { + const vcl::KeyCode& rKeyCode = rEvent.GetKeyEvent()->GetKeyCode(); + switch (rKeyCode.GetCode()) + { + case KEY_UP: + case KEY_DOWN: + case KEY_PAGEUP: + case KEY_PAGEDOWN: + case KEY_HOME: + case KEY_END: + case KEY_LEFT: + case KEY_RIGHT: + case KEY_BACKSPACE: + case KEY_DELETE: + case KEY_INSERT: + case KEY_RETURN: + case KEY_ESCAPE: + { + return true; + } + default: + break; + } + if (!mpAccel) + { + mpAccel = svt::AcceleratorExecute::createAcceleratorHelper(); + mpAccel->init(comphelper::getProcessComponentContext(), mpSidebarController->getXFrame()); + } + const OUString aCommand(mpAccel->findCommand(svt::AcceleratorExecute::st_VCLKey2AWTKey(rKeyCode))); + if (".uno:DesignerDialog" == aCommand) + { + std::shared_ptr<PanelDescriptor> xPanelDescriptor = + mpSidebarController->GetResourceManager()->GetPanelDescriptor( "StyleListPanel" ); + if ( xPanelDescriptor && mpSidebarController->IsDeckVisible( xPanelDescriptor->msDeckId ) ) + Close(); + return true; + } + if (".uno:Undo" == aCommand || ".uno:Redo" == aCommand) + { + comphelper::dispatchCommand(aCommand, {}); + return true; + } + } + else if (MouseNotifyEvent::MOUSEBUTTONDOWN == nType) + { + const MouseEvent *mEvt = rEvent.GetMouseEvent(); + if (mEvt->IsLeft()) + { + tools::Rectangle aGrip = mpSidebarController->GetDeckDragArea(); + if ( aGrip.IsInside( mEvt->GetPosPixel() ) ) + mbIsReadyToDrag = true; + } + } + else if (MouseNotifyEvent::MOUSEMOVE == nType) + { + const MouseEvent *mEvt = rEvent.GetMouseEvent(); + tools::Rectangle aGrip = mpSidebarController->GetDeckDragArea(); + if (mEvt->IsLeft() && aGrip.IsInside( mEvt->GetPosPixel() ) && mbIsReadyToDrag ) + { + Point aPos = mEvt->GetPosPixel(); + vcl::Window* pWindow = rEvent.GetWindow(); + if ( pWindow != this ) + { + aPos = pWindow->OutputToScreenPixel( aPos ); + aPos = ScreenToOutputPixel( aPos ); + } + ImplStartDocking( aPos ); + } + } + + return SfxDockingWindow::EventNotify(rEvent); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/SidebarModelUpdate.cxx b/sfx2/source/sidebar/SidebarModelUpdate.cxx new file mode 100644 index 000000000..2f81b01f6 --- /dev/null +++ b/sfx2/source/sidebar/SidebarModelUpdate.cxx @@ -0,0 +1,20 @@ +/* -*- 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/. + */ + +#include <sfx2/sidebar/SidebarModelUpdate.hxx> + +namespace sfx2::sidebar { + +SidebarModelUpdate::~SidebarModelUpdate() +{ +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/SidebarPanelBase.cxx b/sfx2/source/sidebar/SidebarPanelBase.cxx new file mode 100644 index 000000000..666a573f6 --- /dev/null +++ b/sfx2/source/sidebar/SidebarPanelBase.cxx @@ -0,0 +1,199 @@ +/* -*- 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 <sfx2/sidebar/SidebarPanelBase.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sfx2/sidebar/ILayoutableWindow.hxx> +#include <sfx2/sidebar/IContextChangeReceiver.hxx> +#include <sfx2/sidebar/SidebarModelUpdate.hxx> +#include <vcl/layout.hxx> +#include <comphelper/processfactory.hxx> +#include <com/sun/star/awt/XWindowPeer.hpp> +#include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp> +#include <com/sun/star/ui/UIElementType.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Reference<ui::XUIElement> SidebarPanelBase::Create ( + const OUString& rsResourceURL, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + vcl::Window* pWindow, + const css::ui::LayoutSize& rLayoutSize) +{ + Reference<ui::XUIElement> xUIElement ( + new SidebarPanelBase( + rsResourceURL, + rxFrame, + pWindow, + rLayoutSize)); + return xUIElement; +} + +SidebarPanelBase::SidebarPanelBase ( + const OUString& rsResourceURL, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + vcl::Window* pWindow, + const css::ui::LayoutSize& rLayoutSize) + : SidebarPanelBaseInterfaceBase(m_aMutex), + mxFrame(rxFrame), + mpControl(pWindow), + msResourceURL(rsResourceURL), + maLayoutSize(rLayoutSize) +{ + if (mxFrame.is()) + { + css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer ( + css::ui::ContextChangeEventMultiplexer::get( + ::comphelper::getProcessComponentContext())); + xMultiplexer->addContextChangeEventListener(this, mxFrame->getController()); + } + if (mpControl != nullptr) + { + mpControl->SetBackground(Theme::GetWallpaper(Theme::Paint_PanelBackground)); + mpControl->Show(); + } +} + +SidebarPanelBase::~SidebarPanelBase() +{ +} + +void SAL_CALL SidebarPanelBase::disposing() +{ + mpControl.disposeAndClear(); + + if (mxFrame.is()) + { + css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer ( + css::ui::ContextChangeEventMultiplexer::get( + ::comphelper::getProcessComponentContext())); + xMultiplexer->removeAllContextChangeEventListeners(this); + mxFrame = nullptr; + } +} + +// XContextChangeEventListener +void SAL_CALL SidebarPanelBase::notifyContextChangeEvent ( + const ui::ContextChangeEventObject& rEvent) +{ + IContextChangeReceiver* pContextChangeReceiver + = dynamic_cast<IContextChangeReceiver*>(mpControl.get()); + if (pContextChangeReceiver != nullptr) + { + const vcl::EnumContext aContext( + vcl::EnumContext::GetApplicationEnum(rEvent.ApplicationName), + vcl::EnumContext::GetContextEnum(rEvent.ContextName)); + pContextChangeReceiver->HandleContextChange(aContext); + } +} + +void SAL_CALL SidebarPanelBase::disposing ( + const css::lang::EventObject&) +{ + mxFrame = nullptr; + mpControl = nullptr; +} + +css::uno::Reference<css::frame::XFrame> SAL_CALL SidebarPanelBase::getFrame() +{ + return mxFrame; +} + +OUString SAL_CALL SidebarPanelBase::getResourceURL() +{ + return msResourceURL; +} + +sal_Int16 SAL_CALL SidebarPanelBase::getType() +{ + return ui::UIElementType::TOOLPANEL; +} + +Reference<XInterface> SAL_CALL SidebarPanelBase::getRealInterface() +{ + return Reference<XInterface>(static_cast<XWeak*>(this)); +} + +Reference<accessibility::XAccessible> SAL_CALL SidebarPanelBase::createAccessible ( + const Reference<accessibility::XAccessible>&) +{ + // Not yet implemented. + return nullptr; +} + +Reference<awt::XWindow> SAL_CALL SidebarPanelBase::getWindow() +{ + if (mpControl != nullptr) + return Reference<awt::XWindow>( + mpControl->GetComponentInterface(), + UNO_QUERY); + else + return nullptr; +} + +ui::LayoutSize SAL_CALL SidebarPanelBase::getHeightForWidth (const sal_Int32 nWidth) +{ + if (maLayoutSize.Minimum >= 0) + return maLayoutSize; + else + { + ILayoutableWindow* pLayoutableWindow = dynamic_cast<ILayoutableWindow*>(mpControl.get()); + if (pLayoutableWindow) + return pLayoutableWindow->GetHeightForWidth(nWidth); + else if (isLayoutEnabled(mpControl)) + { + // widget layout-based sidebar + Size aSize(mpControl->get_preferred_size()); + return ui::LayoutSize(aSize.Height(), aSize.Height(), aSize.Height()); + } + else if (mpControl != nullptr) + { + const sal_Int32 nHeight (mpControl->GetSizePixel().Height()); + return ui::LayoutSize(nHeight,nHeight,nHeight); + } + } + + return ui::LayoutSize(0,0,0); +} + +sal_Int32 SAL_CALL SidebarPanelBase::getMinimalWidth () +{ + if (isLayoutEnabled(mpControl)) + { + // widget layout-based sidebar + Size aSize(mpControl->get_preferred_size()); + return aSize.Width(); + } + return 0; +} + +void SAL_CALL SidebarPanelBase::updateModel(const css::uno::Reference<css::frame::XModel>& xModel) +{ + SidebarModelUpdate* pModelUpdate = dynamic_cast<SidebarModelUpdate*>(mpControl.get()); + if (!pModelUpdate) + return; + + pModelUpdate->updateModel(xModel); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/SidebarToolBox.cxx b/sfx2/source/sidebar/SidebarToolBox.cxx new file mode 100644 index 000000000..f77e6d5ff --- /dev/null +++ b/sfx2/source/sidebar/SidebarToolBox.cxx @@ -0,0 +1,351 @@ +/* -*- 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 <sfx2/sidebar/SidebarToolBox.hxx> +#include <sidebar/ControllerFactory.hxx> +#include <sfx2/viewfrm.hxx> + +#include <vcl/commandinfoprovider.hxx> +#include <vcl/event.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <svtools/miscopt.hxx> +#include <com/sun/star/frame/XSubToolbarController.hpp> +#include <com/sun/star/lang/XComponent.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/frame/XToolbarController.hpp> + +using namespace css; +using namespace css::uno; + +namespace { + void lcl_RTLizeCommandURL( OUString& rCommandURL ) + { + if (rCommandURL == ".uno:ParaLeftToRight") + rCommandURL = ".uno:ParaRightToLeft"; + else if (rCommandURL == ".uno:ParaRightToLeft") + rCommandURL = ".uno:ParaLeftToRight"; + else if (rCommandURL == ".uno:LeftPara") + rCommandURL = ".uno:RightPara"; + else if (rCommandURL == ".uno:RightPara") + rCommandURL = ".uno:LeftPara"; + else if (rCommandURL == ".uno:AlignLeft") + rCommandURL = ".uno:AlignRight"; + else if (rCommandURL == ".uno:AlignRight") + rCommandURL = ".uno:AlignLeft"; + } +} + +namespace sfx2::sidebar { + +SidebarToolBox::SidebarToolBox (vcl::Window* pParentWindow) + : ToolBox(pParentWindow, 0), + mbAreHandlersRegistered(false), + mbUseDefaultButtonSize(true), + mbSideBar(true) +{ + SetBackground(Wallpaper()); + SetPaintTransparent(true); + SetToolboxButtonSize(GetDefaultButtonSize()); + + SvtMiscOptions().AddListenerLink(LINK(this, SidebarToolBox, ChangedIconSizeHandler)); + +#ifdef DEBUG + SetText(OUString("SidebarToolBox")); +#endif +} + +SidebarToolBox::~SidebarToolBox() +{ + disposeOnce(); +} + +void SidebarToolBox::dispose() +{ + SvtMiscOptions().RemoveListenerLink(LINK(this, SidebarToolBox, ChangedIconSizeHandler)); + + ControllerContainer aControllers; + aControllers.swap(maControllers); + for (auto const& controller : aControllers) + { + Reference<lang::XComponent> xComponent(controller.second, UNO_QUERY); + if (xComponent.is()) + xComponent->dispose(); + } + + if (mbAreHandlersRegistered) + { + SetDropdownClickHdl(Link<ToolBox *, void>()); + SetClickHdl(Link<ToolBox *, void>()); + SetDoubleClickHdl(Link<ToolBox *, void>()); + SetSelectHdl(Link<ToolBox *, void>()); + SetActivateHdl(Link<ToolBox *, void>()); + SetDeactivateHdl(Link<ToolBox *, void>()); + mbAreHandlersRegistered = false; + } + + ToolBox::dispose(); +} + +ToolBoxButtonSize SidebarToolBox::GetDefaultButtonSize() const +{ + return SvtMiscOptions().GetSidebarIconSize(); +} + +void SidebarToolBox::InsertItem(const OUString& rCommand, + const css::uno::Reference<css::frame::XFrame>& rFrame, + ToolBoxItemBits nBits, const Size& rRequestedSize, ImplToolItems::size_type nPos) +{ + OUString aCommand( rCommand ); + + if( AllSettings::GetLayoutRTL() ) + { + lcl_RTLizeCommandURL( aCommand ); + } + + ToolBox::InsertItem(aCommand, rFrame, nBits, rRequestedSize, nPos); + + CreateController(GetItemId(aCommand), rFrame, std::max(rRequestedSize.Width(), 0L), mbSideBar); + RegisterHandlers(); +} + +bool SidebarToolBox::EventNotify (NotifyEvent& rEvent) +{ + if (rEvent.GetType() == MouseNotifyEvent::KEYINPUT) + { + if (rEvent.GetKeyEvent()->GetKeyCode().GetCode() == KEY_TAB) + { + // Special handling for transferring handling of KEY_TAB + // that becomes necessary because of our parent that is + // not the dialog but a background control. + return DockingWindow::EventNotify(rEvent); + } + } + return ToolBox::EventNotify(rEvent); +} + +void SidebarToolBox::KeyInput(const KeyEvent& rKEvt) +{ + if (KEY_ESCAPE != rKEvt.GetKeyCode().GetCode()) + ToolBox::KeyInput(rKEvt); +} + +void SidebarToolBox::CreateController ( + const sal_uInt16 nItemId, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + const sal_Int32 nItemWidth, bool bSideBar) +{ + const OUString sCommandName (GetItemCommand(nItemId)); + + uno::Reference<frame::XToolbarController> xController(sfx2::sidebar::ControllerFactory::CreateToolBoxController( + this, nItemId, sCommandName, rxFrame, rxFrame->getController(), + VCLUnoHelper::GetInterface(this), nItemWidth, bSideBar)); + + if (xController.is()) + maControllers.insert(std::make_pair(nItemId, xController)); +} + +Reference<frame::XToolbarController> SidebarToolBox::GetControllerForItemId (const sal_uInt16 nItemId) const +{ + ControllerContainer::const_iterator iController (maControllers.find(nItemId)); + if (iController != maControllers.end()) + return iController->second; + + return Reference<frame::XToolbarController>(); +} + +void SidebarToolBox::SetController(const sal_uInt16 nItemId, + const css::uno::Reference<css::frame::XToolbarController>& rxController) +{ + ControllerContainer::iterator iController (maControllers.find(nItemId)); + if (iController != maControllers.end()) + { + Reference<lang::XComponent> xComponent(rxController, UNO_QUERY); + if (xComponent.is()) + xComponent->dispose(); + + iController->second = rxController; + } + else + { + maControllers[nItemId] = rxController; + } + + if (rxController.is()) + RegisterHandlers(); +} + +void SidebarToolBox::RegisterHandlers() +{ + if ( ! mbAreHandlersRegistered) + { + mbAreHandlersRegistered = true; + SetDropdownClickHdl(LINK(this, SidebarToolBox, DropDownClickHandler)); + SetClickHdl(LINK(this, SidebarToolBox, ClickHandler)); + SetDoubleClickHdl(LINK(this, SidebarToolBox, DoubleClickHandler)); + SetSelectHdl(LINK(this, SidebarToolBox, SelectHandler)); + } +} + +IMPL_LINK(SidebarToolBox, DropDownClickHandler, ToolBox*, pToolBox, void) +{ + if (pToolBox != nullptr) + { + Reference<frame::XToolbarController> xController (GetControllerForItemId(pToolBox->GetCurItemId())); + if (xController.is()) + { + Reference<awt::XWindow> xWindow = xController->createPopupWindow(); + if (xWindow.is() ) + xWindow->setFocus(); + } + } +} + +IMPL_LINK(SidebarToolBox, ClickHandler, ToolBox*, pToolBox, void) +{ + if (pToolBox == nullptr) + return; + + Reference<frame::XToolbarController> xController (GetControllerForItemId(pToolBox->GetCurItemId())); + if (xController.is()) + xController->click(); +} + +IMPL_LINK(SidebarToolBox, DoubleClickHandler, ToolBox*, pToolBox, void) +{ + if (pToolBox == nullptr) + return; + + Reference<frame::XToolbarController> xController (GetControllerForItemId(pToolBox->GetCurItemId())); + if (xController.is()) + xController->doubleClick(); +} + +IMPL_LINK(SidebarToolBox, SelectHandler, ToolBox*, pToolBox, void) +{ + if (pToolBox == nullptr) + return; + + Reference<frame::XToolbarController> xController (GetControllerForItemId(pToolBox->GetCurItemId())); + if (xController.is()) + xController->execute(static_cast<sal_Int16>(pToolBox->GetModifier())); +} + +IMPL_LINK_NOARG(SidebarToolBox, ChangedIconSizeHandler, LinkParamNone*, void) +{ + SolarMutexGuard g; + + if (mbUseDefaultButtonSize) + SetToolboxButtonSize(GetDefaultButtonSize()); + + for (auto const& it : maControllers) + { + Reference<frame::XSubToolbarController> xController(it.second, UNO_QUERY); + if (xController.is() && xController->opensSubToolbar()) + { + // The button should show the last function that was selected from the + // dropdown. The controller should know better than us what it was. + xController->updateImage(); + } + else if (SfxViewFrame::Current()) + { + OUString aCommandURL = GetItemCommand(it.first); + css::uno::Reference<frame::XFrame> xFrame = SfxViewFrame::Current()->GetFrame().GetFrameInterface(); + Image aImage = vcl::CommandInfoProvider::GetImageForCommand(aCommandURL, xFrame, GetImageSize()); + SetItemImage(it.first, aImage); + } + } + + Resize(); + queue_resize(); +} + +void SidebarToolBox::InitToolBox(VclBuilder::stringmap& rMap) +{ + for (const auto& it : rMap) + { + if (it.first == "toolbar-style") + { + if (it.second == "text") + SetButtonType(ButtonType::TEXT); + else if (it.second == "both-horiz") + SetButtonType(ButtonType::SYMBOLTEXT); + else if (it.second == "both") + { + SetButtonType(ButtonType::SYMBOLTEXT); + SetToolBoxTextPosition(ToolBoxTextPosition::Bottom); + } + } + else if (it.first == "icon-size") + { + mbUseDefaultButtonSize = false; + if (it.second == "1" || it.second == "2" || it.second == "4") + SetToolboxButtonSize(ToolBoxButtonSize::Small); + else if (it.second == "3") + SetToolboxButtonSize(ToolBoxButtonSize::Large); + else if (it.second == "5") + SetToolboxButtonSize(ToolBoxButtonSize::Size32); + } + else if (it.first == "orientation" && it.second == "vertical") + SetAlign(WindowAlign::Left); + } +} + +namespace { + +class NotebookbarToolBox : public SidebarToolBox +{ +public: + explicit NotebookbarToolBox(vcl::Window* pParentWindow) + : SidebarToolBox(pParentWindow) + { + mbSideBar = false; + SetToolboxButtonSize(GetDefaultButtonSize()); + } + + virtual ToolBoxButtonSize GetDefaultButtonSize() const override + { + return SvtMiscOptions().GetNotebookbarIconSize(); + } +}; + +} + +extern "C" SAL_DLLPUBLIC_EXPORT void makeSidebarToolBox(VclPtr<vcl::Window> & rRet, const VclPtr<vcl::Window> & pParent, VclBuilder::stringmap & rMap) +{ + static_assert(std::is_same_v<std::remove_pointer_t<VclBuilder::customMakeWidget>, + decltype(makeSidebarToolBox)>); + VclPtrInstance<SidebarToolBox> pBox(pParent); + pBox->InitToolBox(rMap); + rRet = pBox; +} + +extern "C" SAL_DLLPUBLIC_EXPORT void makeNotebookbarToolBox(VclPtr<vcl::Window> & rRet, const VclPtr<vcl::Window> & pParent, VclBuilder::stringmap & rMap) +{ + static_assert(std::is_same_v<std::remove_pointer_t<VclBuilder::customMakeWidget>, + decltype(makeNotebookbarToolBox)>); + VclPtrInstance<NotebookbarToolBox> pBox(pParent); + pBox->InitToolBox(rMap); + rRet = pBox; +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/TabBar.cxx b/sfx2/source/sidebar/TabBar.cxx new file mode 100644 index 000000000..4f49bd461 --- /dev/null +++ b/sfx2/source/sidebar/TabBar.cxx @@ -0,0 +1,417 @@ +/* -*- 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 <sfx2/sidebar/TabBar.hxx> +#include <sidebar/ControlFactory.hxx> +#include <sidebar/DeckDescriptor.hxx> +#include <sidebar/Paint.hxx> +#include <sfx2/sidebar/Theme.hxx> +#include <sidebar/Tools.hxx> +#include <sfx2/sidebar/FocusManager.hxx> +#include <sfx2/sidebar/SidebarController.hxx> +#include <sfx2/strings.hrc> + +#include <sfx2/sfxresid.hxx> + +#include <comphelper/processfactory.hxx> +#include <o3tl/safeint.hxx> +#include <vcl/button.hxx> +#include <vcl/commandevent.hxx> +#include <vcl/event.hxx> +#include <vcl/image.hxx> +#include <vcl/svapp.hxx> +#include <tools/svborder.hxx> +#include <svtools/acceleratorexecute.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +TabBar::TabBar(vcl::Window* pParentWindow, + const Reference<frame::XFrame>& rxFrame, + const std::function<void (const OUString&)>& rDeckActivationFunctor, + const PopupMenuProvider& rPopupMenuProvider, + SidebarController* rParentSidebarController + ) + : Window(pParentWindow, WB_DIALOGCONTROL), + mxFrame(rxFrame), + mpMenuButton(ControlFactory::CreateMenuButton(this)), + maItems(), + maDeckActivationFunctor(rDeckActivationFunctor), + maPopupMenuProvider(rPopupMenuProvider), + pParentSidebarController(rParentSidebarController) +{ + + SetBackground(Theme::GetPaint(Theme::Paint_TabBarBackground).GetWallpaper()); + + mpMenuButton->SetModeImage(Theme::GetImage(Theme::Image_TabBarMenu)); + mpMenuButton->SetClickHdl(LINK(this, TabBar, OnToolboxClicked)); + mpMenuButton->SetQuickHelpText(SfxResId(SFX_STR_SIDEBAR_SETTINGS)); + Layout(); + +#ifdef DEBUG + SetText(OUString("TabBar")); +#endif +} + +TabBar::~TabBar() +{ + disposeOnce(); +} + +void TabBar::dispose() +{ + for (auto & item : maItems) + item.mpButton.disposeAndClear(); + maItems.clear(); + mpMenuButton.disposeAndClear(); + vcl::Window::dispose(); +} + +void TabBar::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rUpdateArea) +{ + Window::Paint(rRenderContext, rUpdateArea); + + const sal_Int32 nHorizontalPadding(Theme::GetInteger(Theme::Int_TabMenuSeparatorPadding)); + rRenderContext.SetLineColor(Theme::GetColor(Theme::Color_TabMenuSeparator)); + rRenderContext.DrawLine(Point(nHorizontalPadding, mnMenuSeparatorY), + Point(GetSizePixel().Width() - nHorizontalPadding, mnMenuSeparatorY)); +} + +sal_Int32 TabBar::GetDefaultWidth() +{ + return Theme::GetInteger(Theme::Int_TabItemWidth) + + Theme::GetInteger(Theme::Int_TabBarLeftPadding) + + Theme::GetInteger(Theme::Int_TabBarRightPadding); +} + +void TabBar::SetDecks(const ResourceManager::DeckContextDescriptorContainer& rDecks) +{ + // Remove the current buttons. + { + for (auto & item : maItems) + { + item.mpButton.disposeAndClear(); + } + maItems.clear(); + } + maItems.resize(rDecks.size()); + sal_Int32 nIndex (0); + for (auto const& deck : rDecks) + { + std::shared_ptr<DeckDescriptor> xDescriptor = pParentSidebarController->GetResourceManager()->GetDeckDescriptor(deck.msId); + if (xDescriptor == nullptr) + { + OSL_ASSERT(xDescriptor!=nullptr); + continue; + } + + Item& rItem (maItems[nIndex++]); + rItem.msDeckId = xDescriptor->msId; + rItem.mpButton.disposeAndClear(); + rItem.mpButton = CreateTabItem(*xDescriptor); + rItem.mpButton->SetClickHdl(LINK(&rItem, TabBar::Item, HandleClick)); + rItem.maDeckActivationFunctor = maDeckActivationFunctor; + rItem.mbIsHidden = ! xDescriptor->mbIsEnabled; + rItem.mbIsHiddenByDefault = rItem.mbIsHidden; // the default is the state while creating + + rItem.mpButton->Enable(deck.mbIsEnabled); + } + + UpdateButtonIcons(); + Layout(); +} + +void TabBar::UpdateButtonIcons() +{ + Image aImage = Theme::GetImage(Theme::Image_TabBarMenu); + mpMenuButton->SetModeImage(aImage); + + for (auto const& item : maItems) + { + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pParentSidebarController->GetResourceManager()->GetDeckDescriptor(item.msDeckId); + + if (xDeckDescriptor) + { + aImage = GetItemImage(*xDeckDescriptor); + item.mpButton->SetModeImage(aImage); + } + } + + Invalidate(); +} + +void TabBar::Layout() +{ + const SvBorder aPadding ( + Theme::GetInteger(Theme::Int_TabBarLeftPadding), + Theme::GetInteger(Theme::Int_TabBarTopPadding), + Theme::GetInteger(Theme::Int_TabBarRightPadding), + Theme::GetInteger(Theme::Int_TabBarBottomPadding)); + sal_Int32 nX (aPadding.Top()); + sal_Int32 nY (aPadding.Left()); + const Size aTabItemSize ( + Theme::GetInteger(Theme::Int_TabItemWidth) * GetDPIScaleFactor(), + Theme::GetInteger(Theme::Int_TabItemHeight) * GetDPIScaleFactor()); + + // Place the menu button and the separator. + if (mpMenuButton != nullptr) + { + mpMenuButton->SetPosSizePixel( + Point(nX,nY), + aTabItemSize); + mpMenuButton->Show(); + nY += mpMenuButton->GetSizePixel().Height() + 1 + Theme::GetInteger(Theme::Int_TabMenuPadding); + mnMenuSeparatorY = nY - Theme::GetInteger(Theme::Int_TabMenuPadding)/2 - 1; + } + + // Place the deck selection buttons. + for (auto const& item : maItems) + { + Button& rButton (*item.mpButton); + rButton.Show( ! item.mbIsHidden); + + if (item.mbIsHidden) + continue; + + // Place and size the icon. + rButton.SetPosSizePixel( + Point(nX,nY), + aTabItemSize); + rButton.Show(); + + nY += rButton.GetSizePixel().Height() + 1 + aPadding.Bottom(); + } + Invalidate(); +} + +void TabBar::HighlightDeck (const OUString& rsDeckId) +{ + for (auto const& item : maItems) + { + if (item.msDeckId == rsDeckId) + item.mpButton->Check(); + else + item.mpButton->Check(false); + } +} + +void TabBar::RemoveDeckHighlight () +{ + for (auto const& item : maItems) + { + item.mpButton->Check(false); + } +} + +void TabBar::DataChanged (const DataChangedEvent& rDataChangedEvent) +{ + SetBackground(Theme::GetPaint(Theme::Paint_TabBarBackground).GetWallpaper()); + UpdateButtonIcons(); + + Window::DataChanged(rDataChangedEvent); +} + +bool TabBar::EventNotify(NotifyEvent& rEvent) +{ + MouseNotifyEvent nType = rEvent.GetType(); + if(MouseNotifyEvent::KEYINPUT == nType) + { + const vcl::KeyCode& rKeyCode = rEvent.GetKeyEvent()->GetKeyCode(); + if (!mpAccel) + { + mpAccel = svt::AcceleratorExecute::createAcceleratorHelper(); + mpAccel->init(comphelper::getProcessComponentContext(), mxFrame); + } + const OUString aCommand(mpAccel->findCommand(svt::AcceleratorExecute::st_VCLKey2AWTKey(rKeyCode))); + if (".uno:Sidebar" == aCommand || + (rKeyCode.IsMod1() && rKeyCode.IsShift() && rKeyCode.GetCode() == KEY_F10)) + return vcl::Window::EventNotify(rEvent); + return true; + } + else if(MouseNotifyEvent::COMMAND == nType) + { + const CommandEvent& rCommandEvent = *rEvent.GetCommandEvent(); + if(rCommandEvent.GetCommand() == CommandEventId::Wheel) + { + const CommandWheelData* pData = rCommandEvent.GetWheelData(); + if(!pData->GetModifier() && (pData->GetMode() == CommandWheelMode::SCROLL)) + { + auto pItem = std::find_if(maItems.begin(), maItems.end(), + [] (Item const& rItem) { return rItem.mpButton->IsChecked(); }); + if(pItem == maItems.end()) + return true; + if(pData->GetNotchDelta()<0) + { + if(pItem+1 == maItems.end()) + return true; + ++pItem; + } + else + { + if(pItem == maItems.begin()) + return true; + --pItem; + } + try + { + pItem->maDeckActivationFunctor(pItem->msDeckId); + } + catch(const css::uno::Exception&) {}; + return true; + } + } + } + return false; +} + +VclPtr<RadioButton> TabBar::CreateTabItem(const DeckDescriptor& rDeckDescriptor) +{ + VclPtr<RadioButton> pItem = ControlFactory::CreateTabItem(this); + pItem->SetAccessibleName(rDeckDescriptor.msTitle); + pItem->SetAccessibleDescription(rDeckDescriptor.msHelpText); + pItem->SetHelpText(rDeckDescriptor.msHelpText); + pItem->SetQuickHelpText(rDeckDescriptor.msHelpText); + return pItem; +} + +Image TabBar::GetItemImage(const DeckDescriptor& rDeckDescriptor) const +{ + return Tools::GetImage( + rDeckDescriptor.msIconURL, + rDeckDescriptor.msHighContrastIconURL, + mxFrame); +} + +IMPL_LINK_NOARG(TabBar::Item, HandleClick, Button*, void) +{ + vcl::Window* pFocusWin = Application::GetFocusWindow(); + pFocusWin->GrabFocusToDocument(); + try + { + maDeckActivationFunctor(msDeckId); + } + catch(const css::uno::Exception&) + {} // workaround for #i123198# +} + +OUString const & TabBar::GetDeckIdForIndex (const sal_Int32 nIndex) const +{ + if (nIndex<0 || o3tl::make_unsigned(nIndex)>=maItems.size()) + throw RuntimeException(); + return maItems[nIndex].msDeckId; +} + +void TabBar::ToggleHideFlag (const sal_Int32 nIndex) +{ + if (nIndex<0 || o3tl::make_unsigned(nIndex) >= maItems.size()) + throw RuntimeException(); + + maItems[nIndex].mbIsHidden = ! maItems[nIndex].mbIsHidden; + + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pParentSidebarController->GetResourceManager()->GetDeckDescriptor(maItems[nIndex].msDeckId); + if (xDeckDescriptor) + { + xDeckDescriptor->mbIsEnabled = ! maItems[nIndex].mbIsHidden; + + Context aContext; + aContext.msApplication = pParentSidebarController->GetCurrentContext().msApplication; + // leave aContext.msContext on default 'any' ... this func is used only for decks + // and we don't have context-sensitive decks anyway + + xDeckDescriptor->maContextList.ToggleVisibilityForContext( + aContext, xDeckDescriptor->mbIsEnabled ); + } + + Layout(); +} + +void TabBar::RestoreHideFlags() +{ + bool bNeedsLayout(false); + for (auto & item : maItems) + { + if (item.mbIsHidden != item.mbIsHiddenByDefault) + { + item.mbIsHidden = item.mbIsHiddenByDefault; + bNeedsLayout = true; + + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pParentSidebarController->GetResourceManager()->GetDeckDescriptor(item.msDeckId); + if (xDeckDescriptor) + xDeckDescriptor->mbIsEnabled = ! item.mbIsHidden; + + } + } + if (bNeedsLayout) + Layout(); +} + +void TabBar::UpdateFocusManager(FocusManager& rFocusManager) +{ + std::vector<Button*> aButtons; + aButtons.reserve(maItems.size()+1); + + aButtons.push_back(mpMenuButton.get()); + for (auto const& item : maItems) + { + aButtons.push_back(item.mpButton.get()); + } + rFocusManager.SetButtons(aButtons); +} + +IMPL_LINK_NOARG(TabBar, OnToolboxClicked, Button*, void) +{ + if (!mpMenuButton) + return; + + std::vector<DeckMenuData> aMenuData; + + for (auto const& item : maItems) + { + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pParentSidebarController->GetResourceManager()->GetDeckDescriptor(item.msDeckId); + + if (xDeckDescriptor) + { + DeckMenuData aData; + aData.msDisplayName = xDeckDescriptor->msTitle; + aData.mbIsCurrentDeck = item.mpButton->IsChecked(); + aData.mbIsActive = !item.mbIsHidden; + aData.mbIsEnabled = item.mpButton->IsEnabled(); + + aMenuData.push_back(aData); + } + } + + maPopupMenuProvider( + tools::Rectangle( + mpMenuButton->GetPosPixel(), + mpMenuButton->GetSizePixel()), + aMenuData); + mpMenuButton->Check(false); +} + +void TabBar::EnableMenuButton(const bool bEnable) +{ + mpMenuButton->Enable(bEnable); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/TabItem.cxx b/sfx2/source/sidebar/TabItem.cxx new file mode 100644 index 000000000..dcf005320 --- /dev/null +++ b/sfx2/source/sidebar/TabItem.cxx @@ -0,0 +1,109 @@ +/* -*- 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 <sidebar/TabItem.hxx> + +#include <sidebar/DrawHelper.hxx> +#include <sidebar/Paint.hxx> + +#include <sfx2/sidebar/Theme.hxx> +#include <vcl/event.hxx> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +TabItem::TabItem (vcl::Window* pParentWindow) + : RadioButton(pParentWindow, false, 0) + , mbIsLeftButtonDown(false) +{ + SetStyle(GetStyle() | WB_TABSTOP | WB_DIALOGCONTROL | WB_NOPOINTERFOCUS); + SetBackground(Theme::GetPaint(Theme::Paint_TabBarBackground).GetWallpaper()); +#ifdef DEBUG + SetText(OUString("TabItem")); +#endif +} + +void TabItem::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*UpdateArea*/) +{ + const bool bIsSelected (IsChecked()); + const bool bIsHighlighted (IsMouseOver() || HasFocus()); + DrawHelper::DrawRoundedRectangle( + rRenderContext, + tools::Rectangle(Point(0,0), GetSizePixel()), + Theme::GetInteger(Theme::Int_ButtonCornerRadius), + bIsHighlighted||bIsSelected + ? Theme::GetColor(Theme::Color_TabItemBorder) + : Color(0xffffffff), + bIsHighlighted + ? Theme::GetPaint(Theme::Paint_TabItemBackgroundHighlight) + : Theme::GetPaint(Theme::Paint_TabItemBackgroundNormal)); + + const Image aIcon(Button::GetModeImage()); + const Size aIconSize (aIcon.GetSizePixel()); + const Point aIconLocation((GetSizePixel().Width() - aIconSize.Width()) / 2, + (GetSizePixel().Height() - aIconSize.Height()) / 2); + rRenderContext.DrawImage(aIconLocation, aIcon, IsEnabled() ? DrawImageFlags::NONE : DrawImageFlags::Disable); +} + +void TabItem::MouseMove(const MouseEvent& rEvent) +{ + if (rEvent.IsEnterWindow() || rEvent.IsLeaveWindow()) + Invalidate(); + RadioButton::MouseMove(rEvent); +} + +void TabItem::MouseButtonDown(const MouseEvent& rMouseEvent) +{ + if (rMouseEvent.IsLeft()) + { + mbIsLeftButtonDown = true; + CaptureMouse(); + Invalidate(); + } +} + +void TabItem::MouseButtonUp(const MouseEvent& rMouseEvent) +{ + if (IsMouseCaptured()) + ReleaseMouse(); + + if (rMouseEvent.IsLeft()) + { + if (mbIsLeftButtonDown) + { + Check(); + Click(); + vcl::Window* pParent = GetParent(); + if (pParent) + pParent->Invalidate(); + } + } + + if (mbIsLeftButtonDown) + { + mbIsLeftButtonDown = false; + Invalidate(); + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/Theme.cxx b/sfx2/source/sidebar/Theme.cxx new file mode 100644 index 000000000..7a4d6a785 --- /dev/null +++ b/sfx2/source/sidebar/Theme.cxx @@ -0,0 +1,1047 @@ +/* -*- 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 <sfx2/sidebar/Theme.hxx> +#include <sidebar/Paint.hxx> +#include <sidebar/Tools.hxx> +#include <sfx2/app.hxx> + +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <tools/diagnose_ex.h> + +#include <com/sun/star/awt/Rectangle.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Theme& Theme::GetCurrentTheme() +{ + return SfxGetpApp()->GetSidebarTheme(); +} + +Theme::Theme() + : ThemeInterfaceBase(m_aMutex), + maImages(), + maColors(), + maPaints(), + maIntegers(), + maBooleans(), + mbIsHighContrastMode(Application::GetSettings().GetStyleSettings().GetHighContrastMode()), + mbIsHighContrastModeSetManually(false), + maPropertyNameToIdMap(), + maPropertyIdToNameMap(), + maRawValues(), + maChangeListeners(), + maVetoableListeners() + +{ + SetupPropertyMaps(); +} + +Theme::~Theme() +{ +} + +Image Theme::GetImage (const ThemeItem eItem) +{ + const PropertyType eType (GetPropertyType(eItem)); + OSL_ASSERT(eType==PT_Image); + const sal_Int32 nIndex (GetIndex(eItem, eType)); + const Theme& rTheme (GetCurrentTheme()); + return rTheme.maImages[nIndex]; +} + +Color Theme::GetColor (const ThemeItem eItem) +{ + const PropertyType eType (GetPropertyType(eItem)); + OSL_ASSERT(eType==PT_Color || eType==PT_Paint); + const sal_Int32 nIndex (GetIndex(eItem, eType)); + const Theme& rTheme (GetCurrentTheme()); + if (eType == PT_Color) + return rTheme.maColors[nIndex]; + else if (eType == PT_Paint) + return rTheme.maPaints[nIndex].GetColor(); + else + return COL_WHITE; +} + +const Paint& Theme::GetPaint (const ThemeItem eItem) +{ + const PropertyType eType (GetPropertyType(eItem)); + OSL_ASSERT(eType==PT_Paint); + const sal_Int32 nIndex (GetIndex(eItem, eType)); + const Theme& rTheme (GetCurrentTheme()); + return rTheme.maPaints[nIndex]; +} + +Wallpaper Theme::GetWallpaper (const ThemeItem eItem) +{ + return GetPaint(eItem).GetWallpaper(); +} + +sal_Int32 Theme::GetInteger (const ThemeItem eItem) +{ + const PropertyType eType (GetPropertyType(eItem)); + OSL_ASSERT(eType==PT_Integer); + const sal_Int32 nIndex (GetIndex(eItem, eType)); + const Theme& rTheme (GetCurrentTheme()); + return rTheme.maIntegers[nIndex]; +} + +bool Theme::GetBoolean (const ThemeItem eItem) +{ + const PropertyType eType (GetPropertyType(eItem)); + OSL_ASSERT(eType==PT_Boolean); + const sal_Int32 nIndex (GetIndex(eItem, eType)); + const Theme& rTheme (GetCurrentTheme()); + return rTheme.maBooleans[nIndex]; +} + +bool Theme::IsHighContrastMode() +{ + const Theme& rTheme (GetCurrentTheme()); + return rTheme.mbIsHighContrastMode; +} + +void Theme::HandleDataChange() +{ + Theme& rTheme (GetCurrentTheme()); + + if ( ! rTheme.mbIsHighContrastModeSetManually) + { + // Do not modify mbIsHighContrastMode when it was manually set. + GetCurrentTheme().mbIsHighContrastMode = Application::GetSettings().GetStyleSettings().GetHighContrastMode(); + rTheme.maRawValues[Bool_IsHighContrastModeActive] <<= GetCurrentTheme().mbIsHighContrastMode; + } + + GetCurrentTheme().UpdateTheme(); +} + +void Theme::InitializeTheme() +{ + setPropertyValue( + maPropertyIdToNameMap[Bool_UseSystemColors], + Any(false)); +} + +void Theme::UpdateTheme() +{ + try + { + const StyleSettings& rStyle (Application::GetSettings().GetStyleSettings()); + const bool bUseSystemColors (GetBoolean(Bool_UseSystemColors)); + +#define Alternatives(n,hc,sys) (mbIsHighContrastMode ? hc : (bUseSystemColors ? sys : n)) + + Color aBaseBackgroundColor (rStyle.GetDialogColor()); + // UX says this should be a little brighter, but that looks off when compared to the other windows. + //aBaseBackgroundColor.IncreaseLuminance(7); + Color aBorderColor (aBaseBackgroundColor); + aBorderColor.DecreaseLuminance(15); + Color aSecondColor (aBaseBackgroundColor); + aSecondColor.DecreaseLuminance(15); + + setPropertyValue( + maPropertyIdToNameMap[Paint_DeckBackground], + Any(sal_Int32(aBaseBackgroundColor.GetRGBColor()))); + + setPropertyValue( + maPropertyIdToNameMap[Paint_DeckTitleBarBackground], + Any(sal_Int32(aBaseBackgroundColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Int_DeckLeftPadding], + Any(sal_Int32(2))); + setPropertyValue( + maPropertyIdToNameMap[Int_DeckTopPadding], + Any(sal_Int32(2))); + setPropertyValue( + maPropertyIdToNameMap[Int_DeckRightPadding], + Any(sal_Int32(2))); + setPropertyValue( + maPropertyIdToNameMap[Int_DeckBottomPadding], + Any(sal_Int32(2))); + setPropertyValue( + maPropertyIdToNameMap[Int_DeckBorderSize], + Any(sal_Int32(1))); + setPropertyValue( + maPropertyIdToNameMap[Int_DeckSeparatorHeight], + Any(sal_Int32(1))); + setPropertyValue( + maPropertyIdToNameMap[Int_ButtonCornerRadius], + Any(sal_Int32(3))); + setPropertyValue( + maPropertyIdToNameMap[Color_DeckTitleFont], + Any(sal_Int32(rStyle.GetFontColor().GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Int_DeckTitleBarHeight], + Any(sal_Int32(Alternatives( + 26, + 26, + rStyle.GetFloatTitleHeight())))); + setPropertyValue( + maPropertyIdToNameMap[Paint_PanelBackground], + Any(sal_Int32(aBaseBackgroundColor.GetRGBColor()))); + + setPropertyValue( + maPropertyIdToNameMap[Paint_PanelTitleBarBackground], + Any(Tools::VclToAwtGradient(Gradient( + GradientStyle::Linear, + aSecondColor.GetRGBColor(), + aBaseBackgroundColor.GetRGBColor() + )))); + setPropertyValue( + maPropertyIdToNameMap[Color_PanelTitleFont], + Any(sal_Int32(mbIsHighContrastMode ? 0x00ff00 : 0x262626))); + setPropertyValue( + maPropertyIdToNameMap[Int_PanelTitleBarHeight], + Any(sal_Int32(Alternatives( + 26, + 26, + rStyle.GetTitleHeight())))); + setPropertyValue( + maPropertyIdToNameMap[Paint_TabBarBackground], + Any(sal_Int32(aBaseBackgroundColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Int_TabBarLeftPadding], + Any(sal_Int32(2))); + setPropertyValue( + maPropertyIdToNameMap[Int_TabBarTopPadding], + Any(sal_Int32(2))); + setPropertyValue( + maPropertyIdToNameMap[Int_TabBarRightPadding], + Any(sal_Int32(2))); + setPropertyValue( + maPropertyIdToNameMap[Int_TabBarBottomPadding], + Any(sal_Int32(2))); + + setPropertyValue( + maPropertyIdToNameMap[Int_TabMenuPadding], + Any(sal_Int32(6))); + setPropertyValue( + maPropertyIdToNameMap[Color_TabMenuSeparator], + Any(sal_Int32(aBorderColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Int_TabMenuSeparatorPadding], + Any(sal_Int32(7))); + + setPropertyValue( + maPropertyIdToNameMap[Int_TabItemWidth], + Any(sal_Int32(32))); + setPropertyValue( + maPropertyIdToNameMap[Int_TabItemHeight], + Any(sal_Int32(32))); + setPropertyValue( + maPropertyIdToNameMap[Color_TabItemBorder], + Any(sal_Int32(rStyle.GetActiveBorderColor().GetRGBColor()))); + + setPropertyValue( + maPropertyIdToNameMap[Paint_DropDownBackground], + Any(sal_Int32(aBaseBackgroundColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Color_DropDownBorder], + Any(sal_Int32(rStyle.GetActiveBorderColor().GetRGBColor()))); + + setPropertyValue( + maPropertyIdToNameMap[Color_Highlight], + Any(sal_Int32(rStyle.GetHighlightColor().GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Color_HighlightText], + Any(sal_Int32(rStyle.GetHighlightTextColor().GetRGBColor()))); + + setPropertyValue( + maPropertyIdToNameMap[Paint_TabItemBackgroundNormal], + Any()); + setPropertyValue( + maPropertyIdToNameMap[Paint_TabItemBackgroundHighlight], + Any(sal_Int32(rStyle.GetActiveTabColor().GetRGBColor()))); + + setPropertyValue( + maPropertyIdToNameMap[Paint_HorizontalBorder], + Any(sal_Int32(aBorderColor.GetRGBColor()))); + + setPropertyValue( + maPropertyIdToNameMap[Paint_VerticalBorder], + Any(sal_Int32(aBorderColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Image_Grip], + Any(OUString("private:graphicrepository/sfx2/res/grip.png"))); + setPropertyValue( + maPropertyIdToNameMap[Image_Expand], + Any(OUString("private:graphicrepository/res/plus.png"))); + setPropertyValue( + maPropertyIdToNameMap[Image_Collapse], + Any(OUString("private:graphicrepository/res/minus.png"))); + setPropertyValue( + maPropertyIdToNameMap[Image_TabBarMenu], + Any(OUString("private:graphicrepository/sfx2/res/symphony/open_more.png"))); + setPropertyValue( + maPropertyIdToNameMap[Image_PanelMenu], + Any(OUString("private:graphicrepository/sfx2/res/symphony/morebutton.png"))); + setPropertyValue( + maPropertyIdToNameMap[Image_Closer], + Any(OUString("private:graphicrepository/sfx2/res/closedoc.png"))); + setPropertyValue( + maPropertyIdToNameMap[Image_CloseIndicator], + Any(OUString("private:graphicrepository/cmd/lc_decrementlevel.png"))); + + // Gradient style + Color aGradientStop2 (aBaseBackgroundColor); + aGradientStop2.IncreaseLuminance(17); + Color aToolBoxBorderColor (aBaseBackgroundColor); + aToolBoxBorderColor.DecreaseLuminance(12); + setPropertyValue( + maPropertyIdToNameMap[Paint_ToolBoxBackground], + Any(Tools::VclToAwtGradient(Gradient( + GradientStyle::Linear, + aBaseBackgroundColor.GetRGBColor(), + aGradientStop2.GetRGBColor() + )))); + setPropertyValue( + maPropertyIdToNameMap[Paint_ToolBoxBorderTopLeft], + mbIsHighContrastMode + ? Any(util::Color(sal_uInt32(0x00ff00))) + : Any(util::Color(aToolBoxBorderColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Paint_ToolBoxBorderCenterCorners], + mbIsHighContrastMode + ? Any(util::Color(sal_uInt32(0x00ff00))) + : Any(util::Color(aToolBoxBorderColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Paint_ToolBoxBorderBottomRight], + mbIsHighContrastMode + ? Any(util::Color(sal_uInt32(0x00ff00))) + : Any(util::Color(aToolBoxBorderColor.GetRGBColor()))); + setPropertyValue( + maPropertyIdToNameMap[Rect_ToolBoxPadding], + Any(awt::Rectangle(2,2,2,2))); + setPropertyValue( + maPropertyIdToNameMap[Rect_ToolBoxBorder], + Any(awt::Rectangle(1,1,1,1))); + } + catch(beans::UnknownPropertyException const &) + { + DBG_UNHANDLED_EXCEPTION("sfx", "unknown property"); + OSL_ASSERT(false); + } +} + +void SAL_CALL Theme::disposing() +{ + ChangeListeners aListeners; + aListeners.swap(maChangeListeners); + + const lang::EventObject aEvent (static_cast<XWeak*>(this)); + + for (const auto& rContainer : aListeners) + { + for (const auto& rxListener : rContainer.second) + { + try + { + rxListener->disposing(aEvent); + } + catch(const Exception&) + { + } + } + } +} + +Reference<beans::XPropertySet> Theme::GetPropertySet() +{ + return Reference<beans::XPropertySet>(static_cast<XWeak*>(&GetCurrentTheme()), UNO_QUERY); +} + +Reference<beans::XPropertySetInfo> SAL_CALL Theme::getPropertySetInfo() +{ + return Reference<beans::XPropertySetInfo>(this); +} + +void SAL_CALL Theme::setPropertyValue ( + const OUString& rsPropertyName, + const css::uno::Any& rValue) +{ + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + throw beans::UnknownPropertyException(rsPropertyName); + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + throw beans::UnknownPropertyException(rsPropertyName); + + const ThemeItem eItem (iId->second); + + if (rValue == maRawValues[eItem]) + { + // Value is not different from the one in the property + // set => nothing to do. + return; + } + + const Any aOldValue (maRawValues[eItem]); + + const beans::PropertyChangeEvent aEvent( + static_cast<XWeak*>(this), + rsPropertyName, + false, + eItem, + aOldValue, + rValue); + + if (DoVetoableListenersVeto(GetVetoableListeners(AnyItem_, false), aEvent)) + return; + if (DoVetoableListenersVeto(GetVetoableListeners(eItem, false), aEvent)) + return; + + maRawValues[eItem] = rValue; + ProcessNewValue(rValue, eItem, eType); + + BroadcastPropertyChange(GetChangeListeners(AnyItem_, false), aEvent); + BroadcastPropertyChange(GetChangeListeners(eItem, false), aEvent); +} + +Any SAL_CALL Theme::getPropertyValue ( + const OUString& rsPropertyName) +{ + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + throw beans::UnknownPropertyException(rsPropertyName); + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + throw beans::UnknownPropertyException(rsPropertyName); + + const ThemeItem eItem (iId->second); + + return maRawValues[eItem]; +} + +void SAL_CALL Theme::addPropertyChangeListener( + const OUString& rsPropertyName, + const css::uno::Reference<css::beans::XPropertyChangeListener>& rxListener) +{ + ThemeItem eItem (AnyItem_); + if (rsPropertyName.getLength() > 0) + { + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + throw beans::UnknownPropertyException(rsPropertyName); + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + throw beans::UnknownPropertyException(rsPropertyName); + + eItem = iId->second; + } + ChangeListenerContainer* pListeners = GetChangeListeners(eItem, true); + if (pListeners != nullptr) + pListeners->push_back(rxListener); +} + +void SAL_CALL Theme::removePropertyChangeListener( + const OUString& rsPropertyName, + const css::uno::Reference<css::beans::XPropertyChangeListener>& rxListener) +{ + ThemeItem eItem (AnyItem_); + if (rsPropertyName.getLength() > 0) + { + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + throw beans::UnknownPropertyException(rsPropertyName); + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + throw beans::UnknownPropertyException(rsPropertyName); + + eItem = iId->second; + } + ChangeListenerContainer* pContainer = GetChangeListeners(eItem, false); + if (pContainer != nullptr) + { + ChangeListenerContainer::iterator iListener (::std::find(pContainer->begin(), pContainer->end(), rxListener)); + if (iListener != pContainer->end()) + { + pContainer->erase(iListener); + + // Remove the listener container when empty. + if (pContainer->empty()) + maChangeListeners.erase(eItem); + } + } +} + +void SAL_CALL Theme::addVetoableChangeListener( + const OUString& rsPropertyName, + const css::uno::Reference<css::beans::XVetoableChangeListener>& rxListener) +{ + ThemeItem eItem (AnyItem_); + if (rsPropertyName.getLength() > 0) + { + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + throw beans::UnknownPropertyException(rsPropertyName); + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + throw beans::UnknownPropertyException(rsPropertyName); + + eItem = iId->second; + } + VetoableListenerContainer* pListeners = GetVetoableListeners(eItem, true); + if (pListeners != nullptr) + pListeners->push_back(rxListener); +} + +void SAL_CALL Theme::removeVetoableChangeListener( + const OUString& rsPropertyName, + const css::uno::Reference<css::beans::XVetoableChangeListener>& rxListener) +{ + ThemeItem eItem (AnyItem_); + if (rsPropertyName.getLength() > 0) + { + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + throw beans::UnknownPropertyException(rsPropertyName); + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + throw beans::UnknownPropertyException(rsPropertyName); + + eItem = iId->second; + } + VetoableListenerContainer* pContainer = GetVetoableListeners(eItem, false); + if (pContainer != nullptr) + { + VetoableListenerContainer::iterator iListener (::std::find(pContainer->begin(), pContainer->end(), rxListener)); + if (iListener != pContainer->end()) + { + pContainer->erase(iListener); + // Remove container when empty. + if (pContainer->empty()) + maVetoableListeners.erase(eItem); + } + } +} + +css::uno::Sequence<css::beans::Property> SAL_CALL Theme::getProperties() +{ + ::std::vector<beans::Property> aProperties; + + sal_Int32 const nEnd(End_); + for (sal_Int32 nItem(Begin_); nItem!=nEnd; ++nItem) + { + const ThemeItem eItem (static_cast<ThemeItem>(nItem)); + const PropertyType eType (GetPropertyType(eItem)); + if (eType == PT_Invalid) + continue; + + const beans::Property aProperty( + maPropertyIdToNameMap[eItem], + eItem, + GetCppuType(eType), + 0); + aProperties.push_back(aProperty); + } + + return css::uno::Sequence<css::beans::Property>( + aProperties.data(), + aProperties.size()); +} + +beans::Property SAL_CALL Theme::getPropertyByName (const OUString& rsPropertyName) +{ + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + throw beans::UnknownPropertyException(rsPropertyName); + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + throw beans::UnknownPropertyException(rsPropertyName); + + const ThemeItem eItem (iId->second); + + return beans::Property( + rsPropertyName, + eItem, + GetCppuType(eType), + 0); +} + +sal_Bool SAL_CALL Theme::hasPropertyByName (const OUString& rsPropertyName) +{ + PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName)); + if (iId == maPropertyNameToIdMap.end()) + return false; + + const PropertyType eType (GetPropertyType(iId->second)); + if (eType == PT_Invalid) + return false; + + return true; +} + +void Theme::SetupPropertyMaps() +{ + maPropertyIdToNameMap.resize(Post_Rect_); + maImages.resize(Image_Color_ - Pre_Image_ - 1); + maColors.resize(Color_Paint_ - Image_Color_ - 1); + maPaints.resize(Paint_Int_ - Color_Paint_ - 1); + maIntegers.resize(Int_Bool_ - Paint_Int_ - 1); + maBooleans.resize(Bool_Rect_ - Int_Bool_ - 1); + maRectangles.resize(Post_Rect_ - Bool_Rect_ - 1); + + maPropertyNameToIdMap["Image_Grip"]=Image_Grip; + maPropertyIdToNameMap[Image_Grip]="Image_Grip"; + + maPropertyNameToIdMap["Image_Expand"]=Image_Expand; + maPropertyIdToNameMap[Image_Expand]="Image_Expand"; + + maPropertyNameToIdMap["Image_Collapse"]=Image_Collapse; + maPropertyIdToNameMap[Image_Collapse]="Image_Collapse"; + + maPropertyNameToIdMap["Image_TabBarMenu"]=Image_TabBarMenu; + maPropertyIdToNameMap[Image_TabBarMenu]="Image_TabBarMenu"; + + maPropertyNameToIdMap["Image_PanelMenu"]=Image_PanelMenu; + maPropertyIdToNameMap[Image_PanelMenu]="Image_PanelMenu"; + + maPropertyNameToIdMap["Image_Closer"]=Image_Closer; + maPropertyIdToNameMap[Image_Closer]="Image_Closer"; + + maPropertyNameToIdMap["Image_CloseIndicator"]=Image_CloseIndicator; + maPropertyIdToNameMap[Image_CloseIndicator]="Image_CloseIndicator"; + + + maPropertyNameToIdMap["Color_DeckTitleFont"]=Color_DeckTitleFont; + maPropertyIdToNameMap[Color_DeckTitleFont]="Color_DeckTitleFont"; + + maPropertyNameToIdMap["Color_PanelTitleFont"]=Color_PanelTitleFont; + maPropertyIdToNameMap[Color_PanelTitleFont]="Color_PanelTitleFont"; + + maPropertyNameToIdMap["Color_TabMenuSeparator"]=Color_TabMenuSeparator; + maPropertyIdToNameMap[Color_TabMenuSeparator]="Color_TabMenuSeparator"; + + maPropertyNameToIdMap["Color_TabItemBorder"]=Color_TabItemBorder; + maPropertyIdToNameMap[Color_TabItemBorder]="Color_TabItemBorder"; + + maPropertyNameToIdMap["Color_DropDownBorder"]=Color_DropDownBorder; + maPropertyIdToNameMap[Color_DropDownBorder]="Color_DropDownBorder"; + + maPropertyNameToIdMap["Color_Highlight"]=Color_Highlight; + maPropertyIdToNameMap[Color_Highlight]="Color_Highlight"; + + maPropertyNameToIdMap["Color_HighlightText"]=Color_HighlightText; + maPropertyIdToNameMap[Color_HighlightText]="Color_HighlightText"; + + + maPropertyNameToIdMap["Paint_DeckBackground"]=Paint_DeckBackground; + maPropertyIdToNameMap[Paint_DeckBackground]="Paint_DeckBackground"; + + maPropertyNameToIdMap["Paint_DeckTitleBarBackground"]=Paint_DeckTitleBarBackground; + maPropertyIdToNameMap[Paint_DeckTitleBarBackground]="Paint_DeckTitleBarBackground"; + + maPropertyNameToIdMap["Paint_PanelBackground"]=Paint_PanelBackground; + maPropertyIdToNameMap[Paint_PanelBackground]="Paint_PanelBackground"; + + maPropertyNameToIdMap["Paint_PanelTitleBarBackground"]=Paint_PanelTitleBarBackground; + maPropertyIdToNameMap[Paint_PanelTitleBarBackground]="Paint_PanelTitleBarBackground"; + + maPropertyNameToIdMap["Paint_TabBarBackground"]=Paint_TabBarBackground; + maPropertyIdToNameMap[Paint_TabBarBackground]="Paint_TabBarBackground"; + + maPropertyNameToIdMap["Paint_TabItemBackgroundNormal"]=Paint_TabItemBackgroundNormal; + maPropertyIdToNameMap[Paint_TabItemBackgroundNormal]="Paint_TabItemBackgroundNormal"; + + maPropertyNameToIdMap["Paint_TabItemBackgroundHighlight"]=Paint_TabItemBackgroundHighlight; + maPropertyIdToNameMap[Paint_TabItemBackgroundHighlight]="Paint_TabItemBackgroundHighlight"; + + maPropertyNameToIdMap["Paint_HorizontalBorder"]=Paint_HorizontalBorder; + maPropertyIdToNameMap[Paint_HorizontalBorder]="Paint_HorizontalBorder"; + + maPropertyNameToIdMap["Paint_VerticalBorder"]=Paint_VerticalBorder; + maPropertyIdToNameMap[Paint_VerticalBorder]="Paint_VerticalBorder"; + + maPropertyNameToIdMap["Paint_ToolBoxBackground"]=Paint_ToolBoxBackground; + maPropertyIdToNameMap[Paint_ToolBoxBackground]="Paint_ToolBoxBackground"; + + maPropertyNameToIdMap["Paint_ToolBoxBorderTopLeft"]=Paint_ToolBoxBorderTopLeft; + maPropertyIdToNameMap[Paint_ToolBoxBorderTopLeft]="Paint_ToolBoxBorderTopLeft"; + + maPropertyNameToIdMap["Paint_ToolBoxBorderCenterCorners"]=Paint_ToolBoxBorderCenterCorners; + maPropertyIdToNameMap[Paint_ToolBoxBorderCenterCorners]="Paint_ToolBoxBorderCenterCorners"; + + maPropertyNameToIdMap["Paint_ToolBoxBorderBottomRight"]=Paint_ToolBoxBorderBottomRight; + maPropertyIdToNameMap[Paint_ToolBoxBorderBottomRight]="Paint_ToolBoxBorderBottomRight"; + + maPropertyNameToIdMap["Paint_DropDownBackground"]=Paint_DropDownBackground; + maPropertyIdToNameMap[Paint_DropDownBackground]="Paint_DropDownBackground"; + + + maPropertyNameToIdMap["Int_DeckTitleBarHeight"]=Int_DeckTitleBarHeight; + maPropertyIdToNameMap[Int_DeckTitleBarHeight]="Int_DeckTitleBarHeight"; + + maPropertyNameToIdMap["Int_DeckBorderSize"]=Int_DeckBorderSize; + maPropertyIdToNameMap[Int_DeckBorderSize]="Int_DeckBorderSize"; + + maPropertyNameToIdMap["Int_DeckSeparatorHeight"]=Int_DeckSeparatorHeight; + maPropertyIdToNameMap[Int_DeckSeparatorHeight]="Int_DeckSeparatorHeight"; + + maPropertyNameToIdMap["Int_PanelTitleBarHeight"]=Int_PanelTitleBarHeight; + maPropertyIdToNameMap[Int_PanelTitleBarHeight]="Int_PanelTitleBarHeight"; + + maPropertyNameToIdMap["Int_TabMenuPadding"]=Int_TabMenuPadding; + maPropertyIdToNameMap[Int_TabMenuPadding]="Int_TabMenuPadding"; + + maPropertyNameToIdMap["Int_TabMenuSeparatorPadding"]=Int_TabMenuSeparatorPadding; + maPropertyIdToNameMap[Int_TabMenuSeparatorPadding]="Int_TabMenuSeparatorPadding"; + + maPropertyNameToIdMap["Int_TabItemWidth"]=Int_TabItemWidth; + maPropertyIdToNameMap[Int_TabItemWidth]="Int_TabItemWidth"; + + maPropertyNameToIdMap["Int_TabItemHeight"]=Int_TabItemHeight; + maPropertyIdToNameMap[Int_TabItemHeight]="Int_TabItemHeight"; + + maPropertyNameToIdMap["Int_DeckLeftPadding"]=Int_DeckLeftPadding; + maPropertyIdToNameMap[Int_DeckLeftPadding]="Int_DeckLeftPadding"; + + maPropertyNameToIdMap["Int_DeckTopPadding"]=Int_DeckTopPadding; + maPropertyIdToNameMap[Int_DeckTopPadding]="Int_DeckTopPadding"; + + maPropertyNameToIdMap["Int_DeckRightPadding"]=Int_DeckRightPadding; + maPropertyIdToNameMap[Int_DeckRightPadding]="Int_DeckRightPadding"; + + maPropertyNameToIdMap["Int_DeckBottomPadding"]=Int_DeckBottomPadding; + maPropertyIdToNameMap[Int_DeckBottomPadding]="Int_DeckBottomPadding"; + + maPropertyNameToIdMap["Int_TabBarLeftPadding"]=Int_TabBarLeftPadding; + maPropertyIdToNameMap[Int_TabBarLeftPadding]="Int_TabBarLeftPadding"; + + maPropertyNameToIdMap["Int_TabBarTopPadding"]=Int_TabBarTopPadding; + maPropertyIdToNameMap[Int_TabBarTopPadding]="Int_TabBarTopPadding"; + + maPropertyNameToIdMap["Int_TabBarRightPadding"]=Int_TabBarRightPadding; + maPropertyIdToNameMap[Int_TabBarRightPadding]="Int_TabBarRightPadding"; + + maPropertyNameToIdMap["Int_TabBarBottomPadding"]=Int_TabBarBottomPadding; + maPropertyIdToNameMap[Int_TabBarBottomPadding]="Int_TabBarBottomPadding"; + + maPropertyNameToIdMap["Int_ButtonCornerRadius"]=Int_ButtonCornerRadius; + maPropertyIdToNameMap[Int_ButtonCornerRadius]="Int_ButtonCornerRadius"; + + + maPropertyNameToIdMap["Bool_UseSystemColors"]=Bool_UseSystemColors; + maPropertyIdToNameMap[Bool_UseSystemColors]="Bool_UseSystemColors"; + + maPropertyNameToIdMap["Bool_IsHighContrastModeActive"]=Bool_IsHighContrastModeActive; + maPropertyIdToNameMap[Bool_IsHighContrastModeActive]="Bool_IsHighContrastModeActive"; + + + maPropertyNameToIdMap["Rect_ToolBoxPadding"]=Rect_ToolBoxPadding; + maPropertyIdToNameMap[Rect_ToolBoxPadding]="Rect_ToolBoxPadding"; + + maPropertyNameToIdMap["Rect_ToolBoxBorder"]=Rect_ToolBoxBorder; + maPropertyIdToNameMap[Rect_ToolBoxBorder]="Rect_ToolBoxBorder"; + + maRawValues.resize(maPropertyIdToNameMap.size()); +} + +Theme::PropertyType Theme::GetPropertyType (const ThemeItem eItem) +{ + switch(eItem) + { + case Image_Grip: + case Image_Expand: + case Image_Collapse: + case Image_TabBarMenu: + case Image_PanelMenu: + case Image_Closer: + case Image_CloseIndicator: + return PT_Image; + + case Color_DeckTitleFont: + case Color_PanelTitleFont: + case Color_TabMenuSeparator: + case Color_TabItemBorder: + case Color_DropDownBorder: + case Color_Highlight: + case Color_HighlightText: + return PT_Color; + + case Paint_DeckBackground: + case Paint_DeckTitleBarBackground: + case Paint_PanelBackground: + case Paint_PanelTitleBarBackground: + case Paint_TabBarBackground: + case Paint_TabItemBackgroundNormal: + case Paint_TabItemBackgroundHighlight: + case Paint_HorizontalBorder: + case Paint_VerticalBorder: + case Paint_ToolBoxBackground: + case Paint_ToolBoxBorderTopLeft: + case Paint_ToolBoxBorderCenterCorners: + case Paint_ToolBoxBorderBottomRight: + case Paint_DropDownBackground: + return PT_Paint; + + case Int_DeckTitleBarHeight: + case Int_DeckBorderSize: + case Int_DeckSeparatorHeight: + case Int_PanelTitleBarHeight: + case Int_TabMenuPadding: + case Int_TabMenuSeparatorPadding: + case Int_TabItemWidth: + case Int_TabItemHeight: + case Int_DeckLeftPadding: + case Int_DeckTopPadding: + case Int_DeckRightPadding: + case Int_DeckBottomPadding: + case Int_TabBarLeftPadding: + case Int_TabBarTopPadding: + case Int_TabBarRightPadding: + case Int_TabBarBottomPadding: + case Int_ButtonCornerRadius: + return PT_Integer; + + case Bool_UseSystemColors: + case Bool_IsHighContrastModeActive: + return PT_Boolean; + + case Rect_ToolBoxBorder: + case Rect_ToolBoxPadding: + return PT_Rectangle; + + default: + return PT_Invalid; + } +} + +css::uno::Type const & Theme::GetCppuType (const PropertyType eType) +{ + switch(eType) + { + case PT_Image: + return cppu::UnoType<OUString>::get(); + + case PT_Color: + return cppu::UnoType<sal_uInt32>::get(); + + case PT_Paint: + return cppu::UnoType<void>::get(); + + case PT_Integer: + return cppu::UnoType<sal_Int32>::get(); + + case PT_Boolean: + return cppu::UnoType<sal_Bool>::get(); + + case PT_Rectangle: + return cppu::UnoType<awt::Rectangle>::get(); + + case PT_Invalid: + default: + return cppu::UnoType<void>::get(); + } +} + +sal_Int32 Theme::GetIndex (const ThemeItem eItem, const PropertyType eType) +{ + switch(eType) + { + case PT_Image: + return eItem - Pre_Image_-1; + case PT_Color: + return eItem - Image_Color_-1; + case PT_Paint: + return eItem - Color_Paint_-1; + case PT_Integer: + return eItem - Paint_Int_-1; + case PT_Boolean: + return eItem - Int_Bool_-1; + case PT_Rectangle: + return eItem - Bool_Rect_-1; + + default: + OSL_ASSERT(false); + return 0; + } +} + +Theme::VetoableListenerContainer* Theme::GetVetoableListeners ( + const ThemeItem eItem, + const bool bCreate) +{ + VetoableListeners::iterator iContainer (maVetoableListeners.find(eItem)); + if (iContainer != maVetoableListeners.end()) + return &iContainer->second; + else if (bCreate) + { + maVetoableListeners[eItem] = VetoableListenerContainer(); + return &maVetoableListeners[eItem]; + } + else + return nullptr; +} + +Theme::ChangeListenerContainer* Theme::GetChangeListeners ( + const ThemeItem eItem, + const bool bCreate) +{ + ChangeListeners::iterator iContainer (maChangeListeners.find(eItem)); + if (iContainer != maChangeListeners.end()) + return &iContainer->second; + else if (bCreate) + { + maChangeListeners[eItem] = ChangeListenerContainer(); + return &maChangeListeners[eItem]; + } + else + return nullptr; +} + +bool Theme::DoVetoableListenersVeto ( + const VetoableListenerContainer* pListeners, + const beans::PropertyChangeEvent& rEvent) +{ + if (pListeners == nullptr) + return false; + + VetoableListenerContainer aListeners (*pListeners); + try + { + for (const auto& rxListener : aListeners) + { + rxListener->vetoableChange(rEvent); + } + } + catch(const beans::PropertyVetoException&) + { + return true; + } + catch(const Exception&) + { + // Ignore any other errors (such as disposed listeners). + } + return false; +} + +void Theme::BroadcastPropertyChange ( + const ChangeListenerContainer* pListeners, + const beans::PropertyChangeEvent& rEvent) +{ + if (pListeners == nullptr) + return; + + const ChangeListenerContainer aListeners (*pListeners); + try + { + for (const auto& rxListener : aListeners) + { + rxListener->propertyChange(rEvent); + } + } + catch(const Exception&) + { + // Ignore any errors (such as disposed listeners). + } +} + +void Theme::ProcessNewValue ( + const Any& rValue, + const ThemeItem eItem, + const PropertyType eType) +{ + const sal_Int32 nIndex (GetIndex (eItem, eType)); + switch (eType) + { + case PT_Image: + { + OUString sURL; + if (rValue >>= sURL) + { + maImages[nIndex] = Tools::GetImage(sURL, nullptr); + } + break; + } + case PT_Color: + { + sal_Int32 nColorValue (0); + if (rValue >>= nColorValue) + { + maColors[nIndex] = Color(nColorValue); + } + break; + } + case PT_Paint: + { + maPaints[nIndex] = Paint::Create(rValue); + break; + } + case PT_Integer: + { + sal_Int32 nValue (0); + if (rValue >>= nValue) + { + maIntegers[nIndex] = nValue; + } + break; + } + case PT_Boolean: + { + bool bValue (false); + if (rValue >>= bValue) + { + maBooleans[nIndex] = bValue; + if (eItem == Bool_IsHighContrastModeActive) + { + mbIsHighContrastModeSetManually = true; + mbIsHighContrastMode = maBooleans[nIndex]; + HandleDataChange(); + } + else if (eItem == Bool_UseSystemColors) + { + HandleDataChange(); + } + } + break; + } + case PT_Rectangle: + { + awt::Rectangle aBox; + if (rValue >>= aBox) + { + maRectangles[nIndex] = tools::Rectangle( + aBox.X, + aBox.Y, + aBox.Width, + aBox.Height); + } + break; + } + case PT_Invalid: + OSL_ASSERT(eType != PT_Invalid); + throw RuntimeException(); + } +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/TitleBar.cxx b/sfx2/source/sidebar/TitleBar.cxx new file mode 100644 index 000000000..40627a6c2 --- /dev/null +++ b/sfx2/source/sidebar/TitleBar.cxx @@ -0,0 +1,172 @@ +/* -*- 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 <sidebar/TitleBar.hxx> +#include <sidebar/Paint.hxx> +#include <sidebar/AccessibleTitleBar.hxx> + +#include <com/sun/star/accessibility/AccessibleRole.hpp> + +namespace +{ + const static sal_Int32 gnLeftIconSpace (3); + const static sal_Int32 gnRightIconSpace (3); +} + +namespace sfx2::sidebar { + +TitleBar::TitleBar(const OUString& rsTitle, + vcl::Window* pParentWindow, + const sidebar::Paint& rInitialBackgroundPaint) + : Window(pParentWindow) + , maToolBox(VclPtr<SidebarToolBox>::Create(this)) + , msTitle(rsTitle) + , maIcon() + , maBackgroundPaint(rInitialBackgroundPaint) +{ + maToolBox->SetSelectHdl(LINK(this, TitleBar, SelectionHandler)); +} + +TitleBar::~TitleBar() +{ + disposeOnce(); +} + +void TitleBar::dispose() +{ + maToolBox.disposeAndClear(); + vcl::Window::dispose(); +} + +void TitleBar::SetTitle(const OUString& rsTitle) +{ + msTitle = rsTitle; + Invalidate(); +} + +void TitleBar::SetIcon(const Image& rIcon) +{ + maIcon = rIcon; + Invalidate(); +} + +void TitleBar::ApplySettings(vcl::RenderContext& rRenderContext) +{ + rRenderContext.SetBackground(maBackgroundPaint.GetWallpaper()); +} + +void TitleBar::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rUpdateArea*/) +{ + // Paint title bar background. + Size aWindowSize (GetSizePixel()); + tools::Rectangle aTitleBarBox(0,0, aWindowSize.Width(), aWindowSize.Height()); + + PaintDecoration(rRenderContext); + const tools::Rectangle aTitleBox(GetTitleArea(aTitleBarBox)); + PaintTitle(rRenderContext, aTitleBox); + PaintFocus(rRenderContext, aTitleBox); +} + +void TitleBar::DataChanged (const DataChangedEvent& /*rEvent*/) +{ + maBackgroundPaint = GetBackgroundPaint(); + Invalidate(); +} + +void TitleBar::setPosSizePixel (long nX, long nY, long nWidth, long nHeight, PosSizeFlags nFlags) +{ + Window::setPosSizePixel(nX, nY, nWidth, nHeight, nFlags); + + // Place the toolbox. + const sal_Int32 nToolBoxWidth (maToolBox->GetItemPosRect(0).GetWidth()); + maToolBox->setPosSizePixel(nWidth - nToolBoxWidth,0, nToolBoxWidth, nHeight); + maToolBox->Show(); +} + +void TitleBar::HandleToolBoxItemClick(const sal_uInt16 /*nItemIndex*/) +{ + // Any real processing has to be done in derived class. +} + +css::uno::Reference<css::accessibility::XAccessible> TitleBar::CreateAccessible() +{ + SetAccessibleRole(css::accessibility::AccessibleRole::PANEL); + return AccessibleTitleBar::Create(*this); +} + +void TitleBar::PaintTitle(vcl::RenderContext& rRenderContext, const tools::Rectangle& rTitleBox) +{ + rRenderContext.Push(PushFlags::FONT | PushFlags::TEXTCOLOR); + + tools::Rectangle aTitleBox(rTitleBox); + + // When there is an icon then paint it at the left of the given + // box. + if (!!maIcon) + { + rRenderContext.DrawImage(Point(aTitleBox.Left() + gnLeftIconSpace, + aTitleBox.Top() + (aTitleBox.GetHeight() - maIcon.GetSizePixel().Height()) / 2), + maIcon); + aTitleBox.AdjustLeft(gnLeftIconSpace + maIcon.GetSizePixel().Width() + gnRightIconSpace ); + } + + vcl::Font aFont(rRenderContext.GetFont()); + aFont.SetWeight(WEIGHT_BOLD); + rRenderContext.SetFont(aFont); + + // Paint title bar text. + rRenderContext.SetTextColor(rRenderContext.GetTextColor()); + rRenderContext.DrawText(aTitleBox, msTitle, DrawTextFlags::Left | DrawTextFlags::VCenter); + rRenderContext.Pop(); +} + +void TitleBar::PaintFocus(vcl::RenderContext& rRenderContext, const tools::Rectangle& rFocusBox) +{ + rRenderContext.Push(PushFlags::FONT | PushFlags::TEXTCOLOR); + + vcl::Font aFont(rRenderContext.GetFont()); + aFont.SetWeight(WEIGHT_BOLD); + rRenderContext.SetFont(aFont); + + const tools::Rectangle aTextBox(rRenderContext.GetTextRect(rFocusBox, msTitle, DrawTextFlags::Left | DrawTextFlags::VCenter)); + + const tools::Rectangle aLargerTextBox(aTextBox.Left() - 2, + aTextBox.Top() - 2, + aTextBox.Right() + 2, + aTextBox.Bottom() + 2); + + if (HasFocus()) + Window::ShowFocus(aLargerTextBox); + else + Window::HideFocus(); + + rRenderContext.Pop(); +} + +IMPL_LINK(TitleBar, SelectionHandler, ToolBox*, pToolBox, void) +{ + OSL_ASSERT(maToolBox.get()==pToolBox); + const sal_uInt16 nItemId (maToolBox->GetHighlightItemId()); + + HandleToolBoxItemClick(nItemId); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/Tools.cxx b/sfx2/source/sidebar/Tools.cxx new file mode 100644 index 000000000..eb936c4ff --- /dev/null +++ b/sfx2/source/sidebar/Tools.cxx @@ -0,0 +1,139 @@ +/* -*- 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 <sidebar/Tools.hxx> + +#include <sfx2/sidebar/Theme.hxx> + +#include <comphelper/processfactory.hxx> +#include <vcl/commandinfoprovider.hxx> +#include <vcl/gradient.hxx> + +#include <com/sun/star/frame/XDispatchProvider.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/util/URLTransformer.hpp> +#include <com/sun/star/frame/ModuleManager.hpp> + +using namespace css; +using namespace css::uno; + +namespace sfx2::sidebar { + +Image Tools::GetImage ( + const OUString& rsImageURL, + const OUString& rsHighContrastImageURL, + const Reference<frame::XFrame>& rxFrame) +{ + if (Theme::IsHighContrastMode()) + return GetImage(rsHighContrastImageURL, rxFrame); + else + return GetImage(rsImageURL, rxFrame); +} + +Image Tools::GetImage ( + const OUString& rsURL, + const Reference<frame::XFrame>& rxFrame) +{ + if (rsURL.getLength() > 0) + { + if (rsURL.startsWith(".uno:")) + return vcl::CommandInfoProvider::GetImageForCommand(rsURL, rxFrame); + + else + return Image(rsURL); + } + return Image(); +} + +css::awt::Gradient Tools::VclToAwtGradient (const Gradient& rVclGradient) +{ + css::awt::Gradient aAwtGradient ( + awt::GradientStyle(rVclGradient.GetStyle()), + sal_Int32(rVclGradient.GetStartColor().GetRGBColor()), + sal_Int32(rVclGradient.GetEndColor().GetRGBColor()), + rVclGradient.GetAngle(), + rVclGradient.GetBorder(), + rVclGradient.GetOfsX(), + rVclGradient.GetOfsY(), + rVclGradient.GetStartIntensity(), + rVclGradient.GetEndIntensity(), + rVclGradient.GetSteps()); + return aAwtGradient; +} + +Gradient Tools::AwtToVclGradient (const css::awt::Gradient& rAwtGradient) +{ + Gradient aVclGradient ( + GradientStyle(rAwtGradient.Style), + Color(rAwtGradient.StartColor), + Color(rAwtGradient.EndColor)); + aVclGradient.SetAngle(rAwtGradient.Angle); + aVclGradient.SetBorder(rAwtGradient.Border); + aVclGradient.SetOfsX(rAwtGradient.XOffset); + aVclGradient.SetOfsY(rAwtGradient.YOffset); + aVclGradient.SetStartIntensity(rAwtGradient.StartIntensity); + aVclGradient.SetEndIntensity(rAwtGradient.EndIntensity); + aVclGradient.SetSteps(rAwtGradient.StepCount); + + return aVclGradient; +} + +util::URL Tools::GetURL (const OUString& rsCommand) +{ + util::URL aURL; + aURL.Complete = rsCommand; + + const Reference<XComponentContext> xComponentContext (::comphelper::getProcessComponentContext()); + const Reference<util::XURLTransformer> xParser = util::URLTransformer::create( xComponentContext ); + xParser->parseStrict(aURL); + + return aURL; +} + +Reference<frame::XDispatch> Tools::GetDispatch ( + const css::uno::Reference<css::frame::XFrame>& rxFrame, + const util::URL& rURL) +{ + Reference<frame::XDispatchProvider> xProvider (rxFrame, UNO_QUERY_THROW); + Reference<frame::XDispatch> xDispatch (xProvider->queryDispatch(rURL, OUString(), 0)); + return xDispatch; +} + +OUString Tools::GetModuleName ( + const css::uno::Reference<css::frame::XController>& rxController) +{ + if (!rxController.is()) + return OUString(); + + try + { + const Reference<XComponentContext> xComponentContext (::comphelper::getProcessComponentContext()); + const Reference<frame::XModuleManager> xModuleManager = frame::ModuleManager::create( xComponentContext ); + return xModuleManager->identify(rxController); + } + catch (const Exception&) + { + // Ignored. + } + return OUString(); +} + +} // end of namespace sfx2::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/UnoDeck.cxx b/sfx2/source/sidebar/UnoDeck.cxx new file mode 100644 index 000000000..122afbe01 --- /dev/null +++ b/sfx2/source/sidebar/UnoDeck.cxx @@ -0,0 +1,278 @@ +/* -*- 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/. + * + */ + +#include <sidebar/UnoDeck.hxx> + +#include <sidebar/UnoPanels.hxx> + +#include <sfx2/sidebar/ResourceManager.hxx> +#include <sfx2/sidebar/SidebarController.hxx> +#include <sidebar/DeckTitleBar.hxx> +#include <sfx2/sidebar/Deck.hxx> +#include <sidebar/DeckDescriptor.hxx> + +#include <vcl/svapp.hxx> + +using namespace css; +using namespace ::sfx2::sidebar; + +SfxUnoDeck::SfxUnoDeck(const uno::Reference<frame::XFrame>& rFrame, const OUString& deckId): +xFrame(rFrame), +mDeckId(deckId) +{ + +} +SidebarController* SfxUnoDeck::getSidebarController() +{ + return SidebarController::GetSidebarControllerForFrame(xFrame); +} + +OUString SAL_CALL SfxUnoDeck::getId() +{ + SolarMutexGuard aGuard; + + return mDeckId; +} + +OUString SAL_CALL SfxUnoDeck::getTitle() +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + VclPtr<Deck> pDeck = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId)->mpDeck; + + if (!pDeck) + { + pSidebarController->CreateDeck(mDeckId); + pDeck = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId)->mpDeck; + } + + VclPtr<DeckTitleBar> pTitleBar = pDeck->GetTitleBar(); + return pTitleBar->GetTitle(); +} + +void SAL_CALL SfxUnoDeck::setTitle( const OUString& newTitle ) +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + pSidebarController->CreateDeck(mDeckId); + + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId); + + if (xDeckDescriptor) + { + Deck* pDeck = xDeckDescriptor->mpDeck; + const VclPtr<DeckTitleBar>& pTitleBar = pDeck->GetTitleBar(); + pTitleBar->SetTitle(newTitle); + + xDeckDescriptor->msTitle = newTitle; + xDeckDescriptor->msHelpText = newTitle; + + pSidebarController->notifyDeckTitle(mDeckId); + } +} + +sal_Bool SAL_CALL SfxUnoDeck::isActive() +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + return pSidebarController->IsDeckVisible(mDeckId); +} + + +void SAL_CALL SfxUnoDeck::activate( const sal_Bool bActivate ) +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + if (bActivate) + pSidebarController->SwitchToDeck(mDeckId); + else + pSidebarController->SwitchToDefaultDeck(); + + // update the sidebar + pSidebarController->NotifyResize(); +} + +uno::Reference<ui::XPanels> SAL_CALL SfxUnoDeck::getPanels() +{ + SolarMutexGuard aGuard; + + uno::Reference<ui::XPanels> panels = new SfxUnoPanels(xFrame, mDeckId); + return panels; +} + +sal_Int32 SAL_CALL SfxUnoDeck::getOrderIndex() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + sal_Int32 index = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId)->mnOrderIndex; + return index; +} + +void SAL_CALL SfxUnoDeck::setOrderIndex( const sal_Int32 newOrderIndex ) +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId); + + if (xDeckDescriptor) + { + xDeckDescriptor->mnOrderIndex = newOrderIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } +} + +void SAL_CALL SfxUnoDeck::moveFirst() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::DeckContextDescriptorContainer aDecks = pSidebarController->GetMatchingDecks(); + + sal_Int32 minIndex = GetMinOrderIndex(aDecks); + sal_Int32 curOrderIndex = getOrderIndex(); + + if (curOrderIndex != minIndex) // is deck already in place ? + { + minIndex -= 1; + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId); + if (xDeckDescriptor) + { + xDeckDescriptor->mnOrderIndex = minIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +void SAL_CALL SfxUnoDeck::moveLast() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::DeckContextDescriptorContainer aDecks = pSidebarController->GetMatchingDecks(); + + sal_Int32 maxIndex = GetMaxOrderIndex(aDecks); + sal_Int32 curOrderIndex = getOrderIndex(); + + if (curOrderIndex != maxIndex) // is deck already in place ? + { + maxIndex += 1; + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId); + if (xDeckDescriptor) + { + xDeckDescriptor->mnOrderIndex = maxIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +void SAL_CALL SfxUnoDeck::moveUp() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + // Search for previous deck OrderIndex + ResourceManager::DeckContextDescriptorContainer aDecks = pSidebarController->GetMatchingDecks(); + + sal_Int32 curOrderIndex = getOrderIndex(); + sal_Int32 previousIndex = GetMinOrderIndex(aDecks); + + for (auto const& deck : aDecks) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetDeckDescriptor(deck.msId)->mnOrderIndex; + if( index < curOrderIndex && index > previousIndex) + previousIndex = index; + } + + if (curOrderIndex != previousIndex) // is deck already in place ? + { + previousIndex -= 1; + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId); + if (xDeckDescriptor) + { + xDeckDescriptor->mnOrderIndex = previousIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +void SAL_CALL SfxUnoDeck::moveDown() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::DeckContextDescriptorContainer aDecks = pSidebarController->GetMatchingDecks(); + + // Search for next deck OrderIndex + sal_Int32 curOrderIndex = getOrderIndex(); + sal_Int32 nextIndex = GetMaxOrderIndex(aDecks); + + for (auto const& deck : aDecks) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetDeckDescriptor(deck.msId)->mnOrderIndex; + if( index > curOrderIndex && index < nextIndex) + nextIndex = index; + } + + if (curOrderIndex != nextIndex) // is deck already in place ? + { + nextIndex += 1; + std::shared_ptr<DeckDescriptor> xDeckDescriptor = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId); + if (xDeckDescriptor) + { + xDeckDescriptor->mnOrderIndex = nextIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +sal_Int32 SfxUnoDeck::GetMinOrderIndex(ResourceManager::DeckContextDescriptorContainer aDecks) +{ + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::DeckContextDescriptorContainer::const_iterator iDeck = aDecks.begin(); + sal_Int32 minIndex = pSidebarController->GetResourceManager()->GetDeckDescriptor(iDeck->msId)->mnOrderIndex; + + for (auto const& deck : aDecks) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetDeckDescriptor(deck.msId)->mnOrderIndex; + if(minIndex > index) + minIndex = index; + } + return minIndex; +} + +sal_Int32 SfxUnoDeck::GetMaxOrderIndex(ResourceManager::DeckContextDescriptorContainer aDecks) +{ + SidebarController* pSidebarController = getSidebarController(); + + sal_Int32 maxIndex = pSidebarController->GetResourceManager()->GetDeckDescriptor(aDecks.begin()->msId)->mnOrderIndex; + + for (auto const& deck : aDecks) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetDeckDescriptor(deck.msId)->mnOrderIndex; + if(maxIndex < index) + maxIndex = index; + } + return maxIndex; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/UnoDecks.cxx b/sfx2/source/sidebar/UnoDecks.cxx new file mode 100644 index 000000000..9b3ad8999 --- /dev/null +++ b/sfx2/source/sidebar/UnoDecks.cxx @@ -0,0 +1,149 @@ +/* -*- 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/. + * + */ + +#include <sal/config.h> + +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <sidebar/UnoDecks.hxx> +#include <sidebar/UnoDeck.hxx> + +#include <sfx2/sidebar/ResourceManager.hxx> +#include <sfx2/sidebar/SidebarController.hxx> + +#include <vcl/svapp.hxx> + +using namespace css; +using namespace ::sfx2::sidebar; + +SfxUnoDecks::SfxUnoDecks(const uno::Reference<frame::XFrame>& rFrame): +xFrame(rFrame) +{ +} + +SidebarController* SfxUnoDecks::getSidebarController() +{ + return SidebarController::GetSidebarControllerForFrame(xFrame); +} + +// XNameAccess + +uno::Any SAL_CALL SfxUnoDecks::getByName( const OUString& aName ) +{ + SolarMutexGuard aGuard; + + if (!hasByName(aName)) + throw container::NoSuchElementException(); + + uno::Reference<ui::XDeck> xDeck = new SfxUnoDeck(xFrame, aName); + return uno::Any(xDeck); +} + + +uno::Sequence< OUString > SAL_CALL SfxUnoDecks::getElementNames() +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::DeckContextDescriptorContainer aDecks; + css::uno::Sequence< OUString > deckList(aDecks.size()); + + if (pSidebarController) + { + pSidebarController->GetResourceManager()->GetMatchingDecks ( + aDecks, + pSidebarController->GetCurrentContext(), + pSidebarController->IsDocumentReadOnly(), + xFrame->getController()); + + deckList.realloc(aDecks.size()); + + long n = 0; + + for (const auto& rDeck : aDecks) + { + deckList[n] = rDeck.msId; + n++; + } + } + + return deckList; + +} + +sal_Bool SAL_CALL SfxUnoDecks::hasByName( const OUString& aName ) +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + bool bFound = false; + + if (pSidebarController) + { + ResourceManager::DeckContextDescriptorContainer aDecks; + + pSidebarController->GetResourceManager()->GetMatchingDecks ( + aDecks, + pSidebarController->GetCurrentContext(), + pSidebarController->IsDocumentReadOnly(), + xFrame->getController()); + + bFound = std::any_of(aDecks.begin(), aDecks.end(), + [&aName](const ResourceManager::DeckContextDescriptor& rDeck) { return rDeck.msId == aName; }); + } + + return bFound; + +} + +// XIndexAccess + +sal_Int32 SAL_CALL SfxUnoDecks::getCount() +{ + SolarMutexGuard aGuard; + + uno::Sequence< OUString > decks = getElementNames(); + return decks.getLength(); +} + +uno::Any SAL_CALL SfxUnoDecks::getByIndex( sal_Int32 Index ) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + + uno::Sequence< OUString > decks = getElementNames(); + + if (Index > decks.getLength()-1 || Index < 0) + throw lang::IndexOutOfBoundsException(); + + uno::Reference<ui::XDeck> xDeck = new SfxUnoDeck(xFrame, decks[Index]); + aRet <<= xDeck; + return aRet; + +} + +// XElementAccess +uno::Type SAL_CALL SfxUnoDecks::getElementType() +{ + SolarMutexGuard aGuard; + + return uno::Type(); +} + +sal_Bool SAL_CALL SfxUnoDecks::hasElements() +{ + SolarMutexGuard aGuard; + + uno::Sequence< OUString > decks = getElementNames(); + return decks.hasElements(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/UnoPanel.cxx b/sfx2/source/sidebar/UnoPanel.cxx new file mode 100644 index 000000000..eee70429a --- /dev/null +++ b/sfx2/source/sidebar/UnoPanel.cxx @@ -0,0 +1,290 @@ +/* -*- 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/. + * + */ + +#include <sidebar/UnoPanel.hxx> + +#include <sfx2/sidebar/ResourceManager.hxx> +#include <sfx2/sidebar/SidebarController.hxx> + +#include <sidebar/PanelDescriptor.hxx> +#include <sidebar/PanelTitleBar.hxx> +#include <sfx2/sidebar/Panel.hxx> +#include <sfx2/sidebar/Deck.hxx> +#include <sidebar/DeckDescriptor.hxx> + +#include <vcl/svapp.hxx> + +using namespace css; +using namespace ::sfx2::sidebar; + +SfxUnoPanel::SfxUnoPanel(const uno::Reference<frame::XFrame>& rFrame, const OUString& panelId, const OUString& deckId): +xFrame(rFrame), +mPanelId(panelId), +mDeckId(deckId), +mpDeck(), +mpPanel() +{ + SidebarController* pSidebarController = getSidebarController(); + + pSidebarController->CreateDeck(mDeckId); // creates deck object is not already + mpDeck = pSidebarController->GetResourceManager()->GetDeckDescriptor(mDeckId)->mpDeck; + mpPanel = mpDeck->GetPanel(mPanelId); +} + +SidebarController* SfxUnoPanel::getSidebarController() +{ + return SidebarController::GetSidebarControllerForFrame(xFrame); +} + +OUString SAL_CALL SfxUnoPanel::getId() +{ + SolarMutexGuard aGuard; + + return mPanelId; +} + +OUString SAL_CALL SfxUnoPanel::getTitle() +{ + SolarMutexGuard aGuard; + + VclPtr<PanelTitleBar> pTitleBar = mpPanel->GetTitleBar(); + if (pTitleBar) + return pTitleBar->GetTitle(); + else + return OUString(); +} + +void SAL_CALL SfxUnoPanel::setTitle( const OUString& newTitle ) +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pSidebarController->GetResourceManager()->GetPanelDescriptor(mPanelId); + + if (xPanelDescriptor) + { + xPanelDescriptor->msTitle = newTitle; + VclPtr<PanelTitleBar> pTitleBar = mpPanel->GetTitleBar(); + if (pTitleBar) + pTitleBar->SetTitle(newTitle); + } +} + +sal_Bool SAL_CALL SfxUnoPanel::isExpanded() +{ + SolarMutexGuard aGuard; + + return mpPanel->IsExpanded(); +} + + +void SAL_CALL SfxUnoPanel::expand( const sal_Bool bCollapseOther ) +{ + + SolarMutexGuard aGuard; + + mpPanel->SetExpanded(true); + + if (bCollapseOther) + { + SharedPanelContainer aPanels = mpDeck->GetPanels(); + for (auto const& panel : aPanels) + { + if (! panel->HasIdPredicate(mPanelId)) + panel->SetExpanded(false); + } + } + + SidebarController* pSidebarController = getSidebarController(); + pSidebarController->NotifyResize(); + +} + +void SAL_CALL SfxUnoPanel::collapse() +{ + SolarMutexGuard aGuard; + + mpPanel->SetExpanded(false); + SidebarController* pSidebarController = getSidebarController(); + pSidebarController->NotifyResize(); +} + +uno::Reference<awt::XWindow> SAL_CALL SfxUnoPanel::getDialog() +{ + SolarMutexGuard aGuard; + + return mpPanel->GetElementWindow(); +} + + +sal_Int32 SAL_CALL SfxUnoPanel::getOrderIndex() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + sal_Int32 index = pSidebarController->GetResourceManager()->GetPanelDescriptor(mPanelId)->mnOrderIndex; + return index; +} + +void SAL_CALL SfxUnoPanel::setOrderIndex( const sal_Int32 newOrderIndex ) +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pSidebarController->GetResourceManager()->GetPanelDescriptor(mPanelId); + + if (xPanelDescriptor) + { + xPanelDescriptor->mnOrderIndex = newOrderIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } +} + +void SAL_CALL SfxUnoPanel::moveFirst() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::PanelContextDescriptorContainer aPanels = pSidebarController->GetMatchingPanels(mDeckId); + + sal_Int32 curOrderIndex = getOrderIndex(); + sal_Int32 minIndex = GetMinOrderIndex(aPanels); + + if (curOrderIndex != minIndex) // is current panel already in place ? + { + minIndex -= 1; + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pSidebarController->GetResourceManager()->GetPanelDescriptor(mPanelId); + if (xPanelDescriptor) + { + xPanelDescriptor->mnOrderIndex = minIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +void SAL_CALL SfxUnoPanel::moveLast() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::PanelContextDescriptorContainer aPanels = pSidebarController->GetMatchingPanels(mDeckId); + + sal_Int32 curOrderIndex = getOrderIndex(); + sal_Int32 maxIndex = GetMaxOrderIndex(aPanels); + + if (curOrderIndex != maxIndex) // is current panel already in place ? + { + maxIndex += 1; + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pSidebarController->GetResourceManager()->GetPanelDescriptor(mPanelId); + if (xPanelDescriptor) + { + xPanelDescriptor->mnOrderIndex = maxIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +void SAL_CALL SfxUnoPanel::moveUp() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + // Search for previous panel OrderIndex + ResourceManager::PanelContextDescriptorContainer aPanels = pSidebarController->GetMatchingPanels(mDeckId); + + sal_Int32 curOrderIndex = getOrderIndex(); + sal_Int32 previousIndex = GetMinOrderIndex(aPanels); + + for (auto const& panel : aPanels) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetPanelDescriptor(panel.msId)->mnOrderIndex; + if( index < curOrderIndex && index > previousIndex) + previousIndex = index; + } + + if (curOrderIndex != previousIndex) // is current panel already in place ? + { + previousIndex -= 1; + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pSidebarController->GetResourceManager()->GetPanelDescriptor(mPanelId); + if (xPanelDescriptor) + { + xPanelDescriptor->mnOrderIndex = previousIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +void SAL_CALL SfxUnoPanel::moveDown() +{ + SolarMutexGuard aGuard; + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::PanelContextDescriptorContainer aPanels = pSidebarController->GetMatchingPanels(mDeckId); + + // Search for next panel OrderIndex + sal_Int32 curOrderIndex = getOrderIndex(); + sal_Int32 nextIndex = GetMaxOrderIndex(aPanels); + + for (auto const& panel : aPanels) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetPanelDescriptor(panel.msId)->mnOrderIndex; + if( index > curOrderIndex && index < nextIndex) + nextIndex = index; + } + + if (curOrderIndex != nextIndex) // is current panel already in place ? + { + nextIndex += 1; + std::shared_ptr<PanelDescriptor> xPanelDescriptor = pSidebarController->GetResourceManager()->GetPanelDescriptor(mPanelId); + if (xPanelDescriptor) + { + xPanelDescriptor->mnOrderIndex = nextIndex; + // update the sidebar + pSidebarController->NotifyResize(); + } + } +} + +sal_Int32 SfxUnoPanel::GetMinOrderIndex(ResourceManager::PanelContextDescriptorContainer aPanels) +{ + SidebarController* pSidebarController = getSidebarController(); + + sal_Int32 minIndex = pSidebarController->GetResourceManager()->GetPanelDescriptor(aPanels.begin()->msId)->mnOrderIndex; + + for (auto const& panel : aPanels) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetPanelDescriptor(panel.msId)->mnOrderIndex; + if(minIndex > index) + minIndex = index; + } + return minIndex; +} + +sal_Int32 SfxUnoPanel::GetMaxOrderIndex(ResourceManager::PanelContextDescriptorContainer aPanels) +{ + SidebarController* pSidebarController = getSidebarController(); + + sal_Int32 maxIndex = pSidebarController->GetResourceManager()->GetPanelDescriptor(aPanels.begin()->msId)->mnOrderIndex; + + for (auto const& panel : aPanels) + { + sal_Int32 index = pSidebarController->GetResourceManager()->GetPanelDescriptor(panel.msId)->mnOrderIndex; + if(maxIndex < index) + maxIndex = index; + } + return maxIndex; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/UnoPanels.cxx b/sfx2/source/sidebar/UnoPanels.cxx new file mode 100644 index 000000000..1bc0ded10 --- /dev/null +++ b/sfx2/source/sidebar/UnoPanels.cxx @@ -0,0 +1,161 @@ +/* -*- 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/. + * + */ + +#include <sidebar/UnoPanels.hxx> + +#include <sfx2/sidebar/ResourceManager.hxx> +#include <sfx2/sidebar/SidebarController.hxx> + +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/ui/XPanel.hpp> +#include <sidebar/UnoPanel.hxx> + +#include <vcl/svapp.hxx> + +using namespace css; +using namespace ::sfx2::sidebar; + +SfxUnoPanels::SfxUnoPanels(const uno::Reference<frame::XFrame>& rFrame, const OUString& deckId): +xFrame(rFrame), +mDeckId(deckId) +{ +} + +SidebarController* SfxUnoPanels::getSidebarController() +{ + return SidebarController::GetSidebarControllerForFrame(xFrame); +} + +OUString SAL_CALL SfxUnoPanels::getDeckId() +{ + SolarMutexGuard aGuard; + + return mDeckId; +} + +// XNameAccess + +uno::Any SAL_CALL SfxUnoPanels::getByName( const OUString& aName ) +{ + SolarMutexGuard aGuard; + + if (!hasByName(aName)) + throw container::NoSuchElementException(); + + uno::Reference<ui::XPanel> xPanel = new SfxUnoPanel(xFrame, aName, mDeckId); + return uno::Any(xPanel); +} + + +uno::Sequence< OUString > SAL_CALL SfxUnoPanels::getElementNames() +{ + + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + ResourceManager::PanelContextDescriptorContainer aPanels; + uno::Sequence< OUString > panelList(aPanels.size()); + + if (pSidebarController) + { + pSidebarController->GetResourceManager()->GetMatchingPanels(aPanels, + pSidebarController->GetCurrentContext(), + mDeckId, + xFrame->getController()); + + panelList.realloc(aPanels.size()); + + long n = 0; + + for (const auto& rPanel : aPanels) + { + panelList[n] = rPanel.msId; + n++; + } + } + + return panelList; + +} + +sal_Bool SAL_CALL SfxUnoPanels::hasByName( const OUString& aName ) +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + if (pSidebarController) + { + ResourceManager::PanelContextDescriptorContainer aPanels; + + pSidebarController->GetResourceManager()->GetMatchingPanels(aPanels, + pSidebarController->GetCurrentContext(), + mDeckId, + xFrame->getController()); + + bool bIsDocumentReadOnly = pSidebarController->IsDocumentReadOnly(); + + return std::any_of(aPanels.begin(), aPanels.end(), + [&bIsDocumentReadOnly, &aName](const ResourceManager::PanelContextDescriptor& rPanel) { + return (!bIsDocumentReadOnly || rPanel.mbShowForReadOnlyDocuments) // Determine if the panel can be displayed. + && (rPanel.msId == aName); + }); + } + + // nothing found + return false; + +} + +// XIndexAccess + +sal_Int32 SAL_CALL SfxUnoPanels::getCount() +{ + SolarMutexGuard aGuard; + + uno::Sequence< OUString > panels = getElementNames(); + return panels.getLength(); +} + +uno::Any SAL_CALL SfxUnoPanels::getByIndex( sal_Int32 Index ) +{ + SolarMutexGuard aGuard; + + uno::Any aRet; + + uno::Sequence< OUString > panels = getElementNames(); + + if (Index > panels.getLength()-1 || Index < 0) + throw lang::IndexOutOfBoundsException(); + + uno::Reference<ui::XPanel> xPanel = new SfxUnoPanel(xFrame, panels[Index], mDeckId); + aRet <<= xPanel; + return aRet; + +} + +// XElementAccess +uno::Type SAL_CALL SfxUnoPanels::getElementType() +{ + SolarMutexGuard aGuard; + + return uno::Type(); +} + +sal_Bool SAL_CALL SfxUnoPanels::hasElements() +{ + SolarMutexGuard aGuard; + + uno::Sequence< OUString > panels = getElementNames(); + return panels.hasElements(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/sidebar/UnoSidebar.cxx b/sfx2/source/sidebar/UnoSidebar.cxx new file mode 100644 index 000000000..20a8728d5 --- /dev/null +++ b/sfx2/source/sidebar/UnoSidebar.cxx @@ -0,0 +1,101 @@ +/* -*- 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/. + * + */ + +#include <sidebar/UnoSidebar.hxx> +#include <sidebar/Tools.hxx> + +#include <sfx2/sidebar/SidebarController.hxx> +#include <sidebar/UnoDecks.hxx> + +#include <com/sun/star/frame/XDispatch.hpp> + +#include <vcl/svapp.hxx> + + +using namespace css; +using namespace ::sfx2::sidebar; + +using ::com::sun::star::uno::RuntimeException; + +SfxUnoSidebar::SfxUnoSidebar(const uno::Reference<frame::XFrame>& rFrame): +xFrame(rFrame) +{ +} + +SidebarController* SfxUnoSidebar::getSidebarController() +{ + return SidebarController::GetSidebarControllerForFrame(xFrame); +} + +void SAL_CALL SfxUnoSidebar::showDecks ( const sal_Bool bVisible ) +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + if (pSidebarController) + { + if (bVisible) + pSidebarController->RequestOpenDeck(); + else + pSidebarController->RequestCloseDeck(); + } +} + +void SAL_CALL SfxUnoSidebar::setVisible ( const sal_Bool bVisible ) +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + if ( (bVisible && !pSidebarController) || (!bVisible && pSidebarController) ) + { + const util::URL aURL (Tools::GetURL(".uno:Sidebar")); + uno::Reference<frame::XDispatch> xDispatch (Tools::GetDispatch(xFrame, aURL)); + if (xDispatch.is()) + xDispatch->dispatch(aURL, uno::Sequence<beans::PropertyValue>()); + } + +} + +sal_Bool SAL_CALL SfxUnoSidebar::isVisible() +{ + SolarMutexGuard aGuard; + + SidebarController* pSidebarController = getSidebarController(); + + return pSidebarController != nullptr; +} + +uno::Reference<frame::XFrame> SAL_CALL SfxUnoSidebar::getFrame() +{ + SolarMutexGuard aGuard; + + if (! xFrame.is() ) + throw uno::RuntimeException(); + + return xFrame; +} + +uno::Reference<ui::XDecks> SAL_CALL SfxUnoSidebar::getDecks() +{ + SolarMutexGuard aGuard; + + uno::Reference<ui::XDecks> decks = new SfxUnoDecks(xFrame); + return decks; +} + +uno::Reference<ui::XSidebar> SAL_CALL SfxUnoSidebar::getSidebar() +{ + return getSidebarController(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |