diff options
Diffstat (limited to '')
56 files changed, 11426 insertions, 0 deletions
diff --git a/svx/source/sidebar/ContextChangeEventMultiplexer.cxx b/svx/source/sidebar/ContextChangeEventMultiplexer.cxx new file mode 100644 index 000000000..ce552b0ac --- /dev/null +++ b/svx/source/sidebar/ContextChangeEventMultiplexer.cxx @@ -0,0 +1,90 @@ +/* -*- 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 <svx/sidebar/ContextChangeEventMultiplexer.hxx> + +#include <com/sun/star/ui/ContextChangeEventObject.hpp> +#include <com/sun/star/ui/XContextChangeEventMultiplexer.hpp> +#include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp> +#include <com/sun/star/frame/ModuleManager.hpp> +#include <comphelper/lok.hxx> +#include <comphelper/processfactory.hxx> +#include <sfx2/lokhelper.hxx> +#include <sfx2/viewsh.hxx> + +using namespace css; +using namespace css::uno; + + +void ContextChangeEventMultiplexer::NotifyContextChange ( + const css::uno::Reference<css::frame::XController>& rxController, + const vcl::EnumContext::Context eContext) +{ + if (!(rxController.is() && rxController->getFrame().is())) + return; + + const css::ui::ContextChangeEventObject aEvent( + rxController, + GetModuleName(rxController->getFrame()), + vcl::EnumContext::GetContextName(eContext)); + + css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer ( + css::ui::ContextChangeEventMultiplexer::get( + ::comphelper::getProcessComponentContext())); + if (xMultiplexer.is()) + xMultiplexer->broadcastContextChangeEvent(aEvent, rxController); + + // notify the LOK too after all the change have taken effect. + if (comphelper::LibreOfficeKit::isActive()) + { + if (SfxViewShell* pViewShell = SfxViewShell::Get(rxController)) + SfxLokHelper::notifyContextChange(pViewShell, GetModuleName(rxController->getFrame()), vcl::EnumContext::GetContextName(eContext)); + } +} + + +void ContextChangeEventMultiplexer::NotifyContextChange ( + const SfxViewShell* pViewShell, + const vcl::EnumContext::Context eContext) +{ + if (pViewShell != nullptr) + NotifyContextChange(pViewShell->GetController(), eContext); +} + + +OUString ContextChangeEventMultiplexer::GetModuleName ( + const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + try + { + const Reference<frame::XModuleManager> xModuleManager = + frame::ModuleManager::create( comphelper::getProcessComponentContext() ); + return xModuleManager->identify(rxFrame); + } + catch (const Exception&) + { + // An exception typically means that a context change is notified + // during initialization or destruction of a view. + // Ignore it. + } + return vcl::EnumContext::GetApplicationName( + vcl::EnumContext::Application::NONE); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/EmptyPanel.cxx b/svx/source/sidebar/EmptyPanel.cxx new file mode 100644 index 000000000..3bc21636b --- /dev/null +++ b/svx/source/sidebar/EmptyPanel.cxx @@ -0,0 +1,34 @@ +/* -*- 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 "EmptyPanel.hxx" + +namespace svx::sidebar +{ +EmptyPanel::EmptyPanel(weld::Widget* pParent) + : PanelLayout(pParent, "EmptyPanel", "svx/ui/sidebarempty.ui") + , mxMessageControl(m_xBuilder->weld_label("message")) +{ +} + +EmptyPanel::~EmptyPanel() {} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/EmptyPanel.hxx b/svx/source/sidebar/EmptyPanel.hxx new file mode 100644 index 000000000..26007a530 --- /dev/null +++ b/svx/source/sidebar/EmptyPanel.hxx @@ -0,0 +1,43 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_EMPTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_EMPTYPANEL_HXX + +#include <sfx2/sidebar/PanelLayout.hxx> + +namespace svx::sidebar +{ +/** Display a panel that tells the user that the current deck is + intentionally empty. +*/ +class EmptyPanel final : public PanelLayout +{ +public: + explicit EmptyPanel(weld::Widget* pParent); + virtual ~EmptyPanel() override; + +private: + std::unique_ptr<weld::Label> mxMessageControl; +}; + +} // end of namespace svx::sidebar + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/PanelFactory.cxx b/svx/source/sidebar/PanelFactory.cxx new file mode 100644 index 000000000..f55575d1a --- /dev/null +++ b/svx/source/sidebar/PanelFactory.cxx @@ -0,0 +1,220 @@ +/* -*- 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 <config_features.h> + +#include "text/TextPropertyPanel.hxx" +#include "styles/StylesPropertyPanel.hxx" +#include "paragraph/ParaPropertyPanel.hxx" +#include "lists/ListsPropertyPanel.hxx" +#include "area/AreaPropertyPanel.hxx" +#include "fontwork/FontworkPropertyPanel.hxx" +#include "shadow/ShadowPropertyPanel.hxx" +#include "effect/EffectPropertyPanel.hxx" +#include "graphic/GraphicPropertyPanel.hxx" +#include "line/LinePropertyPanel.hxx" +#include "possize/PosSizePropertyPanel.hxx" +#include "textcolumns/TextColumnsPropertyPanel.hxx" +#include <DefaultShapesPanel.hxx> +#if HAVE_FEATURE_AVMEDIA +#include "media/MediaPlaybackPanel.hxx" +#endif +#include <GalleryControl.hxx> +#include "EmptyPanel.hxx" +#include <sfx2/sidebar/SidebarPanelBase.hxx> +#include <sfx2/templdlg.hxx> +#include <vcl/weldutils.hxx> +#include <comphelper/namedvaluecollection.hxx> +#include <comphelper/compbase.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/ui/XSidebar.hpp> +#include <com/sun/star/ui/XUIElementFactory.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> + +using namespace css; +using namespace css::uno; +using namespace svx::sidebar; + + +namespace { + +/* Why this is not used ? Doesn't it need to inherit from XServiceInfo ? +constexpr OUStringLiteral IMPLEMENTATION_NAME = u"org.apache.openoffice.comp.svx.sidebar.PanelFactory"; +constexpr OUStringLiteral SERVICE_NAME = u"com.sun.star.ui.UIElementFactory"; +*/ + +typedef comphelper::WeakComponentImplHelper< css::ui::XUIElementFactory, css::lang::XServiceInfo > + PanelFactoryInterfaceBase; + +class PanelFactory + : public PanelFactoryInterfaceBase +{ +public: + PanelFactory(); + PanelFactory(const PanelFactory&) = delete; + PanelFactory& operator=(const PanelFactory&) = delete; + + // XUIElementFactory + css::uno::Reference<css::ui::XUIElement> SAL_CALL createUIElement ( + const OUString& rsResourceURL, + const ::css::uno::Sequence<css::beans::PropertyValue>& rArguments) override; + + OUString SAL_CALL getImplementationName() override + { return "org.apache.openoffice.comp.svx.sidebar.PanelFactory"; } + + sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override + { return cppu::supportsService(this, ServiceName); } + + css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override + { return {"com.sun.star.ui.UIElementFactory"}; } +}; + +PanelFactory::PanelFactory() +{ +} + +Reference<ui::XUIElement> SAL_CALL PanelFactory::createUIElement ( + const OUString& rsResourceURL, + const ::css::uno::Sequence<css::beans::PropertyValue>& rArguments) +{ + const ::comphelper::NamedValueCollection aArguments (rArguments); + Reference<frame::XFrame> xFrame (aArguments.getOrDefault("Frame", Reference<frame::XFrame>())); + Reference<awt::XWindow> xParentWindow (aArguments.getOrDefault("ParentWindow", Reference<awt::XWindow>())); + Reference<ui::XSidebar> xSidebar (aArguments.getOrDefault("Sidebar", Reference<ui::XSidebar>())); + const sal_uInt64 nBindingsValue (aArguments.getOrDefault("SfxBindings", sal_uInt64(0))); + SfxBindings* pBindings = reinterpret_cast<SfxBindings*>(nBindingsValue); + + weld::Widget* pParent(nullptr); + if (weld::TransportAsXWindow* pTunnel = dynamic_cast<weld::TransportAsXWindow*>(xParentWindow.get())) + pParent = pTunnel->getWidget(); + + if (!pParent) + throw RuntimeException( + "PanelFactory::createUIElement called without ParentWindow", + nullptr); + if ( ! xFrame.is()) + throw RuntimeException( + "PanelFactory::createUIElement called without Frame", + nullptr); + if (pBindings == nullptr) + throw RuntimeException( + "PanelFactory::createUIElement called without SfxBindings", + nullptr); + + std::unique_ptr<PanelLayout> xControl; + ui::LayoutSize aLayoutSize (-1,-1,-1); + + if (rsResourceURL.endsWith("/TextPropertyPanel")) + { + xControl = TextPropertyPanel::Create(pParent, xFrame); + } + else if (rsResourceURL.endsWith("/StylesPropertyPanel")) + { + xControl = StylesPropertyPanel::Create(pParent, xFrame); + } + else if (rsResourceURL.endsWith("/ParaPropertyPanel")) + { + xControl = ParaPropertyPanel::Create(pParent, xFrame, pBindings, xSidebar); + } + else if (rsResourceURL.endsWith("/ListsPropertyPanel")) + { + xControl = ListsPropertyPanel::Create(pParent, xFrame); + } + else if (rsResourceURL.endsWith("/AreaPropertyPanel")) + { + xControl = AreaPropertyPanel::Create(pParent, xFrame, pBindings); + } + else if (rsResourceURL.endsWith("/FontworkPropertyPanel")) + { + xControl = FontworkPropertyPanel::Create(pParent, xFrame); + } + else if (rsResourceURL.endsWith("/ShadowPropertyPanel")) + { + xControl = ShadowPropertyPanel::Create(pParent, pBindings); + } + else if (rsResourceURL.endsWith("/EffectPropertyPanel")) + { + xControl = EffectPropertyPanel::Create(pParent, pBindings); + } + else if (rsResourceURL.endsWith("/GraphicPropertyPanel")) + { + xControl = GraphicPropertyPanel::Create(pParent, pBindings); + } + else if (rsResourceURL.endsWith("/LinePropertyPanel")) + { + xControl = LinePropertyPanel::Create(pParent, xFrame, pBindings); + } + else if (rsResourceURL.endsWith("/PosSizePropertyPanel")) + { + xControl = PosSizePropertyPanel::Create(pParent, xFrame, pBindings, xSidebar); + } + else if (rsResourceURL.endsWith("/DefaultShapesPanel")) + { + xControl = DefaultShapesPanel::Create(pParent, xFrame); + } +#if HAVE_FEATURE_AVMEDIA + else if (rsResourceURL.endsWith("/MediaPlaybackPanel")) + { + xControl = MediaPlaybackPanel::Create(pParent, pBindings); + } +#endif + else if (rsResourceURL.endsWith("/GalleryPanel")) + { + xControl = std::make_unique<GalleryControl>(pParent); + aLayoutSize = ui::LayoutSize(300,-1,400); + } + else if (rsResourceURL.endsWith("/StyleListPanel")) + { + xControl = std::make_unique<SfxTemplatePanelControl>(pBindings, pParent); + aLayoutSize = ui::LayoutSize(0,-1,-1); + } + else if (rsResourceURL.endsWith("/EmptyPanel")) + { + xControl = std::make_unique<EmptyPanel>(pParent); + aLayoutSize = ui::LayoutSize(20,-1, 50); + } + else if (rsResourceURL.endsWith("/TextColumnsPropertyPanel")) + { + xControl = TextColumnsPropertyPanel::Create(pParent, pBindings); + } + + if (xControl) + { + return sfx2::sidebar::SidebarPanelBase::Create( + rsResourceURL, + xFrame, + std::move(xControl), + aLayoutSize); + } + else + return Reference<ui::XUIElement>(); +} + +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +org_apache_openoffice_comp_svx_sidebar_PanelFactory_get_implementation( + css::uno::XComponentContext *, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new PanelFactory); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/SelectionAnalyzer.cxx b/svx/source/sidebar/SelectionAnalyzer.cxx new file mode 100644 index 000000000..193b6b6b7 --- /dev/null +++ b/svx/source/sidebar/SelectionAnalyzer.cxx @@ -0,0 +1,479 @@ +/* -*- 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 <svx/sidebar/SelectionAnalyzer.hxx> +#include <svx/svdmark.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdotext.hxx> +#include <svx/svdpage.hxx> +#include <svx/fontworkbar.hxx> + +using vcl::EnumContext; + +namespace svx::sidebar +{ +EnumContext::Context SelectionAnalyzer::GetContextForSelection_SC(const SdrMarkList& rMarkList) +{ + EnumContext::Context eContext = EnumContext::Context::Unknown; + + switch (rMarkList.GetMarkCount()) + { + case 0: + // Empty selection. Return Context::Unknown to let the caller + // substitute it with the default context. + break; + + case 1: + { + SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + auto pTextObj = dynamic_cast<SdrTextObj*>(pObj); + if (pTextObj && pTextObj->IsInEditMode()) + { + eContext = EnumContext::Context::DrawText; + } + else if (svx::checkForFontWork(pObj)) + { + eContext = EnumContext::Context::DrawFontwork; + } + else + { + const SdrInventor nInv = pObj->GetObjInventor(); + const SdrObjKind nObjId = pObj->GetObjIdentifier(); + if (nInv == SdrInventor::Default) + eContext = GetContextForObjectId_SC(nObjId); + else if (nInv == SdrInventor::FmForm) + eContext = EnumContext::Context::Form; + } + break; + } + + default: + { + // Multi selection. + switch (GetInventorTypeFromMark(rMarkList)) + { + case SdrInventor::Default: + { + const SdrObjKind nObjId(GetObjectTypeFromMark(rMarkList)); + if (nObjId == SdrObjKind::NONE) + eContext = EnumContext::Context::MultiObject; + else + eContext = GetContextForObjectId_SC(nObjId); + break; + } + + case SdrInventor::FmForm: + eContext = EnumContext::Context::Form; + break; + + case SdrInventor::Unknown: + eContext = EnumContext::Context::MultiObject; + break; + + default: + break; + } + } + } + + return eContext; +} + +EnumContext::Context SelectionAnalyzer::GetContextForSelection_SD(const SdrMarkList& rMarkList, + const ViewType eViewType) +{ + EnumContext::Context eContext = EnumContext::Context::Unknown; + + // Note that some cases are handled by the caller. They rely on + // sd specific data. + switch (rMarkList.GetMarkCount()) + { + case 0: + switch (eViewType) + { + case ViewType::Standard: + eContext = EnumContext::Context::DrawPage; + break; + case ViewType::Master: + eContext = EnumContext::Context::MasterPage; + break; + case ViewType::Handout: + eContext = EnumContext::Context::HandoutPage; + break; + case ViewType::Notes: + eContext = EnumContext::Context::NotesPage; + break; + } + break; + + case 1: + { + SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + auto pTextObj = dynamic_cast<SdrTextObj*>(pObj); + if (pTextObj && pTextObj->IsInEditMode()) + { + if (pObj->GetObjIdentifier() == SdrObjKind::Table) + { + // Let a table object take precedence over text + // edit mode. The panels for text editing are + // present for table context as well, anyway. + eContext = EnumContext::Context::Table; + } + else + eContext = EnumContext::Context::DrawText; + } + else if (svx::checkForFontWork(pObj)) + { + eContext = EnumContext::Context::DrawFontwork; + } + else + { + const SdrInventor nInv = pObj->GetObjInventor(); + SdrObjKind nObjId = pObj->GetObjIdentifier(); + if (nInv == SdrInventor::Default) + { + if (nObjId == SdrObjKind::Group) + { + nObjId = GetObjectTypeFromGroup(pObj); + if (nObjId == SdrObjKind::NONE) + nObjId = SdrObjKind::Group; + } + eContext = GetContextForObjectId_SD(nObjId, eViewType); + } + else if (nInv == SdrInventor::E3d) + { + eContext = EnumContext::Context::ThreeDObject; + } + else if (nInv == SdrInventor::FmForm) + { + eContext = EnumContext::Context::Form; + } + } + break; + } + + default: + { + switch (GetInventorTypeFromMark(rMarkList)) + { + case SdrInventor::Default: + { + const SdrObjKind nObjId = GetObjectTypeFromMark(rMarkList); + if (nObjId == SdrObjKind::NONE) + eContext = EnumContext::Context::MultiObject; + else + eContext = GetContextForObjectId_SD(nObjId, eViewType); + break; + } + + case SdrInventor::E3d: + eContext = EnumContext::Context::ThreeDObject; + break; + + case SdrInventor::FmForm: + eContext = EnumContext::Context::Form; + break; + + case SdrInventor::Unknown: + eContext = EnumContext::Context::MultiObject; + break; + + default: + break; + } + break; + } + } + + return eContext; +} + +EnumContext::Context SelectionAnalyzer::GetContextForObjectId_SC(const SdrObjKind nObjectId) +{ + switch (nObjectId) + { + case SdrObjKind::Caption: + case SdrObjKind::TitleText: + case SdrObjKind::OutlineText: + case SdrObjKind::Text: + case SdrObjKind::Measure: + case SdrObjKind::Rectangle: + case SdrObjKind::CircleOrEllipse: + case SdrObjKind::FreehandFill: + case SdrObjKind::PathFill: + case SdrObjKind::Polygon: + case SdrObjKind::CircleSection: + case SdrObjKind::CircleArc: + case SdrObjKind::CircleCut: + case SdrObjKind::CustomShape: + case SdrObjKind::Group: + return EnumContext::Context::Draw; + + case SdrObjKind::PolyLine: + case SdrObjKind::PathLine: + case SdrObjKind::FreehandLine: + case SdrObjKind::Line: + case SdrObjKind::Edge: + return EnumContext::Context::DrawLine; + + case SdrObjKind::Graphic: + return EnumContext::Context::Graphic; + + case SdrObjKind::OLE2: + return EnumContext::Context::OLE; + + case SdrObjKind::Media: + return EnumContext::Context::Media; + + default: + return EnumContext::Context::Unknown; + } +} + +EnumContext::Context SelectionAnalyzer::GetContextForObjectId_SD(const SdrObjKind nObjectId, + const ViewType eViewType) +{ + switch (nObjectId) + { + case SdrObjKind::Caption: + case SdrObjKind::Measure: + case SdrObjKind::Rectangle: + case SdrObjKind::CircleOrEllipse: + case SdrObjKind::FreehandFill: + case SdrObjKind::PathFill: + case SdrObjKind::Polygon: + case SdrObjKind::CircleSection: + case SdrObjKind::CircleArc: + case SdrObjKind::CircleCut: + case SdrObjKind::CustomShape: + case SdrObjKind::Group: + return EnumContext::Context::Draw; + + case SdrObjKind::Edge: + case SdrObjKind::PathLine: + case SdrObjKind::FreehandLine: + case SdrObjKind::PolyLine: + case SdrObjKind::Line: + return EnumContext::Context::DrawLine; + + case SdrObjKind::TitleText: + case SdrObjKind::OutlineText: + case SdrObjKind::Text: + return EnumContext::Context::TextObject; + + case SdrObjKind::Graphic: + return EnumContext::Context::Graphic; + + case SdrObjKind::OLE2: + return EnumContext::Context::OLE; + + case SdrObjKind::Media: + return EnumContext::Context::Media; + + case SdrObjKind::Table: + return EnumContext::Context::Table; + + case SdrObjKind::Page: + switch (eViewType) + { + case ViewType::Handout: + return EnumContext::Context::HandoutPage; + case ViewType::Notes: + return EnumContext::Context::NotesPage; + default: + return EnumContext::Context::Unknown; + } + + default: + return EnumContext::Context::Unknown; + } +} + +SdrInventor SelectionAnalyzer::GetInventorTypeFromMark(const SdrMarkList& rMarkList) +{ + const size_t nMarkCount(rMarkList.GetMarkCount()); + + if (nMarkCount < 1) + return SdrInventor::Unknown; + + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + const SdrInventor nFirstInv = pObj->GetObjInventor(); + + for (size_t nIndex = 1; nIndex < nMarkCount; ++nIndex) + { + pMark = rMarkList.GetMark(nIndex); + pObj = pMark->GetMarkedSdrObj(); + const SdrInventor nInv(pObj->GetObjInventor()); + + if (nInv != nFirstInv) + return SdrInventor::Unknown; + } + + return nFirstInv; +} + +SdrObjKind SelectionAnalyzer::GetObjectTypeFromGroup(const SdrObject* pObj) +{ + SdrObjList* pObjList = pObj->GetSubList(); + if (pObjList) + { + const size_t nSubObjCount(pObjList->GetObjCount()); + + if (nSubObjCount > 0) + { + SdrObject* pSubObj = pObjList->GetObj(0); + SdrObjKind nResultType = pSubObj->GetObjIdentifier(); + + if (nResultType == SdrObjKind::Group) + nResultType = GetObjectTypeFromGroup(pSubObj); + + if (IsShapeType(nResultType)) + nResultType = SdrObjKind::CustomShape; + + if (IsTextObjType(nResultType)) + nResultType = SdrObjKind::Text; + + for (size_t nIndex = 1; nIndex < nSubObjCount; ++nIndex) + { + pSubObj = pObjList->GetObj(nIndex); + SdrObjKind nType(pSubObj->GetObjIdentifier()); + + if (nType == SdrObjKind::Group) + nType = GetObjectTypeFromGroup(pSubObj); + + if (IsShapeType(nType)) + nType = SdrObjKind::CustomShape; + + if ((nType == SdrObjKind::CustomShape) && (nResultType == SdrObjKind::Text)) + nType = SdrObjKind::Text; + + if (IsTextObjType(nType)) + nType = SdrObjKind::Text; + + if ((nType == SdrObjKind::Text) && (nResultType == SdrObjKind::CustomShape)) + nResultType = SdrObjKind::Text; + + if (nType != nResultType) + return SdrObjKind::NONE; + } + + return nResultType; + } + } + + return SdrObjKind::NONE; +} + +SdrObjKind SelectionAnalyzer::GetObjectTypeFromMark(const SdrMarkList& rMarkList) +{ + const size_t nMarkCount(rMarkList.GetMarkCount()); + + if (nMarkCount < 1) + return SdrObjKind::NONE; + + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + SdrObjKind nResultType = pObj->GetObjIdentifier(); + + if (nResultType == SdrObjKind::Group) + nResultType = GetObjectTypeFromGroup(pObj); + + if (IsShapeType(nResultType)) + nResultType = SdrObjKind::CustomShape; + + if (IsTextObjType(nResultType)) + nResultType = SdrObjKind::Text; + + for (size_t nIndex = 1; nIndex < nMarkCount; ++nIndex) + { + pMark = rMarkList.GetMark(nIndex); + pObj = pMark->GetMarkedSdrObj(); + SdrObjKind nType = pObj->GetObjIdentifier(); + + if (nType == SdrObjKind::Group) + nType = GetObjectTypeFromGroup(pObj); + + if (IsShapeType(nType)) + nType = SdrObjKind::CustomShape; + + if ((nType == SdrObjKind::CustomShape) && (nResultType == SdrObjKind::Text)) + nType = SdrObjKind::Text; + + if (IsTextObjType(nType)) + nType = SdrObjKind::Text; + + if ((nType == SdrObjKind::Text) && (nResultType == SdrObjKind::CustomShape)) + nResultType = SdrObjKind::Text; + + if (nType != nResultType) + return SdrObjKind::NONE; + } + + return nResultType; +} + +bool SelectionAnalyzer::IsShapeType(const SdrObjKind nType) +{ + switch (nType) + { + case SdrObjKind::Line: + case SdrObjKind::CircleArc: + case SdrObjKind::PolyLine: + case SdrObjKind::PathLine: + case SdrObjKind::Rectangle: + case SdrObjKind::CircleOrEllipse: + case SdrObjKind::CircleSection: + case SdrObjKind::CircleCut: + case SdrObjKind::PathFill: + case SdrObjKind::CustomShape: + case SdrObjKind::Caption: + case SdrObjKind::Measure: + case SdrObjKind::Edge: + case SdrObjKind::Polygon: + case SdrObjKind::FreehandLine: + case SdrObjKind::FreehandFill: + + // #122145# adding SdrObjKind::OLE2 since these also allow line/fill style and may + // be multiselected/grouped with normal draw objects, e.g. math OLE objects + case SdrObjKind::OLE2: + return true; + + default: + return false; + } +} + +bool SelectionAnalyzer::IsTextObjType(const SdrObjKind nType) +{ + switch (nType) + { + case SdrObjKind::Text: + case SdrObjKind::TitleText: + case SdrObjKind::OutlineText: + return true; + + default: + return false; + } +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/SelectionChangeHandler.cxx b/svx/source/sidebar/SelectionChangeHandler.cxx new file mode 100644 index 000000000..f4ef4d893 --- /dev/null +++ b/svx/source/sidebar/SelectionChangeHandler.cxx @@ -0,0 +1,100 @@ +/* -*- 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 <svx/sidebar/SelectionChangeHandler.hxx> +#include <svx/sidebar/ContextChangeEventMultiplexer.hxx> + +#include <com/sun/star/view/XSelectionSupplier.hpp> + +#include <vcl/EnumContext.hxx> + + +using namespace css; +using namespace css::uno; + +namespace svx::sidebar { + +SelectionChangeHandler::SelectionChangeHandler ( + const std::function<OUString()>& rSelectionChangeCallback, + const Reference<css::frame::XController>& rxController, + const vcl::EnumContext::Context eDefaultContext) + : maSelectionChangeCallback(rSelectionChangeCallback), + mxController(rxController), + meDefaultContext(eDefaultContext), + mbIsConnected(false) +{ +} + + +SelectionChangeHandler::~SelectionChangeHandler() +{ +} + + +void SAL_CALL SelectionChangeHandler::selectionChanged (const lang::EventObject&) +{ + if (maSelectionChangeCallback) + { + const vcl::EnumContext::Context eContext ( + vcl::EnumContext::GetContextEnum(maSelectionChangeCallback())); + ContextChangeEventMultiplexer::NotifyContextChange( + mxController, + eContext==vcl::EnumContext::Context::Unknown + ? meDefaultContext + : eContext); + } +} + + +void SAL_CALL SelectionChangeHandler::disposing (const lang::EventObject&) +{ +} + + +void SelectionChangeHandler::disposing(std::unique_lock<std::mutex>&) +{ + if (mbIsConnected) + Disconnect(); +} + + +void SelectionChangeHandler::Connect() +{ + uno::Reference<view::XSelectionSupplier> xSupplier (mxController, uno::UNO_QUERY); + if (xSupplier.is()) + { + mbIsConnected = true; + xSupplier->addSelectionChangeListener(this); + } +} + + +void SelectionChangeHandler::Disconnect() +{ + uno::Reference<view::XSelectionSupplier> xSupplier (mxController, uno::UNO_QUERY); + if (xSupplier.is()) + { + mbIsConnected = false; + xSupplier->removeSelectionChangeListener(this); + } +} + + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/area/AreaPropertyPanel.cxx b/svx/source/sidebar/area/AreaPropertyPanel.cxx new file mode 100644 index 000000000..fa634ee44 --- /dev/null +++ b/svx/source/sidebar/area/AreaPropertyPanel.cxx @@ -0,0 +1,158 @@ +/* -*- 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 "AreaPropertyPanel.hxx" +#include <svx/svxids.hrc> +#include <svx/xfltrit.hxx> +#include <svx/xflftrit.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/bindings.hxx> + + +using namespace css; +using namespace css::uno; + +namespace svx::sidebar { + +AreaPropertyPanel::AreaPropertyPanel( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings) + : AreaPropertyPanelBase(pParent, rxFrame), + maStyleControl(SID_ATTR_FILL_STYLE, *pBindings, *this), + maColorControl(SID_ATTR_FILL_COLOR, *pBindings, *this), + maGradientControl(SID_ATTR_FILL_GRADIENT, *pBindings, *this), + maHatchControl(SID_ATTR_FILL_HATCH, *pBindings, *this), + maBitmapControl(SID_ATTR_FILL_BITMAP, *pBindings, *this), + maGradientListControl(SID_GRADIENT_LIST, *pBindings, *this), + maHatchListControl(SID_HATCH_LIST, *pBindings, *this), + maBitmapListControl(SID_BITMAP_LIST, *pBindings, *this), + maPatternListControl(SID_PATTERN_LIST, *pBindings, *this), + maFillTransparenceController(SID_ATTR_FILL_TRANSPARENCE, *pBindings, *this), + maFillFloatTransparenceController(SID_ATTR_FILL_FLOATTRANSPARENCE, *pBindings, *this), + maFillUseSlideBackgroundController(SID_ATTR_FILL_USE_SLIDE_BACKGROUND, *pBindings, *this), + mpBindings(pBindings) +{ +} + +AreaPropertyPanel::~AreaPropertyPanel() +{ + maStyleControl.dispose(); + maColorControl.dispose(); + maGradientControl.dispose(); + maHatchControl.dispose(); + maBitmapControl.dispose(); + maGradientListControl.dispose(); + maHatchListControl.dispose(); + maBitmapListControl.dispose(); + maPatternListControl.dispose(); + maFillTransparenceController.dispose(); + maFillFloatTransparenceController.dispose(); +} + +std::unique_ptr<PanelLayout> AreaPropertyPanel::Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to AreaPropertyPanel::Create", nullptr, 0); + if ( ! rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to AreaPropertyPanel::Create", nullptr, 1); + if (pBindings == nullptr) + throw lang::IllegalArgumentException("no SfxBindings given to AreaPropertyPanel::Create", nullptr, 2); + + return std::make_unique<AreaPropertyPanel>(pParent, rxFrame, pBindings); +} + +void AreaPropertyPanel::setFillTransparence(const XFillTransparenceItem& rItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_TRANSPARENCE, + SfxCallMode::RECORD, { &rItem }); +} + +void AreaPropertyPanel::setFillUseBackground(const XFillStyleItem* pStyleItem, + const XFillUseSlideBackgroundItem& rItem) +{ + const SfxPoolItem* pItem = nullptr; + auto pDispatcher = GetBindings()->GetDispatcher(); + auto state = pDispatcher->QueryState(SID_ATTR_FILL_USE_SLIDE_BACKGROUND, pItem); + // FillUseSlideBackground is only available in Impress + if (state == SfxItemState::DISABLED) + { + setFillStyle(*pStyleItem); + } + else + { + pDispatcher->ExecuteList(SID_ATTR_FILL_USE_SLIDE_BACKGROUND, SfxCallMode::RECORD, + std::initializer_list<SfxPoolItem const*>{ &rItem, pStyleItem }); + } +} + +void AreaPropertyPanel::setFillFloatTransparence(const XFillFloatTransparenceItem& rItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_FLOATTRANSPARENCE, + SfxCallMode::RECORD, { &rItem }); +} + +void AreaPropertyPanel::setFillStyle(const XFillStyleItem& rItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_STYLE, + SfxCallMode::RECORD, { &rItem }); +} + +void AreaPropertyPanel::setFillStyleAndColor(const XFillStyleItem* pStyleItem, + const XFillColorItem& rColorItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_COLOR, + SfxCallMode::RECORD, pStyleItem + ? std::initializer_list<SfxPoolItem const*>{ &rColorItem, pStyleItem } + : std::initializer_list<SfxPoolItem const*>{ &rColorItem }); +} + +void AreaPropertyPanel::setFillStyleAndGradient(const XFillStyleItem* pStyleItem, + const XFillGradientItem& rGradientItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_GRADIENT, + SfxCallMode::RECORD, pStyleItem + ? std::initializer_list<SfxPoolItem const*>{ &rGradientItem, pStyleItem } + : std::initializer_list<SfxPoolItem const*>{ &rGradientItem }); +} + +void AreaPropertyPanel::setFillStyleAndHatch(const XFillStyleItem* pStyleItem, + const XFillHatchItem& rHatchItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_HATCH, + SfxCallMode::RECORD, pStyleItem + ? std::initializer_list<SfxPoolItem const*>{ &rHatchItem, pStyleItem } + : std::initializer_list<SfxPoolItem const*>{ &rHatchItem }); +} + +void AreaPropertyPanel::setFillStyleAndBitmap(const XFillStyleItem* pStyleItem, + const XFillBitmapItem& rBitmapItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_BITMAP, + SfxCallMode::RECORD, pStyleItem + ? std::initializer_list<SfxPoolItem const*>{ &rBitmapItem, pStyleItem } + : std::initializer_list<SfxPoolItem const*>{ &rBitmapItem }); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/area/AreaPropertyPanel.hxx b/svx/source/sidebar/area/AreaPropertyPanel.hxx new file mode 100644 index 000000000..6c398e6ac --- /dev/null +++ b/svx/source/sidebar/area/AreaPropertyPanel.hxx @@ -0,0 +1,94 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_AREA_AREAPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_AREA_AREAPROPERTYPANEL_HXX + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xbtmpit.hxx> + +#include <svx/sidebar/AreaPropertyPanelBase.hxx> + +class XFillFloatTransparenceItem; +class XFillTransparenceItem; +class XFillUseSlideBackgroundItem; +class XFillStyleItem; +class XFillGradientItem; +class XFillColorItem; +class XFillHatchItem; +class XFillBitmapItem; + +namespace svx::sidebar { + +class AreaTransparencyGradientControl; + +class AreaPropertyPanel : public AreaPropertyPanelBase +{ +public: + static std::unique_ptr<PanelLayout> Create( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings); + + SfxBindings* GetBindings() { return mpBindings;} + + // constructor/destructor + AreaPropertyPanel( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings); + + virtual ~AreaPropertyPanel() override; + + virtual void setFillTransparence(const XFillTransparenceItem& rItem) override; + virtual void setFillUseBackground(const XFillStyleItem* pStyleItem, const XFillUseSlideBackgroundItem& rItem) override; + virtual void setFillFloatTransparence(const XFillFloatTransparenceItem& rItem) override; + virtual void setFillStyle(const XFillStyleItem& rItem) override; + virtual void setFillStyleAndColor(const XFillStyleItem* pStyleItem, const XFillColorItem& aColorItem) override; + virtual void setFillStyleAndGradient(const XFillStyleItem* pStyleItem, const XFillGradientItem& aGradientItem) override; + virtual void setFillStyleAndHatch(const XFillStyleItem* pStyleItem, const XFillHatchItem& aHatchItem) override; + virtual void setFillStyleAndBitmap(const XFillStyleItem* pStyleItem, const XFillBitmapItem& aHatchItem) override; + +private: + ::sfx2::sidebar::ControllerItem maStyleControl; + ::sfx2::sidebar::ControllerItem maColorControl; + ::sfx2::sidebar::ControllerItem maGradientControl; + ::sfx2::sidebar::ControllerItem maHatchControl; + ::sfx2::sidebar::ControllerItem maBitmapControl; + ::sfx2::sidebar::ControllerItem maGradientListControl; + ::sfx2::sidebar::ControllerItem maHatchListControl; + ::sfx2::sidebar::ControllerItem maBitmapListControl; + ::sfx2::sidebar::ControllerItem maPatternListControl; + ::sfx2::sidebar::ControllerItem maFillTransparenceController; + ::sfx2::sidebar::ControllerItem maFillFloatTransparenceController; + ::sfx2::sidebar::ControllerItem maFillUseSlideBackgroundController; + + SfxBindings* mpBindings; +}; + + +} // end of namespace svx::sidebar + + +#endif // INCLUDED_SVX_SOURCE_SIDEBAR_AREA_AREAPROPERTYPANEL_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/area/AreaPropertyPanelBase.cxx b/svx/source/sidebar/area/AreaPropertyPanelBase.cxx new file mode 100644 index 000000000..672ab145f --- /dev/null +++ b/svx/source/sidebar/area/AreaPropertyPanelBase.cxx @@ -0,0 +1,1371 @@ +/* -*- 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 <osl/diagnose.h> +#include <svx/sidebar/AreaPropertyPanelBase.hxx> +#include <svx/drawitem.hxx> +#include <svx/itemwin.hxx> +#include <svx/svxids.hrc> +#include <sfx2/objsh.hxx> +#include <svx/xfltrit.hxx> +#include <svx/xflftrit.hxx> +#include <svx/xfilluseslidebackgrounditem.hxx> +#include <svx/xtable.hxx> +#include <sfx2/sidebar/Panel.hxx> +#include <sfx2/opengrf.hxx> +#include <sfx2/weldutils.hxx> +#include <tools/urlobj.hxx> +#include <bitmaps.hlst> +#include <comphelper/lok.hxx> + +using namespace css; +using namespace css::uno; + +constexpr OStringLiteral SIDEBARGRADIENT = "sidebargradient"; + +namespace svx::sidebar { + +namespace { + +enum eFillStyle +{ + NONE, + SOLID, + GRADIENT, + HATCH, + BITMAP, + PATTERN, + USE_BACKGROUND +}; + +} + +const sal_Int32 AreaPropertyPanelBase::DEFAULT_CENTERX = 50; +const sal_Int32 AreaPropertyPanelBase::DEFAULT_CENTERY = 50; +const sal_Int32 AreaPropertyPanelBase::DEFAULT_ANGLE = 0; +const sal_Int32 AreaPropertyPanelBase::DEFAULT_STARTVALUE = 0; +const sal_Int32 AreaPropertyPanelBase::DEFAULT_ENDVALUE = 16777215; +const sal_Int32 AreaPropertyPanelBase::DEFAULT_BORDER = 0; + +AreaPropertyPanelBase::AreaPropertyPanelBase( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) + : PanelLayout(pParent, "AreaPropertyPanel", "svx/ui/sidebararea.ui"), + mxFrame(rxFrame), + meLastXFS(static_cast<sal_uInt16>(-1)), + mnLastPosHatch(0), + mnLastPosBitmap(0), + mnLastPosPattern(0), + mnLastTransSolid(50), + mxColorTextFT(m_xBuilder->weld_label("filllabel")), + mxLbFillType(m_xBuilder->weld_combo_box("fillstylearea")), + mxLbFillAttr(m_xBuilder->weld_combo_box("fillattrhb")), + mxLbFillGradFrom(new ColorListBox(m_xBuilder->weld_menu_button("fillgrad1"), [this]{ return GetFrameWeld(); })), + mxLbFillGradTo(new ColorListBox(m_xBuilder->weld_menu_button("fillgrad2"), [this]{ return GetFrameWeld(); })), + mxToolBoxColor(m_xBuilder->weld_toolbar("selectcolor")), + mxColorDispatch(new ToolbarUnoDispatcher(*mxToolBoxColor, *m_xBuilder, rxFrame)), + mxTrspTextFT(m_xBuilder->weld_label("transparencylabel")), + mxLBTransType(m_xBuilder->weld_combo_box("transtype")), + mxMTRTransparent(m_xBuilder->weld_metric_spin_button("settransparency", FieldUnit::PERCENT)), + mxSldTransparent(m_xBuilder->weld_scale("transparencyslider")), + mxBTNGradient(m_xBuilder->weld_toolbar("selectgradient")), + mxMTRAngle(m_xBuilder->weld_metric_spin_button("gradangle", FieldUnit::DEGREE)), + mxGradientStyle(m_xBuilder->weld_combo_box("gradientstyle")), + mxBmpImport(m_xBuilder->weld_button("bmpimport")), + maImgAxial(BMP_AXIAL), + maImgElli(BMP_ELLI), + maImgQuad(BMP_QUAD), + maImgRadial(BMP_RADIAL), + maImgSquare(BMP_SQUARE), + maImgLinear(BMP_LINEAR) +{ + Initialize(); +} + +AreaPropertyPanelBase::~AreaPropertyPanelBase() +{ + mxTrGrPopup.reset(); + mxColorTextFT.reset(); + mxLbFillType.reset(); + mxLbFillAttr.reset(); + mxColorDispatch.reset(); + mxToolBoxColor.reset(); + mxTrspTextFT.reset(); + mxLBTransType.reset(); + mxMTRTransparent.reset(); + mxSldTransparent.reset(); + mxBTNGradient.reset(); + mxMTRAngle.reset(); + mxLbFillGradFrom.reset(); + mxLbFillGradTo.reset(); + mxGradientStyle.reset(); + mxBmpImport.reset(); +} + +void AreaPropertyPanelBase::Initialize() +{ + SvxFillTypeBox::Fill(*mxLbFillType); + + mxLbFillAttr->set_size_request(42, -1); + + maGradientLinear.SetXOffset(DEFAULT_CENTERX); + maGradientLinear.SetYOffset(DEFAULT_CENTERY); + maGradientLinear.SetAngle(Degree10(DEFAULT_ANGLE)); + maGradientLinear.SetStartColor(Color(DEFAULT_STARTVALUE)); + maGradientLinear.SetEndColor(Color(DEFAULT_ENDVALUE)); + maGradientLinear.SetBorder(DEFAULT_BORDER); + maGradientLinear.SetGradientStyle(css::awt::GradientStyle_LINEAR); + + maGradientAxial = maGradientLinear; + maGradientAxial.SetGradientStyle(css::awt::GradientStyle_AXIAL); + + maGradientRadial = maGradientLinear; + maGradientRadial.SetGradientStyle(css::awt::GradientStyle_RADIAL); + + maGradientElliptical = maGradientLinear; + maGradientElliptical.SetGradientStyle(css::awt::GradientStyle_ELLIPTICAL); + + maGradientSquare = maGradientLinear; + maGradientSquare.SetGradientStyle(css::awt::GradientStyle_SQUARE); + + maGradientRect = maGradientLinear; + maGradientRect.SetGradientStyle(css::awt::GradientStyle_RECT); + + + mxLbFillType->connect_changed( LINK( this, AreaPropertyPanelBase, SelectFillTypeHdl ) ); + + Link<weld::ComboBox&,void> aLink = LINK( this, AreaPropertyPanelBase, SelectFillAttrHdl ); + mxLbFillAttr->connect_changed( aLink ); + mxGradientStyle->connect_changed( aLink ); + Link<ColorListBox&,void> aLink3 = LINK( this, AreaPropertyPanelBase, SelectFillColorHdl ); + mxLbFillGradFrom->SetSelectHdl( aLink3 ); + mxLbFillGradTo->SetSelectHdl( aLink3 ); + mxMTRAngle->connect_value_changed(LINK(this,AreaPropertyPanelBase, ChangeGradientAngle)); + + // https://gerrit.libreoffice.org/c/core/+/87313 set a small width to force widgets to + // take their final width from other widgets in the grid + mxLbFillGradFrom->get_widget().set_size_request(42, -1); + mxLbFillGradTo->get_widget().set_size_request(42, -1); + + mxLBTransType->connect_changed(LINK(this, AreaPropertyPanelBase, ChangeTrgrTypeHdl_Impl)); + + SetTransparency( 50 ); + mxMTRTransparent->connect_value_changed(LINK(this, AreaPropertyPanelBase, ModifyTransparentHdl_Impl)); + mxSldTransparent->connect_value_changed(LINK(this, AreaPropertyPanelBase, ModifyTransSliderHdl)); + + mxTrGrPopup = std::make_unique<AreaTransparencyGradientPopup>(mxFrame, *this, mxBTNGradient.get()); + + mxBTNGradient->set_item_popover(SIDEBARGRADIENT, mxTrGrPopup->getTopLevel()); + mxBTNGradient->connect_clicked(LINK(this, AreaPropertyPanelBase, ToolbarHdl_Impl)); + + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgLinear); + mxBTNGradient->hide(); + mxBmpImport->connect_clicked( LINK(this, AreaPropertyPanelBase, ClickImportBitmapHdl)); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, ToolbarHdl_Impl, const OString&, void) +{ + mxBTNGradient->set_menu_item_active(SIDEBARGRADIENT, !mxBTNGradient->get_menu_item_active(SIDEBARGRADIENT)); +} + +void AreaPropertyPanelBase::SetTransparency(sal_uInt16 nVal) +{ + mxSldTransparent->set_value(nVal); + mxMTRTransparent->set_value(nVal, FieldUnit::PERCENT); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, ClickImportBitmapHdl, weld::Button&, void) +{ + SvxOpenGraphicDialog aDlg("Import", GetFrameWeld()); + aDlg.EnableLink(false); + if( aDlg.Execute() != ERRCODE_NONE ) + return; + + Graphic aGraphic; + auto xWait = std::make_unique<weld::WaitObject>(m_xContainer.get()); + ErrCode nError = aDlg.GetGraphic( aGraphic ); + xWait.reset(); + if( nError != ERRCODE_NONE ) + return; + + mxLbFillAttr->clear(); + + if (SfxObjectShell* pSh = SfxObjectShell::Current()) + { + INetURLObject aURL(aDlg.GetPath()); + OUString aFileName = aURL.GetLastName().getToken(0, '.'); + OUString aName = aFileName; + + XBitmapListRef pList = pSh->GetItem(SID_BITMAP_LIST)->GetBitmapList(); + + tools::Long j = 1; + bool bValidBitmapName = false; + while( !bValidBitmapName ) + { + bValidBitmapName = true; + for( tools::Long i = 0; i < pList->Count() && bValidBitmapName; i++ ) + { + if( aName == pList->GetBitmap(i)->GetName() ) + { + bValidBitmapName = false; + aName = aFileName + OUString::number(j++); + } + } + } + + pList->Insert(std::make_unique<XBitmapEntry>(aGraphic, aName)); + pList->Save(); + + SvxFillAttrBox::Fill(*mxLbFillAttr, pList); + + mxLbFillAttr->set_active_text(aName); + SelectFillAttrHdl(*mxLbFillAttr); + } +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, SelectFillTypeHdl, weld::ComboBox&, void) +{ + FillStyleChanged(true); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, SelectFillColorHdl, ColorListBox&, void) +{ + SelectFillAttrHdl_Impl(); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, SelectFillAttrHdl, weld::ComboBox&, void) +{ + SelectFillAttrHdl_Impl(); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, ChangeGradientAngle, weld::MetricSpinButton&, void) +{ + SelectFillAttrHdl_Impl(); +} + +void AreaPropertyPanelBase::SelectFillAttrHdl_Impl() +{ + sal_Int32 nPosFillStyle = static_cast<eFillStyle>(mxLbFillType->get_active()); + SfxObjectShell* pSh = SfxObjectShell::Current(); + + // #i122676# dependent from bFillStyleChange, do execute a single or two + // changes in one Execute call + const bool bFillStyleChange(static_cast<eFillStyle>(meLastXFS) != static_cast<eFillStyle>(nPosFillStyle)); + + switch(nPosFillStyle) + { + case eFillStyle::NONE: + { + if(bFillStyleChange) + { + const XFillStyleItem aXFillStyleItem(drawing::FillStyle_NONE); + // Need to disable the XFillUseSlideBackgroundItem + const XFillUseSlideBackgroundItem aXFillUseSlideBackgroundItem(false); + setFillUseBackground(&aXFillStyleItem, aXFillUseSlideBackgroundItem); + } + break; + } + case eFillStyle::SOLID: + { + if(bFillStyleChange) + { + // #i122676# Single FillStyle change call needed here + XFillStyleItem aXFillStyleItem(drawing::FillStyle_SOLID); + setFillStyle(aXFillStyleItem); + } + break; + } + case eFillStyle::GRADIENT: + { + + if (pSh && pSh->GetItem(SID_COLOR_TABLE)) + { + XGradient aGradient; + aGradient.SetAngle(Degree10(mxMTRAngle->get_value(FieldUnit::DEGREE) * 10)); + aGradient.SetGradientStyle(static_cast<css::awt::GradientStyle>(mxGradientStyle->get_active())); + aGradient.SetStartColor(mxLbFillGradFrom->GetSelectEntryColor()); + aGradient.SetEndColor(mxLbFillGradTo->GetSelectEntryColor()); + + const XFillGradientItem aXFillGradientItem(mxLbFillAttr->get_active_text(), aGradient); + + // #i122676# Change FillStyle and Gradient in one call + XFillStyleItem aXFillStyleItem(drawing::FillStyle_GRADIENT); + setFillStyleAndGradient(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillGradientItem); + } + break; + } + case eFillStyle::HATCH: + { + sal_Int32 nPos = mxLbFillAttr->get_active(); + + if (nPos == -1) + { + nPos = mnLastPosHatch; + } + + if (nPos != -1 && pSh && pSh->GetItem(SID_HATCH_LIST)) + { + const SvxHatchListItem * pItem = pSh->GetItem(SID_HATCH_LIST); + + if(nPos < pItem->GetHatchList()->Count()) + { + const XHatch aHatch = pItem->GetHatchList()->GetHatch(nPos)->GetHatch(); + const XFillHatchItem aXFillHatchItem( mxLbFillAttr->get_active_text(), aHatch); + + // #i122676# Change FillStyle and Hatch in one call + XFillStyleItem aXFillStyleItem(drawing::FillStyle_HATCH); + setFillStyleAndHatch(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillHatchItem); + } + } + + if (nPos != -1) + { + mnLastPosHatch = nPos; + } + break; + } + case eFillStyle::BITMAP: + { + sal_Int32 nPos = mxLbFillAttr->get_active(); + + if (nPos == -1) + { + nPos = mnLastPosBitmap; + } + + if (nPos != -1 && pSh && pSh->GetItem(SID_BITMAP_LIST)) + { + const SvxBitmapListItem * pItem = pSh->GetItem(SID_BITMAP_LIST); + + if(nPos < pItem->GetBitmapList()->Count()) + { + const XBitmapEntry* pXBitmapEntry = pItem->GetBitmapList()->GetBitmap(nPos); + const XFillBitmapItem aXFillBitmapItem(mxLbFillAttr->get_active_text(), pXBitmapEntry->GetGraphicObject()); + + // #i122676# Change FillStyle and Bitmap in one call + XFillStyleItem aXFillStyleItem(drawing::FillStyle_BITMAP); + setFillStyleAndBitmap(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillBitmapItem); + } + } + + if (nPos != -1) + { + mnLastPosBitmap = nPos; + } + break; + } + case eFillStyle::PATTERN: + { + sal_Int32 nPos = mxLbFillAttr->get_active(); + + if (nPos == -1) + { + nPos = mnLastPosPattern; + } + + if (nPos != -1 && pSh && pSh->GetItem(SID_PATTERN_LIST)) + { + const SvxPatternListItem * pItem = pSh->GetItem(SID_PATTERN_LIST); + + if(nPos < pItem->GetPatternList()->Count()) + { + const XBitmapEntry* pXPatternEntry = pItem->GetPatternList()->GetBitmap(nPos); + const XFillBitmapItem aXFillBitmapItem(mxLbFillAttr->get_active_text(), pXPatternEntry->GetGraphicObject()); + + // #i122676# Change FillStyle and Bitmap in one call + XFillStyleItem aXFillStyleItem(drawing::FillStyle_BITMAP); + setFillStyleAndBitmap(bFillStyleChange ? &aXFillStyleItem : nullptr, aXFillBitmapItem); + } + } + + if (nPos != -1) + { + mnLastPosPattern = nPos; + } + break; + } + } + if (m_pPanel && !comphelper::LibreOfficeKit::isActive()) + m_pPanel->TriggerDeckLayouting(); +} + +void AreaPropertyPanelBase::FillStyleChanged(bool bUpdateModel) +{ + sal_Int32 nPos = static_cast<eFillStyle>(mxLbFillType->get_active()); + mxLbFillAttr->clear(); + SfxObjectShell* pSh = SfxObjectShell::Current(); + if (!pSh) + return; + + bool bShowLbFillAttr = false; + bool bShowLbFillGradFrom = false; + bool bShowLbFillGradTo = false; + bool bShowGradientStyle = false; + bool bShowMTRAngle = false; + bool bShowToolBoxColor = false; + bool bShowBmpImport = false; + + // #i122676# Do no longer trigger two Execute calls, one for SID_ATTR_FILL_STYLE + // and one for setting the fill attribute itself, but add two SfxPoolItems to the + // call to get just one action at the SdrObject and to create only one Undo action, too. + // Checked that this works in all apps. + switch (nPos) + { + default: + case NONE: + { + if (bUpdateModel) + { + const XFillStyleItem aXFillStyleItem(drawing::FillStyle_NONE); + // Need to disable the XFillUseSlideBackgroundItem + const XFillUseSlideBackgroundItem aXFillUseSlideBackgroundItem(false); + setFillUseBackground(&aXFillStyleItem, aXFillUseSlideBackgroundItem); + } + + break; + } + case SOLID: + { + bShowToolBoxColor = true; + + if (bUpdateModel) + { + const Color aColor = mpColorItem ? mpColorItem->GetColorValue() : COL_AUTO; + const XFillColorItem aXFillColorItem("", aColor); + + // #i122676# change FillStyle and Color in one call + XFillStyleItem aXFillStyleItem(drawing::FillStyle_SOLID); + setFillStyleAndColor(&aXFillStyleItem, aXFillColorItem); + } + break; + } + case GRADIENT: + { + bShowLbFillGradFrom = true; + bShowLbFillGradTo = true; + bShowGradientStyle = true; + bShowMTRAngle = true; + + mxLbFillAttr->set_sensitive(true); + mxLbFillGradTo->set_sensitive(true); + mxLbFillGradFrom->set_sensitive(true); + mxGradientStyle->set_sensitive(true); + mxMTRAngle->set_sensitive(true); + mxLbFillAttr->clear(); + + if (bUpdateModel) + { + mxLbFillAttr->hide(); + mxToolBoxColor->hide(); + mxBmpImport->hide(); + + const SvxGradientListItem* pItem = pSh->GetItem(SID_GRADIENT_LIST); + if (pItem->GetGradientList()->Count() > 0) + { + const XGradient aGradient + = pItem->GetGradientList()->GetGradient(0)->GetGradient(); + const OUString aName = pItem->GetGradientList()->GetGradient(0)->GetName(); + const XFillGradientItem aXFillGradientItem(aName, aGradient); + + // #i122676# change FillStyle and Gradient in one call + XFillStyleItem aXFillStyleItem(drawing::FillStyle_GRADIENT); + setFillStyleAndGradient(&aXFillStyleItem, aXFillGradientItem); + mxLbFillGradFrom->SelectEntry(aGradient.GetStartColor()); + mxLbFillGradTo->SelectEntry(aGradient.GetEndColor()); + + mxMTRAngle->set_value(toDegrees(aGradient.GetAngle()), FieldUnit::DEGREE); + css::awt::GradientStyle eXGS = aGradient.GetGradientStyle(); + mxGradientStyle->set_active(sal::static_int_cast<sal_Int32>(eXGS)); + } + } + else + { + if (pSh && pSh->GetItem(SID_GRADIENT_LIST)) + { + SvxFillAttrBox::Fill(*mxLbFillAttr, + pSh->GetItem(SID_GRADIENT_LIST)->GetGradientList()); + mxLbFillGradTo->SetNoSelection(); + mxLbFillGradFrom->SetNoSelection(); + if (mpFillGradientItem) + { + const OUString aString(mpFillGradientItem->GetName()); + mxLbFillAttr->set_active_text(aString); + const XGradient aGradient = mpFillGradientItem->GetGradientValue(); + mxLbFillGradFrom->SelectEntry(aGradient.GetStartColor()); + mxLbFillGradTo->SelectEntry(aGradient.GetEndColor()); + mxGradientStyle->set_active( + sal::static_int_cast<sal_Int32>(aGradient.GetGradientStyle())); + if (mxGradientStyle->get_active() == sal_Int32(GradientStyle::Radial)) + mxMTRAngle->set_sensitive(false); + else + mxMTRAngle->set_value(toDegrees(aGradient.GetAngle()), + FieldUnit::DEGREE); + } + else + { + mxLbFillAttr->set_active(-1); + } + } + else + { + mxLbFillAttr->set_active(-1); + } + } + break; + } + case HATCH: + { + bShowLbFillAttr = true; + + const SvxHatchListItem* pItem(pSh->GetItem(SID_HATCH_LIST)); + if (pItem) + { + const XHatchListRef& pXHatchList(pItem->GetHatchList()); + mxLbFillAttr->set_sensitive(true); + mxLbFillAttr->clear(); + SvxFillAttrBox::Fill(*mxLbFillAttr, pXHatchList); + + if (mnLastPosHatch != -1) + { + if (mnLastPosHatch < pXHatchList->Count()) + { + const XHatch aHatch = pXHatchList->GetHatch(mnLastPosHatch)->GetHatch(); + const OUString aName = pXHatchList->GetHatch(mnLastPosHatch)->GetName(); + const XFillHatchItem aXFillHatchItem(aName, aHatch); + + // #i122676# change FillStyle and Hatch in one call + if (bUpdateModel) + { + XFillStyleItem aXFillStyleItem(drawing::FillStyle_HATCH); + setFillStyleAndHatch(&aXFillStyleItem, aXFillHatchItem); + } + mxLbFillAttr->set_active(mnLastPosHatch); + } + } + } + else + { + mxLbFillAttr->set_sensitive(false); + } + break; + } + case BITMAP: + case PATTERN: + { + bShowLbFillAttr = true; + mxLbFillAttr->set_sensitive(true); + mxLbFillAttr->clear(); + + OUString aName; + GraphicObject aBitmap; + if (nPos == static_cast<sal_Int32>(BITMAP)) + { + if (!comphelper::LibreOfficeKit::isActive()) + bShowBmpImport = true; + const SvxBitmapListItem* pItem = pSh->GetItem(SID_BITMAP_LIST); + if (pItem) + { + const XBitmapListRef& pXBitmapList(pItem->GetBitmapList()); + SvxFillAttrBox::Fill(*mxLbFillAttr, pXBitmapList); + + if (mnLastPosBitmap != -1) + { + if (mnLastPosBitmap < pXBitmapList->Count()) + { + const XBitmapEntry* pXBitmapEntry + = pXBitmapList->GetBitmap(mnLastPosBitmap); + aBitmap = pXBitmapEntry->GetGraphicObject(); + aName = pXBitmapEntry->GetName(); + mxLbFillAttr->set_active(mnLastPosBitmap); + } + } + } + else + { + bShowBmpImport = false; + } + } + else if (nPos == static_cast<sal_Int32>(PATTERN)) + { + const SvxPatternListItem* pItem = pSh->GetItem(SID_PATTERN_LIST); + if (pItem) + { + const XPatternListRef& pXPatternList(pItem->GetPatternList()); + SvxFillAttrBox::Fill(*mxLbFillAttr, pXPatternList); + + if (mnLastPosPattern != -1) + { + if (mnLastPosPattern < pXPatternList->Count()) + { + const XBitmapEntry* pXPatternEntry + = pXPatternList->GetBitmap(mnLastPosPattern); + aBitmap = pXPatternEntry->GetGraphicObject(); + aName = pXPatternEntry->GetName(); + mxLbFillAttr->set_active(mnLastPosPattern); + } + } + } + else + { + bShowLbFillAttr = false; + } + } + if (bUpdateModel) + { + const XFillBitmapItem aXFillBitmapItem(aName, aBitmap); + const XFillStyleItem aXFillStyleItem(drawing::FillStyle_BITMAP); + setFillStyleAndBitmap(&aXFillStyleItem, aXFillBitmapItem); + } + break; + } + case USE_BACKGROUND: + { + // No transparencies here + mxLBTransType->hide(); + mxTrspTextFT->hide(); + mxMTRTransparent->hide(); + mxSldTransparent->hide(); + mxBTNGradient->hide(); + if (bUpdateModel) + { + const XFillStyleItem aXFillStyleItem(drawing::FillStyle_NONE); + const XFillUseSlideBackgroundItem aXFillUseSlideBackgroundItem(true); + setFillUseBackground(&aXFillStyleItem, aXFillUseSlideBackgroundItem); + break; + } + } + } + + mxLbFillAttr->set_visible(bShowLbFillAttr); + mxLbFillGradFrom->set_visible(bShowLbFillGradFrom); + mxLbFillGradTo->set_visible(bShowLbFillGradTo); + mxGradientStyle->set_visible(bShowGradientStyle); + mxMTRAngle->set_visible(bShowMTRAngle); + mxToolBoxColor->set_visible(bShowToolBoxColor); + mxBmpImport->set_visible(bShowBmpImport); + + meLastXFS = static_cast<sal_uInt16>(nPos); + + if (m_pPanel && !comphelper::LibreOfficeKit::isActive()) + m_pPanel->TriggerDeckLayouting(); +} + +void AreaPropertyPanelBase::ImpUpdateTransparencies() +{ + if(mpTransparenceItem || mpFloatTransparenceItem) + { + bool bZeroValue(false); + + if (mpTransparenceItem) + { + const sal_uInt16 nValue(mpTransparenceItem->GetValue()); + + if(!nValue) + { + bZeroValue = true; + } + else if(nValue <= 100) + { + mxLBTransType->set_sensitive(true); + mxTrspTextFT->set_sensitive(true); + mxLBTransType->set_active(1); + mxBTNGradient->hide(); + mxMTRTransparent->show(); + mxSldTransparent->show(); + mxMTRTransparent->set_sensitive(true); + mxSldTransparent->set_sensitive(true); + SetTransparency(nValue); + } + + if (!bZeroValue && mxTrGrPopup) + { + mxBTNGradient->set_menu_item_active(SIDEBARGRADIENT, false); + } + } + + if(bZeroValue && mpFloatTransparenceItem) + { + if(mpFloatTransparenceItem->IsEnabled()) + { + const XGradient& rGradient = mpFloatTransparenceItem->GetGradientValue(); + sal_Int32 nEntryPos(0); + OUString* pImage = nullptr; + + mxLBTransType->set_sensitive(true); + mxTrspTextFT->set_sensitive(true); + mxMTRTransparent->hide(); + mxSldTransparent->hide(); + mxBTNGradient->set_sensitive(true); + mxBTNGradient->show(); + + switch(rGradient.GetGradientStyle()) + { + default: + case css::awt::GradientStyle_LINEAR: + { + nEntryPos = 2; + pImage = &maImgLinear; + break; + } + case css::awt::GradientStyle_AXIAL: + { + nEntryPos = 3; + pImage = &maImgAxial; + break; + } + case css::awt::GradientStyle_RADIAL: + { + nEntryPos = 4; + pImage = &maImgRadial; + break; + } + case css::awt::GradientStyle_ELLIPTICAL: + { + nEntryPos = 5; + pImage = &maImgElli; + break; + } + case css::awt::GradientStyle_SQUARE: + { + nEntryPos = 6; + pImage = &maImgQuad; + break; + } + case css::awt::GradientStyle_RECT: + { + nEntryPos = 7; + pImage = &maImgSquare; + break; + } + } + mxLBTransType->set_active(nEntryPos); + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, *pImage); + mxTrGrPopup->Rearrange(mpFloatTransparenceItem.get()); + bZeroValue = false; + } + else + { + bZeroValue = true; + } + } + + if(bZeroValue) + { + mxLBTransType->set_sensitive(true); + mxTrspTextFT->set_sensitive(true); + mxLBTransType->set_active(0); + mxBTNGradient->hide(); + mxMTRTransparent->set_sensitive(true); + mxSldTransparent->set_sensitive(true); + mxMTRTransparent->show(); + mxSldTransparent->show(); + SetTransparency(0); + } + } + else + { + // no transparency at all + mxLBTransType->set_active(-1); + mxLBTransType->set_sensitive(false); + mxTrspTextFT->set_sensitive(false); + mxMTRTransparent->set_sensitive(false); + mxSldTransparent->set_sensitive(false); + mxMTRTransparent->show(); + mxSldTransparent->show(); + mxBTNGradient->set_sensitive(false); + mxBTNGradient->hide(); + } +} + +void AreaPropertyPanelBase::updateFillTransparence(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if (bDisabled) + { + mpTransparenceItem.reset(); + return; + } + else if (bDefaultOrSet) + { + if (pState) + { + const SfxUInt16Item* pItem = static_cast<const SfxUInt16Item*>(pState); + mpTransparenceItem.reset(pItem->Clone()); + } + else + { + mpTransparenceItem.reset(); + } + } + else + { + mpTransparenceItem.reset(); + } + + // update transparency settings dependent of mpTransparenceItem and mpFloatTransparenceItem + ImpUpdateTransparencies(); +} + +void AreaPropertyPanelBase::updateFillFloatTransparence(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if (bDisabled) + { + mpFloatTransparenceItem.reset(); + return; + } + + if (bDefaultOrSet) + { + if (pState) + { + const XFillFloatTransparenceItem* pItem = static_cast<const XFillFloatTransparenceItem*>(pState); + mpFloatTransparenceItem.reset(pItem->Clone()); + } + else + { + mpFloatTransparenceItem.reset(); + } + } + else + { + mpFloatTransparenceItem.reset(); + } + + // update transparency settings dependent of mpTransparenceItem and mpFloatTransparenceItem + ImpUpdateTransparencies(); +} + +void AreaPropertyPanelBase::updateFillStyle(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if(bDisabled) + { + mxLbFillType->set_sensitive(false); + mxColorTextFT->set_sensitive(false); + mxLbFillType->set_active(-1); + mxLbFillAttr->show(); + mxLbFillAttr->set_sensitive(false); + mxLbFillAttr->set_active(-1); + mxToolBoxColor->hide(); + meLastXFS = static_cast<sal_uInt16>(-1); + mpStyleItem.reset(); + } + else if (bDefaultOrSet && pState) + { + const XFillStyleItem* pItem = static_cast<const XFillStyleItem*>(pState); + mpStyleItem.reset(pItem->Clone()); + mxLbFillType->set_sensitive(true); + mxColorTextFT->set_sensitive(true); + drawing::FillStyle eXFS = mpStyleItem->GetValue(); + eFillStyle nPos = NONE; + switch(eXFS) + { + default: + case drawing::FillStyle_NONE: + { + mxLbFillAttr->set_active(-1); + mxLbFillAttr->set_sensitive(false); + // "Use slide background" also uses FillStyle_NONE internally, + // don't switch listbox in that case (will be handled by updateFillUseBackground) + nPos = meLastXFS == USE_BACKGROUND ? USE_BACKGROUND : NONE; + break; + } + case drawing::FillStyle_SOLID: + nPos = SOLID; + break; + case drawing::FillStyle_GRADIENT: + nPos = GRADIENT; + break; + case drawing::FillStyle_HATCH: + nPos = HATCH; + break; + case drawing::FillStyle_BITMAP: + { + if(mpBitmapItem) + { + if(!mpBitmapItem->isPattern()) + nPos = BITMAP; + else + nPos = PATTERN; + } + else + nPos = BITMAP; + break; + } + } + meLastXFS = static_cast< sal_uInt16 >(mxLbFillType->get_active()); + mxLbFillType->set_active(static_cast< sal_Int32 >(nPos)); + FillStyleChanged(false); + return; + } + + mxLbFillType->set_active(-1); + mxLbFillAttr->show(); + mxLbFillAttr->set_sensitive(false); + mxLbFillAttr->set_active(-1); + mxToolBoxColor->hide(); + meLastXFS = static_cast<sal_uInt16>(-1); + mpStyleItem.reset(); +} + +void AreaPropertyPanelBase::updateFillGradient(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if (bDefaultOrSet) + { + const XFillGradientItem* pItem = static_cast<const XFillGradientItem*>(pState); + mpFillGradientItem.reset(pItem ? pItem->Clone() : nullptr); + } + + if(mpStyleItem && drawing::FillStyle_GRADIENT == mpStyleItem->GetValue()) + { + mxLbFillAttr->hide(); + mxLbFillGradFrom->show(); + mxLbFillGradTo->show(); + mxMTRAngle->show(); + mxGradientStyle->show(); + mxToolBoxColor->hide(); + + if (bDefaultOrSet) + { + mxLbFillType->set_active(GRADIENT); + FillStyleChanged(false); + } + else if(bDisabled) + { + mxLbFillGradFrom->SetNoSelection(); + mxLbFillGradTo->SetNoSelection(); + mxLbFillGradFrom->set_sensitive(false); + mxLbFillGradTo->set_sensitive(false); + mxMTRAngle->set_sensitive(false); + mxGradientStyle->set_sensitive(false); + } + else + { + mxLbFillGradFrom->SetNoSelection(); + mxLbFillGradTo->SetNoSelection(); + } + } +} + +void AreaPropertyPanelBase::updateFillHatch(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if (bDefaultOrSet) + { + const XFillHatchItem* pItem = static_cast<const XFillHatchItem*>(pState); + mpHatchItem.reset(pItem ? pItem->Clone() : nullptr); + } + + if(mpStyleItem && drawing::FillStyle_HATCH == mpStyleItem->GetValue()) + { + mxLbFillAttr->show(); + mxToolBoxColor->hide(); + + if (bDefaultOrSet) + { + mxLbFillAttr->set_sensitive(true); + mxLbFillType->set_active(HATCH); + FillStyleChanged(false); + } + else if(bDisabled) + { + mxLbFillAttr->set_sensitive(false); + mxLbFillAttr->set_active(-1); + } + else + { + mxLbFillAttr->set_active(-1); + } + } + FillStyleChanged(false); +} + +void AreaPropertyPanelBase::updateFillColor(bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if (bDefaultOrSet) + { + const XFillColorItem* pItem = static_cast<const XFillColorItem*>(pState); + mpColorItem.reset(pItem ? pItem->Clone() : nullptr); + } + + if(mpStyleItem && drawing::FillStyle_SOLID == mpStyleItem->GetValue()) + { + mxLbFillAttr->hide(); + mxToolBoxColor->show(); + mxLbFillType->set_active(SOLID); + FillStyleChanged(false); + } +} + +void AreaPropertyPanelBase::updateFillBitmap(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if (bDefaultOrSet) + { + const XFillBitmapItem* pItem = static_cast<const XFillBitmapItem*>(pState); + mpBitmapItem.reset(pItem ? pItem->Clone() : nullptr); + } + + if(mpStyleItem && drawing::FillStyle_BITMAP == mpStyleItem->GetValue()) + { + mxLbFillAttr->show(); + mxToolBoxColor->hide(); + + if (bDefaultOrSet) + { + if(mpBitmapItem->isPattern()) + mxLbFillType->set_active(PATTERN); + else + mxLbFillType->set_active(BITMAP); + FillStyleChanged(false); + } + else if(bDisabled) + { + mxLbFillAttr->hide(); + mxLbFillAttr->set_active(-1); + } + else + { + mxLbFillAttr->set_active(-1); + } + } +} + +void AreaPropertyPanelBase::updateFillUseBackground(bool bDisabled, bool bDefaultOrSet, const SfxPoolItem* pState) +{ + if (bDisabled) + { + mpUseSlideBackgroundItem.reset(); + return; + } + + if (bDefaultOrSet) + { + if (pState) + { + const XFillUseSlideBackgroundItem* pItem = static_cast<const XFillUseSlideBackgroundItem*>(pState); + // When XFillUseSlideBackgroundItem is true, select "Use Background Fill". When false, select "None" + int nPos = pItem->GetValue() ? USE_BACKGROUND : NONE; + mxLbFillType->set_active(nPos); + mpUseSlideBackgroundItem.reset(pItem->Clone()); + FillStyleChanged(false); + } + else + { + mpUseSlideBackgroundItem.reset(); + } + } + else + { + mpUseSlideBackgroundItem.reset(); + } +} + +void AreaPropertyPanelBase::NotifyItemUpdate( + sal_uInt16 nSID, + SfxItemState eState, + const SfxPoolItem* pState) +{ + const bool bDisabled(SfxItemState::DISABLED == eState); + const bool bDefaultOrSet(SfxItemState::DEFAULT <= eState); + const bool bDefault(SfxItemState::DEFAULT == eState); + + switch(nSID) + { + case SID_ATTR_FILL_TRANSPARENCE: + updateFillTransparence(bDisabled, bDefaultOrSet, pState); + break; + case SID_ATTR_FILL_FLOATTRANSPARENCE: + updateFillFloatTransparence(bDisabled, bDefaultOrSet, pState); + break; + case SID_ATTR_FILL_STYLE: + updateFillStyle(bDisabled, bDefaultOrSet, pState); + break; + case SID_ATTR_FILL_COLOR: + updateFillColor(bDefaultOrSet, pState); + break; + case SID_ATTR_FILL_GRADIENT: + updateFillGradient(bDisabled, bDefaultOrSet, pState); + break; + case SID_ATTR_FILL_HATCH: + updateFillHatch(bDisabled, bDefaultOrSet, pState); + break; + case SID_ATTR_FILL_BITMAP: + updateFillBitmap(bDisabled, bDefaultOrSet, pState); + break; + case SID_ATTR_FILL_USE_SLIDE_BACKGROUND: + updateFillUseBackground(bDisabled, bDefaultOrSet, pState); + break; + case SID_GRADIENT_LIST: + { + if(bDefault) + { + if(mpStyleItem && drawing::FillStyle_GRADIENT == mpStyleItem->GetValue()) + { + if(mpFillGradientItem) + { + const OUString aString( mpFillGradientItem->GetName() ); + const SfxObjectShell* pSh = SfxObjectShell::Current(); + mxLbFillAttr->clear(); + if (pSh) + { + mxLbFillAttr->set_sensitive(true); + SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_GRADIENT_LIST)->GetGradientList()); + } + mxLbFillAttr->set_active_text(aString); + } + else + { + mxLbFillAttr->set_active(-1); + } + } + } + break; + } + case SID_HATCH_LIST: + { + if(bDefault) + { + if(mpStyleItem && drawing::FillStyle_HATCH == mpStyleItem->GetValue()) + { + if(mpHatchItem) + { + const OUString aString( mpHatchItem->GetName() ); + const SfxObjectShell* pSh = SfxObjectShell::Current(); + mxLbFillAttr->clear(); + if (pSh) + { + mxLbFillAttr->set_sensitive(true); + SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_HATCH_LIST)->GetHatchList()); + } + mxLbFillAttr->set_active_text(aString); + } + else + { + mxLbFillAttr->set_active(-1); + } + } + } + break; + } + case SID_BITMAP_LIST: + case SID_PATTERN_LIST: + { + if(bDefault) + { + if(mpStyleItem && drawing::FillStyle_BITMAP == mpStyleItem->GetValue()) + { + if(mpBitmapItem) + { + const OUString aString( mpBitmapItem->GetName() ); + const SfxObjectShell* pSh = SfxObjectShell::Current(); + mxLbFillAttr->clear(); + mxLbFillAttr->show(); + if (pSh) + { + if(nSID == SID_BITMAP_LIST) + SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_BITMAP_LIST)->GetBitmapList()); + else if(nSID == SID_PATTERN_LIST) + SvxFillAttrBox::Fill(*mxLbFillAttr, pSh->GetItem(SID_PATTERN_LIST)->GetPatternList()); + } + mxLbFillAttr->set_active_text(aString); + } + else + { + mxLbFillAttr->set_active(-1); + } + } + } + break; + } + } + FillStyleChanged(false); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, ModifyTransSliderHdl, weld::Scale&, void) +{ + const sal_uInt16 nVal = mxSldTransparent->get_value(); + SetTransparency(nVal); + const XFillTransparenceItem aLinearItem(nVal); + setFillTransparence(aLinearItem); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, ChangeTrgrTypeHdl_Impl, weld::ComboBox&, void) +{ + sal_Int32 nSelectType = mxLBTransType->get_active(); + bool bGradient = false; + sal_uInt16 nTrans = 0; + + if(!nSelectType) + { + mxBTNGradient->hide(); + mxMTRTransparent->show(); + mxSldTransparent->show(); + mxMTRTransparent->set_sensitive(true); + mxSldTransparent->set_sensitive(true); + SetTransparency(0); + } + else if(1 == nSelectType) + { + mxBTNGradient->hide(); + mxMTRTransparent->show(); + mxSldTransparent->show(); + nTrans = mnLastTransSolid; + mxMTRTransparent->set_value(nTrans, FieldUnit::PERCENT); + mxLBTransType->set_active(1); + mxMTRTransparent->set_sensitive(true); + mxSldTransparent->set_sensitive(true); + } + else + { + mxBTNGradient->show(); + + switch (nSelectType) + { + case 2: + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgLinear); + break; + case 3: + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgAxial); + break; + case 4: + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgRadial); + break; + case 5: + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgElli); + break; + case 6: + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgQuad); + break; + case 7: + mxBTNGradient->set_item_icon_name(SIDEBARGRADIENT, maImgSquare); + break; + } + + mxMTRTransparent->hide(); + mxSldTransparent->hide(); + mxBTNGradient->set_sensitive(true); + bGradient = true; + } + + const XFillTransparenceItem aLinearItem(nTrans); + setFillTransparence(aLinearItem); + + if(nSelectType > 1) + { + nSelectType -= 2; + } + + XGradient aTmpGradient; + + switch(static_cast<css::awt::GradientStyle>(nSelectType)) + { + case css::awt::GradientStyle_LINEAR: + aTmpGradient = maGradientLinear; + break; + case css::awt::GradientStyle_AXIAL: + aTmpGradient = maGradientAxial; + break; + case css::awt::GradientStyle_RADIAL: + aTmpGradient = maGradientRadial; + break; + case css::awt::GradientStyle_ELLIPTICAL: + aTmpGradient = maGradientElliptical; + break; + case css::awt::GradientStyle_SQUARE: + aTmpGradient = maGradientSquare; + break; + case css::awt::GradientStyle_RECT: + aTmpGradient = maGradientRect; + break; + default: + break; + } + + const XFillFloatTransparenceItem aGradientItem(aTmpGradient, bGradient); + setFillFloatTransparence(aGradientItem); +} + +IMPL_LINK_NOARG(AreaPropertyPanelBase, ModifyTransparentHdl_Impl, weld::MetricSpinButton&, void) +{ + const sal_uInt16 nTrans = static_cast<sal_uInt16>(mxMTRTransparent->get_value(FieldUnit::PERCENT)); + mnLastTransSolid = nTrans; + SetTransparency(nTrans); + const sal_Int32 nSelectType = mxLBTransType->get_active(); + + if(nTrans && !nSelectType) + { + mxLBTransType->set_active(1); + } + + const XFillTransparenceItem aLinearItem(nTrans); + setFillTransparence(aLinearItem); +} + +const XGradient& AreaPropertyPanelBase::GetGradient (const css::awt::GradientStyle eStyle) const +{ + switch (eStyle) + { + default: + case css::awt::GradientStyle_LINEAR: + return maGradientLinear; + case css::awt::GradientStyle_AXIAL: + return maGradientAxial; + case css::awt::GradientStyle_RADIAL: + return maGradientRadial; + case css::awt::GradientStyle_ELLIPTICAL: + return maGradientElliptical; + case css::awt::GradientStyle_SQUARE: + return maGradientSquare; + case css::awt::GradientStyle_RECT: + return maGradientRect; + } +} + +void AreaPropertyPanelBase::SetGradient (const XGradient& rGradient) +{ + switch (rGradient.GetGradientStyle()) + { + case css::awt::GradientStyle_LINEAR: + maGradientLinear = rGradient; + break; + case css::awt::GradientStyle_AXIAL: + maGradientAxial = rGradient; + break; + case css::awt::GradientStyle_RADIAL: + maGradientRadial = rGradient; + break; + case css::awt::GradientStyle_ELLIPTICAL: + maGradientElliptical = rGradient; + break; + case css::awt::GradientStyle_SQUARE: + maGradientSquare = rGradient; + break; + case css::awt::GradientStyle_RECT: + maGradientRect = rGradient; + break; + default: + break; + } +} + +sal_Int32 AreaPropertyPanelBase::GetSelectedTransparencyTypeIndex() const +{ + return mxLBTransType->get_active(); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/area/AreaTransparencyGradientPopup.cxx b/svx/source/sidebar/area/AreaTransparencyGradientPopup.cxx new file mode 100644 index 000000000..2d92b6b4b --- /dev/null +++ b/svx/source/sidebar/area/AreaTransparencyGradientPopup.cxx @@ -0,0 +1,179 @@ +/* -*- 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 <svx/sidebar/AreaTransparencyGradientPopup.hxx> +#include <svx/sidebar/AreaPropertyPanelBase.hxx> +#include <svx/xflftrit.hxx> +#include <svx/xgrad.hxx> + +namespace svx::sidebar { + +AreaTransparencyGradientPopup::AreaTransparencyGradientPopup(const css::uno::Reference<css::frame::XFrame>& rFrame, + AreaPropertyPanelBase& rPanel, weld::Widget* pParent) + : WeldToolbarPopup(rFrame, pParent, "svx/ui/floatingareastyle.ui", "FloatingAreaStyle") + , mrAreaPropertyPanel(rPanel) + , mxCenterGrid(m_xBuilder->weld_widget("centergrid")) + , mxAngleGrid(m_xBuilder->weld_widget("anglegrid")) + , mxMtrTrgrCenterX(m_xBuilder->weld_metric_spin_button("centerx", FieldUnit::PERCENT)) + , mxMtrTrgrCenterY(m_xBuilder->weld_metric_spin_button("centery", FieldUnit::PERCENT)) + , mxMtrTrgrAngle(m_xBuilder->weld_metric_spin_button("angle", FieldUnit::DEGREE)) + , mxBtnLeft45(m_xBuilder->weld_toolbar("lefttoolbox")) + , mxBtnRight45(m_xBuilder->weld_toolbar("righttoolbox")) + , mxMtrTrgrStartValue(m_xBuilder->weld_metric_spin_button("start", FieldUnit::PERCENT)) + , mxMtrTrgrEndValue(m_xBuilder->weld_metric_spin_button("end", FieldUnit::PERCENT)) + , mxMtrTrgrBorder(m_xBuilder->weld_metric_spin_button("border", FieldUnit::PERCENT)) +{ + Link<weld::MetricSpinButton&,void> aLink = LINK(this, AreaTransparencyGradientPopup, ModifiedTrgrHdl_Impl); + mxMtrTrgrCenterX->connect_value_changed(aLink); + mxMtrTrgrCenterY->connect_value_changed(aLink); + mxMtrTrgrAngle->connect_value_changed(aLink); + mxMtrTrgrBorder->connect_value_changed(aLink); + mxMtrTrgrStartValue->connect_value_changed(aLink); + mxMtrTrgrEndValue->connect_value_changed(aLink); + mxBtnLeft45->connect_clicked(LINK(this, AreaTransparencyGradientPopup, Left_Click45_Impl)); + mxBtnRight45->connect_clicked(LINK(this, AreaTransparencyGradientPopup, Right_Click45_Impl)); +} + +AreaTransparencyGradientPopup::~AreaTransparencyGradientPopup() +{ +} + +void AreaTransparencyGradientPopup::InitStatus(XFillFloatTransparenceItem const * pGradientItem) +{ + const XGradient& rGradient = pGradientItem->GetGradientValue(); + + XGradient aGradient; + + if (rGradient.GetXOffset() == AreaPropertyPanelBase::DEFAULT_CENTERX + && rGradient.GetYOffset() == AreaPropertyPanelBase::DEFAULT_CENTERY + && static_cast<sal_Int32>(toDegrees(rGradient.GetAngle())) == AreaPropertyPanelBase::DEFAULT_ANGLE + && static_cast<sal_uInt16>(((static_cast<sal_uInt16>(rGradient.GetStartColor().GetRed()) + 1) * 100) / 255) + == AreaPropertyPanelBase::DEFAULT_STARTVALUE + && static_cast<sal_uInt16>(((static_cast<sal_uInt16>(rGradient.GetEndColor().GetRed()) + 1) * 100) / 255) + == AreaPropertyPanelBase::DEFAULT_ENDVALUE + && rGradient.GetBorder() == AreaPropertyPanelBase::DEFAULT_BORDER) + { + aGradient = mrAreaPropertyPanel.GetGradient(rGradient.GetGradientStyle()); + } + else + { + aGradient = rGradient; + } + mxMtrTrgrCenterX->set_value(aGradient.GetXOffset(), FieldUnit::PERCENT); + mxMtrTrgrCenterY->set_value(aGradient.GetYOffset(), FieldUnit::PERCENT); + mxMtrTrgrAngle->set_value(toDegrees(aGradient.GetAngle()), FieldUnit::DEGREE); + mxMtrTrgrStartValue->set_value(static_cast<sal_uInt16>(((static_cast<sal_uInt16>(aGradient.GetStartColor().GetRed()) + 1) * 100) / 255), FieldUnit::PERCENT); + mxMtrTrgrEndValue->set_value(static_cast<sal_uInt16>(((static_cast<sal_uInt16>(aGradient.GetEndColor().GetRed()) + 1) * 100) / 255), FieldUnit::PERCENT); + mxMtrTrgrBorder->set_value(aGradient.GetBorder(), FieldUnit::PERCENT); +} + +void AreaTransparencyGradientPopup::Rearrange(XFillFloatTransparenceItem const * pGradientItem) +{ + InitStatus(pGradientItem); + const XGradient& rGradient = pGradientItem->GetGradientValue(); + css::awt::GradientStyle eXGS(rGradient.GetGradientStyle()); + + switch(eXGS) + { + case css::awt::GradientStyle_LINEAR: + case css::awt::GradientStyle_AXIAL: + mxCenterGrid->hide(); + mxAngleGrid->show(); + break; + case css::awt::GradientStyle_RADIAL: + mxCenterGrid->show(); + mxAngleGrid->hide(); + break; + case css::awt::GradientStyle_ELLIPTICAL: + case css::awt::GradientStyle_SQUARE: + case css::awt::GradientStyle_RECT: + mxCenterGrid->show(); + mxAngleGrid->show(); + break; + default: + break; + } +} + +void AreaTransparencyGradientPopup::ExecuteValueModify(sal_uInt8 nStartCol, sal_uInt8 nEndCol) +{ + //Added + sal_Int16 aMtrValue = static_cast<sal_Int16>(mxMtrTrgrAngle->get_value(FieldUnit::DEGREE)); + while(aMtrValue<0) + aMtrValue += 360; + sal_uInt16 nVal = aMtrValue/360; + nVal = aMtrValue - nVal*360; + mxMtrTrgrAngle->set_value(nVal, FieldUnit::DEGREE); + //End of new code + XGradient aTmpGradient( + Color(nStartCol, nStartCol, nStartCol), + Color(nEndCol, nEndCol, nEndCol), + static_cast<css::awt::GradientStyle>(mrAreaPropertyPanel.GetSelectedTransparencyTypeIndex()-2), + Degree10(static_cast<sal_Int16>(mxMtrTrgrAngle->get_value(FieldUnit::DEGREE)) * 10), + static_cast<sal_uInt16>(mxMtrTrgrCenterX->get_value(FieldUnit::PERCENT)), + static_cast<sal_uInt16>(mxMtrTrgrCenterY->get_value(FieldUnit::PERCENT)), + static_cast<sal_uInt16>(mxMtrTrgrBorder->get_value(FieldUnit::PERCENT)), + 100, 100); + + mrAreaPropertyPanel.SetGradient(aTmpGradient); + + XFillFloatTransparenceItem aGradientItem(aTmpGradient, true ); + + mrAreaPropertyPanel.setFillFloatTransparence(aGradientItem); +} + +IMPL_LINK_NOARG(AreaTransparencyGradientPopup, ModifiedTrgrHdl_Impl, weld::MetricSpinButton&, void) +{ + sal_uInt8 nStartCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(mxMtrTrgrStartValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + sal_uInt8 nEndCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(mxMtrTrgrEndValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + ExecuteValueModify( nStartCol, nEndCol ); +} + +IMPL_LINK_NOARG(AreaTransparencyGradientPopup, Left_Click45_Impl, const OString&, void) +{ + sal_uInt8 nStartCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(mxMtrTrgrStartValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + sal_uInt8 nEndCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(mxMtrTrgrEndValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + sal_uInt16 nTemp = static_cast<sal_uInt16>(mxMtrTrgrAngle->get_value(FieldUnit::DEGREE)); + if (nTemp>=315) + nTemp -= 360; + nTemp += 45; + mxMtrTrgrAngle->set_value(nTemp, FieldUnit::DEGREE); + ExecuteValueModify(nStartCol, nEndCol); +} + +IMPL_LINK_NOARG(AreaTransparencyGradientPopup, Right_Click45_Impl, const OString&, void) +{ + sal_uInt8 nStartCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(mxMtrTrgrStartValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + sal_uInt8 nEndCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(mxMtrTrgrEndValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + sal_uInt16 nTemp = static_cast<sal_uInt16>(mxMtrTrgrAngle->get_value(FieldUnit::DEGREE)); + if (nTemp<45) + nTemp += 360; + nTemp -= 45; + mxMtrTrgrAngle->set_value(nTemp, FieldUnit::DEGREE); + ExecuteValueModify(nStartCol, nEndCol); +} + +void AreaTransparencyGradientPopup::GrabFocus() +{ + mxMtrTrgrCenterX->grab_focus(); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/effect/EffectPropertyPanel.cxx b/svx/source/sidebar/effect/EffectPropertyPanel.cxx new file mode 100644 index 000000000..77e2dac11 --- /dev/null +++ b/svx/source/sidebar/effect/EffectPropertyPanel.cxx @@ -0,0 +1,178 @@ +/* -*- 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 "EffectPropertyPanel.hxx" + +#include <sfx2/dispatch.hxx> +#include <svx/colorbox.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/sdprcitm.hxx> +#include <svx/svddef.hxx> +#include <svx/svxids.hrc> +#include <svx/xcolit.hxx> + +namespace svx::sidebar +{ +EffectPropertyPanel::EffectPropertyPanel(weld::Widget* pParent, SfxBindings* pBindings) + : PanelLayout(pParent, "EffectPropertyPanel", "svx/ui/sidebareffect.ui") + , maGlowColorController(SID_ATTR_GLOW_COLOR, *pBindings, *this) + , maGlowRadiusController(SID_ATTR_GLOW_RADIUS, *pBindings, *this) + , maGlowTransparencyController(SID_ATTR_GLOW_TRANSPARENCY, *pBindings, *this) + , mxFTTransparency(m_xBuilder->weld_label("transparency")) + , maSoftEdgeRadiusController(SID_ATTR_SOFTEDGE_RADIUS, *pBindings, *this) + , mpBindings(pBindings) + , mxGlowRadius(m_xBuilder->weld_metric_spin_button("LB_GLOW_RADIUS", FieldUnit::POINT)) + , mxLBGlowColor(new ColorListBox(m_xBuilder->weld_menu_button("LB_GLOW_COLOR"), + [this] { return GetFrameWeld(); })) + , mxGlowTransparency( + m_xBuilder->weld_metric_spin_button("LB_GLOW_TRANSPARENCY", FieldUnit::PERCENT)) + , mxFTRadiusSoftEdge(m_xBuilder->weld_label("radiussoftedge")) + , mxFTRadiusGlow(m_xBuilder->weld_label("radiusglow")) + , mxFTColor(m_xBuilder->weld_label("glowcolorlabel")) + , mxSoftEdgeRadius(m_xBuilder->weld_metric_spin_button("SB_SOFTEDGE_RADIUS", FieldUnit::POINT)) +{ + Initialize(); +} + +EffectPropertyPanel::~EffectPropertyPanel() +{ + mxGlowRadius.reset(); + mxLBGlowColor.reset(); + mxGlowTransparency.reset(); + mxFTRadiusSoftEdge.reset(); + mxFTColor.reset(); + mxFTTransparency.reset(); + mxSoftEdgeRadius.reset(); + mxFTRadiusGlow.reset(); + + maGlowColorController.dispose(); + maGlowRadiusController.dispose(); + maGlowTransparencyController.dispose(); + maSoftEdgeRadiusController.dispose(); +} + +void EffectPropertyPanel::Initialize() +{ + mxGlowRadius->connect_value_changed(LINK(this, EffectPropertyPanel, ModifyGlowRadiusHdl)); + mxLBGlowColor->SetSelectHdl(LINK(this, EffectPropertyPanel, ModifyGlowColorHdl)); + mxGlowTransparency->connect_value_changed( + LINK(this, EffectPropertyPanel, ModifyGlowTransparencyHdl)); + mxSoftEdgeRadius->connect_value_changed( + LINK(this, EffectPropertyPanel, ModifySoftEdgeRadiusHdl)); +} + +IMPL_LINK_NOARG(EffectPropertyPanel, ModifySoftEdgeRadiusHdl, weld::MetricSpinButton&, void) +{ + SdrMetricItem aItem(SDRATTR_SOFTEDGE_RADIUS, mxSoftEdgeRadius->get_value(FieldUnit::MM_100TH)); + mpBindings->GetDispatcher()->ExecuteList(SID_ATTR_SOFTEDGE_RADIUS, SfxCallMode::RECORD, + { &aItem }); +} + +IMPL_LINK_NOARG(EffectPropertyPanel, ModifyGlowColorHdl, ColorListBox&, void) +{ + XColorItem aItem(SDRATTR_GLOW_COLOR, mxLBGlowColor->GetSelectEntryColor()); + mpBindings->GetDispatcher()->ExecuteList(SID_ATTR_GLOW_COLOR, SfxCallMode::RECORD, { &aItem }); +} + +IMPL_LINK_NOARG(EffectPropertyPanel, ModifyGlowRadiusHdl, weld::MetricSpinButton&, void) +{ + SdrMetricItem aItem(SDRATTR_GLOW_RADIUS, mxGlowRadius->get_value(FieldUnit::MM_100TH)); + mpBindings->GetDispatcher()->ExecuteList(SID_ATTR_GLOW_RADIUS, SfxCallMode::RECORD, { &aItem }); +} + +IMPL_LINK_NOARG(EffectPropertyPanel, ModifyGlowTransparencyHdl, weld::MetricSpinButton&, void) +{ + SdrPercentItem aItem(SDRATTR_GLOW_TRANSPARENCY, + mxGlowTransparency->get_value(FieldUnit::PERCENT)); + mpBindings->GetDispatcher()->ExecuteList(SID_ATTR_GLOW_TRANSPARENCY, SfxCallMode::RECORD, + { &aItem }); +} + +void EffectPropertyPanel::UpdateControls() +{ + const bool bEnabled = mxGlowRadius->get_value(FieldUnit::MM_100TH) != 0; + mxLBGlowColor->set_sensitive(bEnabled); + mxGlowTransparency->set_sensitive(bEnabled); + mxFTColor->set_sensitive(bEnabled); + mxFTTransparency->set_sensitive(bEnabled); +} + +void EffectPropertyPanel::NotifyItemUpdate(sal_uInt16 nSID, SfxItemState eState, + const SfxPoolItem* pState) +{ + switch (nSID) + { + case SID_ATTR_SOFTEDGE_RADIUS: + { + if (eState >= SfxItemState::DEFAULT) + { + const SdrMetricItem* pRadiusItem = dynamic_cast<const SdrMetricItem*>(pState); + if (pRadiusItem) + { + mxSoftEdgeRadius->set_value(pRadiusItem->GetValue(), FieldUnit::MM_100TH); + } + } + } + break; + case SID_ATTR_GLOW_COLOR: + { + if (eState >= SfxItemState::DEFAULT) + { + const XColorItem* pColorItem = dynamic_cast<const XColorItem*>(pState); + if (pColorItem) + { + mxLBGlowColor->SelectEntry(pColorItem->GetColorValue()); + } + } + } + break; + case SID_ATTR_GLOW_RADIUS: + { + if (eState >= SfxItemState::DEFAULT) + { + const SdrMetricItem* pRadiusItem = dynamic_cast<const SdrMetricItem*>(pState); + if (pRadiusItem) + { + mxGlowRadius->set_value(pRadiusItem->GetValue(), FieldUnit::MM_100TH); + } + } + } + break; + case SID_ATTR_GLOW_TRANSPARENCY: + { + if (eState >= SfxItemState::DEFAULT) + { + if (auto pItem = dynamic_cast<const SdrPercentItem*>(pState)) + { + mxGlowTransparency->set_value(pItem->GetValue(), FieldUnit::PERCENT); + } + } + } + break; + } + UpdateControls(); +} + +std::unique_ptr<PanelLayout> EffectPropertyPanel::Create(weld::Widget* pParent, + SfxBindings* pBindings) +{ + if (pParent == nullptr) + throw css::lang::IllegalArgumentException( + "no parent Window given to EffectPropertyPanel::Create", nullptr, 0); + if (pBindings == nullptr) + throw css::lang::IllegalArgumentException( + "no SfxBindings given to EffectPropertyPanel::Create", nullptr, 2); + + return std::make_unique<EffectPropertyPanel>(pParent, pBindings); +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/effect/EffectPropertyPanel.hxx b/svx/source/sidebar/effect/EffectPropertyPanel.hxx new file mode 100644 index 000000000..d657d83e6 --- /dev/null +++ b/svx/source/sidebar/effect/EffectPropertyPanel.hxx @@ -0,0 +1,63 @@ +/* -*- 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/. + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_EFFECT_EFFECTPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_EFFECT_EFFECTPROPERTYPANEL_HXX + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> + +class ColorListBox; + +namespace svx::sidebar +{ +class EffectPropertyPanel : public PanelLayout, + public ::sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface +{ +public: + EffectPropertyPanel(weld::Widget* pParent, SfxBindings* pBindings); + virtual ~EffectPropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create(weld::Widget* pParent, SfxBindings* pBindings); + + virtual void NotifyItemUpdate(const sal_uInt16 nSId, const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void GetControlState(const sal_uInt16 /*nSId*/, + boost::property_tree::ptree& /*rState*/) override{}; + +private: + sfx2::sidebar::ControllerItem maGlowColorController; + sfx2::sidebar::ControllerItem maGlowRadiusController; + sfx2::sidebar::ControllerItem maGlowTransparencyController; + std::unique_ptr<weld::Label> mxFTTransparency; + sfx2::sidebar::ControllerItem maSoftEdgeRadiusController; + + SfxBindings* mpBindings; + + std::unique_ptr<weld::MetricSpinButton> mxGlowRadius; + std::unique_ptr<ColorListBox> mxLBGlowColor; + std::unique_ptr<weld::MetricSpinButton> mxGlowTransparency; + std::unique_ptr<weld::Label> mxFTRadiusSoftEdge; + std::unique_ptr<weld::Label> mxFTRadiusGlow; + std::unique_ptr<weld::Label> mxFTColor; + std::unique_ptr<weld::MetricSpinButton> mxSoftEdgeRadius; + + void Initialize(); + void UpdateControls(); + + DECL_LINK(ModifyGlowColorHdl, ColorListBox&, void); + DECL_LINK(ModifyGlowRadiusHdl, weld::MetricSpinButton&, void); + DECL_LINK(ModifyGlowTransparencyHdl, weld::MetricSpinButton&, void); + DECL_LINK(ModifySoftEdgeRadiusHdl, weld::MetricSpinButton&, void); +}; +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/fontwork/FontworkPropertyPanel.cxx b/svx/source/sidebar/fontwork/FontworkPropertyPanel.cxx new file mode 100644 index 000000000..972141b7b --- /dev/null +++ b/svx/source/sidebar/fontwork/FontworkPropertyPanel.cxx @@ -0,0 +1,59 @@ +/* -*- 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 "FontworkPropertyPanel.hxx" + +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +#include <comphelper/lok.hxx> + +using namespace css; +using namespace css::uno; + +namespace svx +{ +namespace sidebar +{ +FontworkPropertyPanel::FontworkPropertyPanel(weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) + : PanelLayout(pParent, "FontworkPropertyPanel", "svx/ui/sidebarfontwork.ui") + , m_pToolbar(m_xBuilder->weld_toolbar("fontwork-toolbox")) + , m_xToolbar(new ToolbarUnoDispatcher(*m_pToolbar, *m_xBuilder, rxFrame)) +{ + if (comphelper::LibreOfficeKit::isActive()) + m_pToolbar->set_item_visible(".uno:ExtrusionToggle", false); +} + +std::unique_ptr<PanelLayout> +FontworkPropertyPanel::Create(weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException( + "no parent Window given to FontworkPropertyPanel::Create", nullptr, 0); + if (!rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to FontworkPropertyPanel::Create", + nullptr, 1); + + return std::make_unique<FontworkPropertyPanel>(pParent, rxFrame); +} +} +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/fontwork/FontworkPropertyPanel.hxx b/svx/source/sidebar/fontwork/FontworkPropertyPanel.hxx new file mode 100644 index 000000000..cded09b95 --- /dev/null +++ b/svx/source/sidebar/fontwork/FontworkPropertyPanel.hxx @@ -0,0 +1,48 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_AREA_FONTWORKPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_AREA_FONTWORKPROPERTYPANEL_HXX + +#include <sfx2/sidebar/PanelLayout.hxx> +#include <sfx2/weldutils.hxx> + +namespace svx +{ +namespace sidebar +{ +class FontworkPropertyPanel : public PanelLayout +{ +public: + static std::unique_ptr<PanelLayout> + Create(weld::Widget* pParent, const css::uno::Reference<css::frame::XFrame>& rxFrame); + + // constructor/destructor + FontworkPropertyPanel(weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + +private: + std::unique_ptr<weld::Toolbar> m_pToolbar; + std::unique_ptr<ToolbarUnoDispatcher> m_xToolbar; +}; +} +} // end of namespace svx::sidebar + +#endif // INCLUDED_SVX_SOURCE_SIDEBAR_AREA_FONTWORKPROPERTYPANEL_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/graphic/GraphicPropertyPanel.cxx b/svx/source/sidebar/graphic/GraphicPropertyPanel.cxx new file mode 100644 index 000000000..550364955 --- /dev/null +++ b/svx/source/sidebar/graphic/GraphicPropertyPanel.cxx @@ -0,0 +1,246 @@ +/* -*- 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 "GraphicPropertyPanel.hxx" +#include <svx/strings.hrc> +#include <svx/svxids.hrc> +#include <svx/dialmgr.hxx> +#include <svl/intitem.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +using namespace css; +using namespace css::uno; + + +// namespace open + +namespace svx::sidebar { + + +GraphicPropertyPanel::GraphicPropertyPanel( + weld::Widget* pParent, + SfxBindings* pBindings) +: PanelLayout(pParent, "GraphicPropertyPanel", "svx/ui/sidebargraphic.ui"), + maBrightControl(SID_ATTR_GRAF_LUMINANCE, *pBindings, *this), + maContrastControl(SID_ATTR_GRAF_CONTRAST, *pBindings, *this), + maTransparenceControl(SID_ATTR_GRAF_TRANSPARENCE, *pBindings, *this), + maRedControl(SID_ATTR_GRAF_RED, *pBindings, *this), + maGreenControl(SID_ATTR_GRAF_GREEN, *pBindings, *this), + maBlueControl(SID_ATTR_GRAF_BLUE, *pBindings, *this), + maGammaControl(SID_ATTR_GRAF_GAMMA, *pBindings, *this), + maModeControl(SID_ATTR_GRAF_MODE, *pBindings, *this), + mpBindings(pBindings), + mxMtrBrightness(m_xBuilder->weld_metric_spin_button("setbrightness", FieldUnit::PERCENT)), + mxMtrContrast(m_xBuilder->weld_metric_spin_button("setcontrast", FieldUnit::PERCENT)), + mxLBColorMode(m_xBuilder->weld_combo_box("setcolormode")), + mxMtrTrans(m_xBuilder->weld_metric_spin_button("setgraphtransparency", FieldUnit::PERCENT)) +{ + mxLBColorMode->set_size_request(mxLBColorMode->get_preferred_size().Width(), -1); + Initialize(); +} + +GraphicPropertyPanel::~GraphicPropertyPanel() +{ + mxMtrBrightness.reset(); + mxMtrContrast.reset(); + mxLBColorMode.reset(); + mxMtrTrans.reset(); + + maBrightControl.dispose(); + maContrastControl.dispose(); + maTransparenceControl.dispose(); + maRedControl.dispose(); + maGreenControl.dispose(); + maBlueControl.dispose(); + maGammaControl.dispose(); + maModeControl.dispose(); +} + +void GraphicPropertyPanel::Initialize() +{ + mxMtrBrightness->connect_value_changed( LINK( this, GraphicPropertyPanel, ModifyBrightnessHdl ) ); + mxMtrContrast->connect_value_changed( LINK( this, GraphicPropertyPanel, ModifyContrastHdl ) ); + mxMtrTrans->connect_value_changed( LINK( this, GraphicPropertyPanel, ModifyTransHdl ) ); + + mxLBColorMode->append_text(SvxResId(RID_SVXSTR_GRAFMODE_STANDARD)); + mxLBColorMode->append_text(SvxResId(RID_SVXSTR_GRAFMODE_GREYS)); + mxLBColorMode->append_text(SvxResId(RID_SVXSTR_GRAFMODE_MONO)); + mxLBColorMode->append_text(SvxResId(RID_SVXSTR_GRAFMODE_WATERMARK)); + mxLBColorMode->connect_changed( LINK( this, GraphicPropertyPanel, ClickColorModeHdl )); +} + +IMPL_LINK_NOARG( GraphicPropertyPanel, ModifyBrightnessHdl, weld::MetricSpinButton&, void ) +{ + const sal_Int16 nBright = mxMtrBrightness->get_value(FieldUnit::PERCENT); + const SfxInt16Item aBrightItem( SID_ATTR_GRAF_LUMINANCE, nBright ); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_GRAF_LUMINANCE, + SfxCallMode::RECORD, { &aBrightItem }); +} + + +IMPL_LINK_NOARG( GraphicPropertyPanel, ModifyContrastHdl, weld::MetricSpinButton&, void ) +{ + const sal_Int16 nContrast = mxMtrContrast->get_value(FieldUnit::PERCENT); + const SfxInt16Item aContrastItem( SID_ATTR_GRAF_CONTRAST, nContrast ); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_GRAF_CONTRAST, + SfxCallMode::RECORD, { &aContrastItem }); +} + + +IMPL_LINK_NOARG( GraphicPropertyPanel, ModifyTransHdl, weld::MetricSpinButton&, void ) +{ + const sal_Int16 nTrans = mxMtrTrans->get_value(FieldUnit::PERCENT); + const SfxUInt16Item aTransItem( SID_ATTR_GRAF_TRANSPARENCE, nTrans ); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_GRAF_TRANSPARENCE, + SfxCallMode::RECORD, { &aTransItem }); +} + + +IMPL_LINK_NOARG( GraphicPropertyPanel, ClickColorModeHdl, weld::ComboBox&, void ) +{ + const sal_Int16 nTrans = mxLBColorMode->get_active(); + const SfxUInt16Item aTransItem( SID_ATTR_GRAF_MODE, nTrans ); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_GRAF_MODE, + SfxCallMode::RECORD, { &aTransItem }); +} + +std::unique_ptr<PanelLayout> GraphicPropertyPanel::Create ( + weld::Widget* pParent, + SfxBindings* pBindings) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to GraphicPropertyPanel::Create", nullptr, 0); + if (pBindings == nullptr) + throw lang::IllegalArgumentException("no SfxBindings given to GraphicPropertyPanel::Create", nullptr, 2); + + return std::make_unique<GraphicPropertyPanel>(pParent, pBindings); +} + +void GraphicPropertyPanel::NotifyItemUpdate( + sal_uInt16 nSID, + SfxItemState eState, + const SfxPoolItem* pState) +{ + switch( nSID ) + { + case SID_ATTR_GRAF_LUMINANCE: + { + if(eState >= SfxItemState::DEFAULT) + { + mxMtrBrightness->set_sensitive(true); + const SfxInt16Item* pItem = dynamic_cast< const SfxInt16Item* >(pState); + + if(pItem) + { + const sal_Int64 nBright = pItem->GetValue(); + mxMtrBrightness->set_value(nBright, FieldUnit::PERCENT); + } + } + else if(SfxItemState::DISABLED == eState) + { + mxMtrBrightness->set_sensitive(false); + } + else + { + mxMtrBrightness->set_sensitive(true); + mxMtrBrightness->set_text(OUString()); + } + break; + } + case SID_ATTR_GRAF_CONTRAST: + { + if(eState >= SfxItemState::DEFAULT) + { + mxMtrContrast->set_sensitive(true); + const SfxInt16Item* pItem = dynamic_cast< const SfxInt16Item* >(pState); + + if(pItem) + { + const sal_Int64 nContrast = pItem->GetValue(); + mxMtrContrast->set_value(nContrast, FieldUnit::PERCENT); + } + } + else if(SfxItemState::DISABLED == eState) + { + mxMtrContrast->set_sensitive(false); + } + else + { + mxMtrContrast->set_sensitive(true); + mxMtrContrast->set_text(OUString()); + } + break; + } + case SID_ATTR_GRAF_TRANSPARENCE: + { + if(eState >= SfxItemState::DEFAULT) + { + mxMtrTrans->set_sensitive(true); + const SfxUInt16Item* pItem = dynamic_cast< const SfxUInt16Item* >(pState); + + if(pItem) + { + const sal_Int64 nTrans = pItem->GetValue(); + mxMtrTrans->set_value(nTrans, FieldUnit::PERCENT); + } + } + else if(SfxItemState::DISABLED == eState) + { + mxMtrTrans->set_sensitive(false); + } + else + { + mxMtrTrans->set_sensitive(true); + mxMtrTrans->set_text(OUString()); + } + break; + } + case SID_ATTR_GRAF_MODE: + { + if(eState >= SfxItemState::DEFAULT) + { + mxLBColorMode->set_sensitive(true); + + if(pState) + { + const sal_uInt16 nTrans = static_cast< const SfxUInt16Item* >(pState)->GetValue(); + mxLBColorMode->set_active(nTrans); + } + } + else if(SfxItemState::DISABLED == eState) + { + mxLBColorMode->set_sensitive(false); + } + else + { + mxLBColorMode->set_sensitive(true); + mxLBColorMode->set_active(-1); + } + break; + } + } +} + +// namespace close + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/graphic/GraphicPropertyPanel.hxx b/svx/source/sidebar/graphic/GraphicPropertyPanel.hxx new file mode 100644 index 000000000..e7fd4914b --- /dev/null +++ b/svx/source/sidebar/graphic/GraphicPropertyPanel.hxx @@ -0,0 +1,89 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_GRAPHIC_GRAPHICPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_GRAPHIC_GRAPHICPROPERTYPANEL_HXX + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> +#include <vcl/weld.hxx> + +namespace svx::sidebar { + +class GraphicPropertyPanel +: public PanelLayout, + public ::sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface +{ +public: + virtual ~GraphicPropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create( + weld::Widget* pParent, + SfxBindings* pBindings); + + virtual void NotifyItemUpdate( + const sal_uInt16 nSId, + const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void GetControlState( + const sal_uInt16 /*nSId*/, + boost::property_tree::ptree& /*rState*/) override {}; + + SfxBindings* GetBindings() { return mpBindings;} + + // constructor/destructor + GraphicPropertyPanel( + weld::Widget* pParent, + SfxBindings* pBindings); + +private: + ::sfx2::sidebar::ControllerItem maBrightControl; + ::sfx2::sidebar::ControllerItem maContrastControl; + ::sfx2::sidebar::ControllerItem maTransparenceControl; + ::sfx2::sidebar::ControllerItem maRedControl; + ::sfx2::sidebar::ControllerItem maGreenControl; + ::sfx2::sidebar::ControllerItem maBlueControl; + ::sfx2::sidebar::ControllerItem maGammaControl; + ::sfx2::sidebar::ControllerItem maModeControl; + + SfxBindings* mpBindings; + + //ui controls + std::unique_ptr<weld::MetricSpinButton> mxMtrBrightness; + std::unique_ptr<weld::MetricSpinButton> mxMtrContrast; + std::unique_ptr<weld::ComboBox> mxLBColorMode; + std::unique_ptr<weld::MetricSpinButton> mxMtrTrans; + std::unique_ptr<weld::MetricSpinButton> mxMtrRed; + std::unique_ptr<weld::MetricSpinButton> mxMtrGreen; + std::unique_ptr<weld::MetricSpinButton> mxMtrBlue; + std::unique_ptr<weld::SpinButton> mxMtrGamma; + + DECL_LINK( ModifyBrightnessHdl, weld::MetricSpinButton&, void ); + DECL_LINK( ModifyContrastHdl, weld::MetricSpinButton&, void ); + DECL_LINK( ModifyTransHdl, weld::MetricSpinButton&, void ); + DECL_LINK( ClickColorModeHdl, weld::ComboBox&, void ); + + void Initialize(); +}; + +} // end of namespace svx::sidebar + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/inspector/InspectorTextPanel.cxx b/svx/source/sidebar/inspector/InspectorTextPanel.cxx new file mode 100644 index 000000000..0b5da3d2d --- /dev/null +++ b/svx/source/sidebar/inspector/InspectorTextPanel.cxx @@ -0,0 +1,173 @@ +/* -*- 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 <o3tl/safeint.hxx> +#include <sal/config.h> + +#include <svx/dialmgr.hxx> + +#include <svx/sidebar/InspectorTextPanel.hxx> + +#include <svl/cjkoptions.hxx> +#include <svl/ctloptions.hxx> +#include <com/sun/star/awt/FontSlant.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <inspectorvalues.hrc> + +using namespace css; + +const int MinimumPanelWidth = 250; + +namespace svx::sidebar +{ +std::unique_ptr<PanelLayout> InspectorTextPanel::Create(weld::Widget* pParent) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to InspectorTextPanel::Create", + nullptr, 0); + return std::make_unique<InspectorTextPanel>(pParent); +} + +InspectorTextPanel::InspectorTextPanel(weld::Widget* pParent) + : PanelLayout(pParent, "InspectorTextPanel", "svx/ui/inspectortextpanel.ui") + , mpListBoxStyles(m_xBuilder->weld_tree_view("listbox_fonts")) +{ + mpListBoxStyles->set_size_request(MinimumPanelWidth, -1); + float fWidth = mpListBoxStyles->get_approximate_digit_width(); + std::vector<int> aWidths{ o3tl::narrowing<int>(fWidth * 29) }; + // 2nd column will fill remaining space + mpListBoxStyles->set_column_fixed_widths(aWidths); +} + +static bool GetPropertyValues(std::u16string_view rPropName, const uno::Any& rAny, + OUString& rString) +{ + // Hide Asian and Complex properties + if (!SvtCJKOptions::IsCJKFontEnabled() && rPropName.find(u"Asian") != std::u16string_view::npos) + return false; + if (!SvtCTLOptions().IsCTLFontEnabled() + && rPropName.find(u"Complex") != std::u16string_view::npos) + return false; + + if (bool bValue; rAny >>= bValue) + { + rString = SvxResId(bValue ? RID_TRUE : RID_FALSE); // tdf#139136 + } + else if (OUString aValue; (rAny >>= aValue) && !(aValue.isEmpty())) + { + rString = aValue; + } + else if (awt::FontSlant eValue; rAny >>= eValue) + { + rString = SvxResId(eValue == awt::FontSlant_ITALIC ? RID_ITALIC : RID_NORMAL); + } + else if (tools::Long nValueLong; rAny >>= nValueLong) + { + if (rPropName.find(u"Color") != std::u16string_view::npos) + rString = "0x" + OUString::number(nValueLong, 16); + else + rString = OUString::number(nValueLong); + } + else if (double fValue; rAny >>= fValue) + { + if (rPropName.find(u"Weight") != std::u16string_view::npos) + rString = SvxResId(fValue > 100 ? RID_BOLD : RID_NORMAL); + else + rString = OUString::number((round(fValue * 100)) / 100.00); + } + else if (short nValueShort; rAny >>= nValueShort) + { + rString = OUString::number(nValueShort); + } + else + return false; + + return true; +} + +static void FillBox_Impl(weld::TreeView& rListBoxStyles, const TreeNode& rCurrent, + const weld::TreeIter* pParent) +{ + std::unique_ptr<weld::TreeIter> pResult = rListBoxStyles.make_iterator(); + const OUString& rName = rCurrent.sNodeName; + OUString sPairValue; + + if (!(rCurrent.NodeType != TreeNode::SimpleProperty + || GetPropertyValues(rName, rCurrent.aValue, sPairValue))) + return; + + rListBoxStyles.insert(pParent, -1, &rName, nullptr, nullptr, nullptr, false, pResult.get()); + rListBoxStyles.set_sensitive(*pResult, !rCurrent.isGrey, 0); + rListBoxStyles.set_text_emphasis(*pResult, rCurrent.NodeType == TreeNode::Category, 0); + + if (rCurrent.NodeType == TreeNode::SimpleProperty) + { + rListBoxStyles.set_text(*pResult, sPairValue, 1); + rListBoxStyles.set_sensitive(*pResult, !rCurrent.isGrey, 1); + rListBoxStyles.set_text_emphasis(*pResult, false, 1); + } + else + { + // Necessary, without this the selection line will be truncated. + rListBoxStyles.set_text(*pResult, "", 1); + } + + for (const TreeNode& rChildNode : rCurrent.children) + FillBox_Impl(rListBoxStyles, rChildNode, pResult.get()); +} + +void InspectorTextPanel::updateEntries(const std::vector<TreeNode>& rStore, const sal_Int32 nParIdx) +{ + mpListBoxStyles->freeze(); + mpListBoxStyles->clear(); + for (const TreeNode& rChildNode : rStore) + { + FillBox_Impl(*mpListBoxStyles, rChildNode, nullptr); + } + + mpListBoxStyles->thaw(); + + weld::TreeView* pTreeDiagram = mpListBoxStyles.get(); + pTreeDiagram->all_foreach([pTreeDiagram](weld::TreeIter& rEntry) { + pTreeDiagram->expand_row(rEntry); + return false; + }); + + // Collapse "Default Paragraph Style" + + std::unique_ptr<weld::TreeIter> pEntry = mpListBoxStyles->make_iterator(); + if (!mpListBoxStyles->get_iter_first(*pEntry)) + return; + // skip the optional metadata items before "Default Paragraph Style" + for (sal_Int32 i = 0; i < nParIdx; ++i) + { + if (!mpListBoxStyles->iter_next_sibling(*pEntry)) + return; + } + if (!mpListBoxStyles->iter_next(*pEntry)) + return; + + mpListBoxStyles->collapse_row(*pEntry); +} + +InspectorTextPanel::~InspectorTextPanel() {} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/line/LinePropertyPanel.cxx b/svx/source/sidebar/line/LinePropertyPanel.cxx new file mode 100644 index 000000000..02dd597bd --- /dev/null +++ b/svx/source/sidebar/line/LinePropertyPanel.cxx @@ -0,0 +1,165 @@ +/* -*- 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 "LinePropertyPanel.hxx" +#include <svx/svxids.hrc> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlntrit.hxx> +#include <svx/xlncapit.hxx> +#include <svx/xlinjoit.hxx> +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +using namespace css; +using namespace css::uno; + +namespace svx::sidebar { + +LinePropertyPanel::LinePropertyPanel( + weld::Widget* pParent, + const uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings) +: LinePropertyPanelBase(pParent, rxFrame), + maStyleControl(SID_ATTR_LINE_STYLE, *pBindings, *this), + maDashControl (SID_ATTR_LINE_DASH, *pBindings, *this), + maWidthControl(SID_ATTR_LINE_WIDTH, *pBindings, *this), + maTransControl(SID_ATTR_LINE_TRANSPARENCE, *pBindings, *this), + maEdgeStyle(SID_ATTR_LINE_JOINT, *pBindings, *this), + maCapStyle(SID_ATTR_LINE_CAP, *pBindings, *this), + mpBindings(pBindings) +{ + setMapUnit(maWidthControl.GetCoreMetric()); +} + +LinePropertyPanel::~LinePropertyPanel() +{ + maStyleControl.dispose(); + maDashControl.dispose(); + maWidthControl.dispose(); + maTransControl.dispose(); + maEdgeStyle.dispose(); + maCapStyle.dispose(); +} + +std::unique_ptr<PanelLayout> LinePropertyPanel::Create ( + weld::Widget* pParent, + const uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to LinePropertyPanel::Create", nullptr, 0); + if ( ! rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to LinePropertyPanel::Create", nullptr, 1); + if (pBindings == nullptr) + throw lang::IllegalArgumentException("no SfxBindings given to LinePropertyPanel::Create", nullptr, 2); + + return std::make_unique<LinePropertyPanel>(pParent, rxFrame, pBindings); +} + +void LinePropertyPanel::NotifyItemUpdate( + sal_uInt16 nSID, + SfxItemState eState, + const SfxPoolItem* pState) +{ + const bool bDisabled(SfxItemState::DISABLED == eState); + const bool bSetOrDefault = eState >= SfxItemState::DEFAULT; + + switch(nSID) + { + case SID_ATTR_LINE_TRANSPARENCE: + { + updateLineTransparence(bDisabled, bSetOrDefault, pState); + break; + } + case SID_ATTR_LINE_WIDTH: + { + updateLineWidth(bDisabled, bSetOrDefault, pState); + break; + } + case SID_ATTR_LINE_JOINT: + { + updateLineJoint(bDisabled, bSetOrDefault, pState); + break; + } + case SID_ATTR_LINE_CAP: + { + updateLineCap(bDisabled, bSetOrDefault, pState); + break; + } + } + ActivateControls(); +} + +void LinePropertyPanel::HandleContextChange( + const vcl::EnumContext& rContext) +{ + if(maContext == rContext) + { + // Nothing to do + return; + } + + maContext = rContext; + bool bShowArrows = false; + + switch(maContext.GetCombinedContext_DI()) + { + case CombinedEnumContext(Application::Calc, Context::DrawLine): + case CombinedEnumContext(Application::DrawImpress, Context::DrawLine): + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::WriterVariants, Context::Draw): + // TODO : Implement DrawLine context in Writer + bShowArrows = true; + break; + } + + if (!bShowArrows) + disableArrowHead(); + else + enableArrowHead(); +} + +void LinePropertyPanel::setLineJoint(const XLineJointItem* pItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_LINE_JOINT, + SfxCallMode::RECORD, { pItem }); +} + +void LinePropertyPanel::setLineCap(const XLineCapItem* pItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_LINE_CAP, + SfxCallMode::RECORD, { pItem }); +} + +void LinePropertyPanel::setLineTransparency(const XLineTransparenceItem& rItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_LINE_STYLE, + SfxCallMode::RECORD, { &rItem }); +} + +void LinePropertyPanel::setLineWidth(const XLineWidthItem& rItem) +{ + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_LINE_WIDTH, + SfxCallMode::RECORD, { &rItem }); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/line/LinePropertyPanel.hxx b/svx/source/sidebar/line/LinePropertyPanel.hxx new file mode 100644 index 000000000..7223cd9f1 --- /dev/null +++ b/svx/source/sidebar/line/LinePropertyPanel.hxx @@ -0,0 +1,96 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_LINE_LINEPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_LINE_LINEPROPERTYPANEL_HXX + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <sfx2/sidebar/IContextChangeReceiver.hxx> +#include <svx/sidebar/LinePropertyPanelBase.hxx> +#include <vcl/EnumContext.hxx> + +class XLineStyleItem; +class XLineDashItem; +class XLineStartItem; +class XLineEndItem; +class XLineEndList; +class XDashList; +class ListBox; +class ToolBox; + +namespace svx::sidebar +{ + +class LinePropertyPanel : public LinePropertyPanelBase, + public sfx2::sidebar::IContextChangeReceiver, + public sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface +{ +public: + virtual ~LinePropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings); + + virtual void HandleContextChange( + const vcl::EnumContext& rContext) override; + + virtual void NotifyItemUpdate( + const sal_uInt16 nSId, + const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void GetControlState( + const sal_uInt16 /*nSId*/, + boost::property_tree::ptree& /*rState*/) override {}; + + SfxBindings* GetBindings() { return mpBindings;} + + // constructor/destructor + LinePropertyPanel( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings); + + virtual void setLineWidth(const XLineWidthItem& rItem) override; + +protected: + + virtual void setLineTransparency(const XLineTransparenceItem& rItem) override; + virtual void setLineJoint(const XLineJointItem* pItem) override; + virtual void setLineCap(const XLineCapItem* pItem) override; + +private: + //ControllerItem + sfx2::sidebar::ControllerItem maStyleControl; + sfx2::sidebar::ControllerItem maDashControl; + sfx2::sidebar::ControllerItem maWidthControl; + sfx2::sidebar::ControllerItem maTransControl; + sfx2::sidebar::ControllerItem maEdgeStyle; + sfx2::sidebar::ControllerItem maCapStyle; + + SfxBindings* mpBindings; + vcl::EnumContext maContext; +}; + +} // end of namespace svx::sidebar + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/line/LinePropertyPanelBase.cxx b/svx/source/sidebar/line/LinePropertyPanelBase.cxx new file mode 100644 index 000000000..454e16a33 --- /dev/null +++ b/svx/source/sidebar/line/LinePropertyPanelBase.cxx @@ -0,0 +1,470 @@ +/* -*- 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 <svx/sidebar/LinePropertyPanelBase.hxx> +#include <sfx2/weldutils.hxx> +#include <svx/linectrl.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlntrit.hxx> +#include <svx/xlncapit.hxx> +#include <svx/xlinjoit.hxx> +#include <bitmaps.hlst> + +using namespace css; +using namespace css::uno; + +constexpr OStringLiteral SELECTWIDTH = "SelectWidth"; + +namespace svx::sidebar { + +// trigger disabling the arrows if the none line style is selected +class LineStyleNoneChange +{ +private: + LinePropertyPanelBase& m_rPanel; + +public: + LineStyleNoneChange(LinePropertyPanelBase& rPanel) + : m_rPanel(rPanel) + { + } + + void operator()(bool bLineStyleNone) + { + m_rPanel.SetNoneLineStyle(bLineStyleNone); + } +}; + +namespace +{ + SvxLineStyleToolBoxControl* getLineStyleToolBoxControl(const ToolbarUnoDispatcher& rToolBoxColor) + { + css::uno::Reference<css::frame::XToolbarController> xController = rToolBoxColor.GetControllerForCommand(".uno:XLineStyle"); + SvxLineStyleToolBoxControl* pToolBoxLineStyleControl = dynamic_cast<SvxLineStyleToolBoxControl*>(xController.get()); + return pToolBoxLineStyleControl; + } +} + + +LinePropertyPanelBase::LinePropertyPanelBase( + weld::Widget* pParent, + const uno::Reference<css::frame::XFrame>& rxFrame) +: PanelLayout(pParent, "LinePropertyPanel", "svx/ui/sidebarline.ui"), + mxTBColor(m_xBuilder->weld_toolbar("color")), + mxColorDispatch(new ToolbarUnoDispatcher(*mxTBColor, *m_xBuilder, rxFrame)), + mxLineStyleTB(m_xBuilder->weld_toolbar("linestyle")), + mxLineStyleDispatch(new ToolbarUnoDispatcher(*mxLineStyleTB, *m_xBuilder, rxFrame)), + mnWidthCoreValue(0), + mxFTWidth(m_xBuilder->weld_label("widthlabel")), + mxTBWidth(m_xBuilder->weld_toolbar("width")), + mxFTTransparency(m_xBuilder->weld_label("translabel")), + mxMFTransparent(m_xBuilder->weld_metric_spin_button("linetransparency", FieldUnit::PERCENT)), + mxFTEdgeStyle(m_xBuilder->weld_label("cornerlabel")), + mxLBEdgeStyle(m_xBuilder->weld_combo_box("edgestyle")), + mxFTCapStyle(m_xBuilder->weld_label("caplabel")), + mxLBCapStyle(m_xBuilder->weld_combo_box("linecapstyle")), + mxGridLineProps(m_xBuilder->weld_widget("lineproperties")), + mxBoxArrowProps(m_xBuilder->weld_widget("arrowproperties")), + mxLineWidthPopup(new LineWidthPopup(mxTBWidth.get(), *this)), + mxLineStyleNoneChange(new LineStyleNoneChange(*this)), + mnTrans(0), + meMapUnit(MapUnit::MapMM), + maIMGNone(BMP_NONE_ICON), + mbWidthValuable(true), + mbArrowSupported(true), + mbNoneLineStyle(false) +{ + Initialize(); +} + +LinePropertyPanelBase::~LinePropertyPanelBase() +{ + mxLineWidthPopup.reset(); + mxFTWidth.reset(); + mxTBWidth.reset(); + mxColorDispatch.reset(); + mxTBColor.reset(); + mxFTTransparency.reset(); + mxMFTransparent.reset(); + mxLineStyleDispatch.reset(); + mxLineStyleTB.reset(); + mxFTEdgeStyle.reset(); + mxLBEdgeStyle.reset(); + mxFTCapStyle.reset(); + mxLBCapStyle.reset(); + mxGridLineProps.reset(); + mxBoxArrowProps.reset(); +} + +void LinePropertyPanelBase::Initialize() +{ + mxTBWidth->set_item_popover(SELECTWIDTH, mxLineWidthPopup->getTopLevel()); + + maIMGWidthIcon[0] = BMP_WIDTH1_ICON; + maIMGWidthIcon[1] = BMP_WIDTH2_ICON; + maIMGWidthIcon[2] = BMP_WIDTH3_ICON; + maIMGWidthIcon[3] = BMP_WIDTH4_ICON; + maIMGWidthIcon[4] = BMP_WIDTH5_ICON; + maIMGWidthIcon[5] = BMP_WIDTH6_ICON; + maIMGWidthIcon[6] = BMP_WIDTH7_ICON; + maIMGWidthIcon[7] = BMP_WIDTH8_ICON; + + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[0]); + mxTBWidth->connect_clicked(LINK(this, LinePropertyPanelBase, ToolboxWidthSelectHdl)); + + mxMFTransparent->connect_value_changed(LINK(this, LinePropertyPanelBase, ChangeTransparentHdl)); + + mxLBEdgeStyle->connect_changed( LINK( this, LinePropertyPanelBase, ChangeEdgeStyleHdl ) ); + + mxLBCapStyle->connect_changed( LINK( this, LinePropertyPanelBase, ChangeCapStyleHdl ) ); + + SvxLineStyleToolBoxControl* pLineStyleControl = getLineStyleToolBoxControl(*mxLineStyleDispatch); + pLineStyleControl->setLineStyleIsNoneFunction(*mxLineStyleNoneChange); +} + +void LinePropertyPanelBase::updateLineTransparence(bool bDisabled, bool bSetOrDefault, + const SfxPoolItem* pState) +{ + if(bDisabled) + { + mxFTTransparency->set_sensitive(false); + mxMFTransparent->set_sensitive(false); + } + else + { + mxFTTransparency->set_sensitive(true); + mxMFTransparent->set_sensitive(true); + } + + if(bSetOrDefault) + { + if (const XLineTransparenceItem* pItem = dynamic_cast<const XLineTransparenceItem*>(pState)) + { + mnTrans = pItem->GetValue(); + mxMFTransparent->set_value(mnTrans, FieldUnit::PERCENT); + return; + } + } + + mxMFTransparent->set_value(0, FieldUnit::PERCENT);//add + mxMFTransparent->set_text(OUString()); +} + +void LinePropertyPanelBase::updateLineWidth(bool bDisabled, bool bSetOrDefault, + const SfxPoolItem* pState) +{ + if(bDisabled) + { + mxTBWidth->set_sensitive(false); + mxFTWidth->set_sensitive(false); + } + else + { + mxTBWidth->set_sensitive(true); + mxFTWidth->set_sensitive(true); + } + + if(bSetOrDefault) + { + if (const XLineWidthItem* pItem = dynamic_cast<const XLineWidthItem*>(pState)) + { + mnWidthCoreValue = pItem->GetValue(); + mbWidthValuable = true; + SetWidthIcon(); + return; + } + } + + mbWidthValuable = false; + SetWidthIcon(); +} + +void LinePropertyPanelBase::updateLineJoint(bool bDisabled, bool bSetOrDefault, + const SfxPoolItem* pState) +{ + if(bDisabled) + { + mxLBEdgeStyle->set_sensitive(false); + mxFTEdgeStyle->set_sensitive(false); + } + else + { + mxLBEdgeStyle->set_sensitive(true); + mxFTEdgeStyle->set_sensitive(true); + } + + if(bSetOrDefault) + { + if (const XLineJointItem* pItem = dynamic_cast<const XLineJointItem*>(pState)) + { + sal_Int32 nEntryPos(0); + + switch(pItem->GetValue()) + { + case drawing::LineJoint_ROUND: + { + nEntryPos = 1; + break; + } + case drawing::LineJoint_NONE: + { + nEntryPos = 2; + break; + } + case drawing::LineJoint_MIDDLE: + case drawing::LineJoint_MITER: + { + nEntryPos = 3; + break; + } + case drawing::LineJoint_BEVEL: + { + nEntryPos = 4; + break; + } + + default: + break; + } + + if(nEntryPos) + { + mxLBEdgeStyle->set_active(nEntryPos - 1); + return; + } + } + } + + mxLBEdgeStyle->set_active(-1); +} + +void LinePropertyPanelBase::updateLineCap(bool bDisabled, bool bSetOrDefault, + const SfxPoolItem* pState) +{ + if(bDisabled) + { + mxLBCapStyle->set_sensitive(false); + mxFTCapStyle->set_sensitive(false); + } + else + { + mxLBCapStyle->set_sensitive(true); + mxLBCapStyle->set_sensitive(true); + } + + if(bSetOrDefault) + { + if (const XLineCapItem* pItem = dynamic_cast<const XLineCapItem*>(pState)) + { + sal_Int32 nEntryPos(0); + + switch(pItem->GetValue()) + { + case drawing::LineCap_BUTT: + { + nEntryPos = 1; + break; + } + case drawing::LineCap_ROUND: + { + nEntryPos = 2; + break; + } + case drawing::LineCap_SQUARE: + { + nEntryPos = 3; + break; + } + + default: + break; + } + + if(nEntryPos) + { + mxLBCapStyle->set_active(nEntryPos - 1); + return; + } + } + } + + mxLBCapStyle->set_active(-1); +} + +IMPL_LINK_NOARG(LinePropertyPanelBase, ChangeEdgeStyleHdl, weld::ComboBox&, void) +{ + const sal_Int32 nPos(mxLBEdgeStyle->get_active()); + + if (nPos == -1 || !mxLBEdgeStyle->get_value_changed_from_saved()) + return; + + std::unique_ptr<XLineJointItem> pItem; + + switch(nPos) + { + case 0: // rounded + { + pItem.reset(new XLineJointItem(drawing::LineJoint_ROUND)); + break; + } + case 1: // none + { + pItem.reset(new XLineJointItem(drawing::LineJoint_NONE)); + break; + } + case 2: // mitered + { + pItem.reset(new XLineJointItem(drawing::LineJoint_MITER)); + break; + } + case 3: // beveled + { + pItem.reset(new XLineJointItem(drawing::LineJoint_BEVEL)); + break; + } + } + + setLineJoint(pItem.get()); +} + +IMPL_LINK_NOARG(LinePropertyPanelBase, ChangeCapStyleHdl, weld::ComboBox&, void) +{ + const sal_Int32 nPos(mxLBCapStyle->get_active()); + + if (!(nPos != -1 && mxLBCapStyle->get_value_changed_from_saved())) + return; + + std::unique_ptr<XLineCapItem> pItem; + + switch(nPos) + { + case 0: // flat + { + pItem.reset(new XLineCapItem(drawing::LineCap_BUTT)); + break; + } + case 1: // round + { + pItem.reset(new XLineCapItem(drawing::LineCap_ROUND)); + break; + } + case 2: // square + { + pItem.reset(new XLineCapItem(drawing::LineCap_SQUARE)); + break; + } + } + + setLineCap(pItem.get()); +} + +IMPL_LINK_NOARG(LinePropertyPanelBase, ToolboxWidthSelectHdl, const OString&, void) +{ + mxTBWidth->set_menu_item_active(SELECTWIDTH, !mxTBWidth->get_menu_item_active(SELECTWIDTH)); +} + +void LinePropertyPanelBase::EndLineWidthPopup() +{ + mxTBWidth->set_menu_item_active(SELECTWIDTH, false); +} + +IMPL_LINK_NOARG( LinePropertyPanelBase, ChangeTransparentHdl, weld::MetricSpinButton&, void ) +{ + sal_uInt16 nVal = static_cast<sal_uInt16>(mxMFTransparent->get_value(FieldUnit::PERCENT)); + XLineTransparenceItem aItem( nVal ); + + setLineTransparency(aItem); +} + +void LinePropertyPanelBase::SetWidthIcon(int n) +{ + if (n == 0) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGNone); + else + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[n-1]); +} + +void LinePropertyPanelBase::SetWidthIcon() +{ + if(!mbWidthValuable) + { + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGNone); + return; + } + + tools::Long nVal = OutputDevice::LogicToLogic(mnWidthCoreValue * 10, meMapUnit, MapUnit::MapPoint); + + if(nVal <= 6) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[0]); + else if (nVal <= 9) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[1]); + else if (nVal <= 12) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[2]); + else if (nVal <= 19) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[3]); + else if (nVal <= 26) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[4]); + else if (nVal <= 37) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[5]); + else if (nVal <= 52) + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[6]); + else + mxTBWidth->set_item_icon_name(SELECTWIDTH, maIMGWidthIcon[7]); + +} + +void LinePropertyPanelBase::SetWidth(tools::Long nWidth) +{ + mnWidthCoreValue = nWidth; + mbWidthValuable = true; + mxLineWidthPopup->SetWidthSelect(mnWidthCoreValue, mbWidthValuable, meMapUnit); +} + +void LinePropertyPanelBase::ActivateControls() +{ + mxGridLineProps->set_sensitive(!mbNoneLineStyle); + mxBoxArrowProps->set_sensitive(!mbNoneLineStyle); + mxLineStyleTB->set_item_sensitive(".uno:LineEndStyle", !mbNoneLineStyle); + + mxBoxArrowProps->set_visible(mbArrowSupported); + mxLineStyleTB->set_item_visible(".uno:LineEndStyle", mbArrowSupported); +} + +void LinePropertyPanelBase::setMapUnit(MapUnit eMapUnit) +{ + meMapUnit = eMapUnit; + mxLineWidthPopup->SetWidthSelect(mnWidthCoreValue, mbWidthValuable, meMapUnit); +} + +void LinePropertyPanelBase::disableArrowHead() +{ + mbArrowSupported = false; + ActivateControls(); +} + +void LinePropertyPanelBase::enableArrowHead() +{ + mbArrowSupported = true; + ActivateControls(); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/line/LineWidthPopup.cxx b/svx/source/sidebar/line/LineWidthPopup.cxx new file mode 100644 index 000000000..347bb2a3b --- /dev/null +++ b/svx/source/sidebar/line/LineWidthPopup.cxx @@ -0,0 +1,223 @@ +/* -*- 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 <svx/sidebar/LineWidthPopup.hxx> +#include <svx/sidebar/LinePropertyPanelBase.hxx> +#include <com/sun/star/beans/NamedValue.hpp> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <svx/xlnwtit.hxx> +#include <unotools/localedatawrapper.hxx> +#include <unotools/viewoptions.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include "LineWidthValueSet.hxx" +#include <bitmaps.hlst> + +namespace svx::sidebar +{ +LineWidthPopup::LineWidthPopup(weld::Widget* pParent, LinePropertyPanelBase& rParent) + : WeldToolbarPopup(nullptr, pParent, "svx/ui/floatinglineproperty.ui", "FloatingLineProperty") + , m_rParent(rParent) + , m_sPt(SvxResId(RID_SVXSTR_PT)) + , m_eMapUnit(MapUnit::MapTwip) + , m_bVSFocus(true) + , m_bCustom(false) + , m_nCustomWidth(0) + , m_aIMGCus(StockImage::Yes, RID_SVXBMP_WIDTH_CUSTOM) + , m_aIMGCusGray(StockImage::Yes, RID_SVXBMP_WIDTH_CUSTOM_GRAY) + , m_xMFWidth(m_xBuilder->weld_metric_spin_button("spin", FieldUnit::POINT)) + , m_xVSWidth(new LineWidthValueSet()) + , m_xVSWidthWin(new weld::CustomWeld(*m_xBuilder, "lineset", *m_xVSWidth)) +{ + m_xVSWidth->SetStyle(m_xVSWidth->GetStyle() | WB_3DLOOK | WB_NO_DIRECTSELECT); + + maStrUnits[0] = "0.5"; + maStrUnits[1] = "0.8"; + maStrUnits[2] = "1.0"; + maStrUnits[3] = "1.5"; + maStrUnits[4] = "2.3"; + maStrUnits[5] = "3.0"; + maStrUnits[6] = "4.5"; + maStrUnits[7] = "6.0"; + maStrUnits[8] = SvxResId(RID_SVXSTR_WIDTH_LAST_CUSTOM); + + const LocaleDataWrapper& rLocaleWrapper(Application::GetSettings().GetLocaleDataWrapper()); + const sal_Unicode cSep = rLocaleWrapper.getNumDecimalSep()[0]; + + for (int i = 0; i <= 7; i++) + { + maStrUnits[i] = maStrUnits[i].replace('.', cSep); //Modify + maStrUnits[i] += " "; + maStrUnits[i] += m_sPt; + } + + for (sal_uInt16 i = 1; i <= 9; ++i) + { + m_xVSWidth->InsertItem(i); + m_xVSWidth->SetItemText(i, maStrUnits[i - 1]); + } + + m_xVSWidth->SetUnit(maStrUnits); + m_xVSWidth->SetItemData(1, reinterpret_cast<void*>(5)); + m_xVSWidth->SetItemData(2, reinterpret_cast<void*>(8)); + m_xVSWidth->SetItemData(3, reinterpret_cast<void*>(10)); + m_xVSWidth->SetItemData(4, reinterpret_cast<void*>(15)); + m_xVSWidth->SetItemData(5, reinterpret_cast<void*>(23)); + m_xVSWidth->SetItemData(6, reinterpret_cast<void*>(30)); + m_xVSWidth->SetItemData(7, reinterpret_cast<void*>(45)); + m_xVSWidth->SetItemData(8, reinterpret_cast<void*>(60)); + m_xVSWidth->SetImage(m_aIMGCusGray); + + m_xVSWidth->SetSelItem(0); + + m_xVSWidth->SetSelectHdl(LINK(this, LineWidthPopup, VSSelectHdl)); + m_xMFWidth->connect_value_changed(LINK(this, LineWidthPopup, MFModifyHdl)); +} + +LineWidthPopup::~LineWidthPopup() {} + +IMPL_LINK_NOARG(LineWidthPopup, VSSelectHdl, ValueSet*, void) +{ + sal_uInt16 iPos = m_xVSWidth->GetSelectedItemId(); + if (iPos >= 1 && iPos <= 8) + { + sal_IntPtr nVal = OutputDevice::LogicToLogic( + reinterpret_cast<sal_IntPtr>(m_xVSWidth->GetItemData(iPos)), MapUnit::MapPoint, + m_eMapUnit); + nVal = m_xMFWidth->denormalize(nVal); + XLineWidthItem aWidthItem(nVal); + m_rParent.setLineWidth(aWidthItem); + m_rParent.SetWidthIcon(iPos); + m_rParent.SetWidth(nVal); + } + else if (iPos == 9) + { //last custom + //modified + if (m_bCustom) + { + tools::Long nVal + = OutputDevice::LogicToLogic(m_nCustomWidth, MapUnit::MapPoint, m_eMapUnit); + nVal = m_xMFWidth->denormalize(nVal); + XLineWidthItem aWidthItem(nVal); + m_rParent.setLineWidth(aWidthItem); + m_rParent.SetWidth(nVal); + } + else + { + m_xVSWidth->SetNoSelection(); //add , set no selection and keep the last select item + m_xVSWidth->SetFormat(); + m_xVSWidth->Invalidate(); + } + //modify end + } + + if ((iPos >= 1 && iPos <= 8) || (iPos == 9 && m_bCustom)) //add + { + m_rParent.EndLineWidthPopup(); + } +} + +IMPL_LINK_NOARG(LineWidthPopup, MFModifyHdl, weld::MetricSpinButton&, void) +{ + if (m_xVSWidth->GetSelItem()) + { + m_xVSWidth->SetSelItem(0); + m_xVSWidth->SetFormat(); + m_xVSWidth->Invalidate(); + } + tools::Long nTmp = static_cast<tools::Long>(m_xMFWidth->get_value(FieldUnit::NONE)); + tools::Long nVal = OutputDevice::LogicToLogic(nTmp, MapUnit::MapPoint, m_eMapUnit); + sal_Int32 nNewWidth = static_cast<short>(m_xMFWidth->denormalize(nVal)); + XLineWidthItem aWidthItem(nNewWidth); + m_rParent.setLineWidth(aWidthItem); +} + +void LineWidthPopup::SetWidthSelect(tools::Long lValue, bool bValuable, MapUnit eMapUnit) +{ + m_bVSFocus = true; + m_xVSWidth->SetSelItem(0); + m_eMapUnit = eMapUnit; + SvtViewOptions aWinOpt(EViewType::Window, "PopupPanel_LineWidth"); + if (aWinOpt.Exists()) + { + css::uno::Sequence<css::beans::NamedValue> aSeq = aWinOpt.GetUserData(); + OUString aTmp; + if (aSeq.hasElements()) + aSeq[0].Value >>= aTmp; + + OUString aWinData(aTmp); + m_nCustomWidth = aWinData.toInt32(); + m_bCustom = true; + m_xVSWidth->SetImage(m_aIMGCus); + m_xVSWidth->SetCusEnable(true); + + OUString aStrTip = OUString::number(static_cast<double>(m_nCustomWidth) / 10) + m_sPt; + m_xVSWidth->SetItemText(9, aStrTip); + } + else + { + m_bCustom = false; + m_xVSWidth->SetImage(m_aIMGCusGray); + m_xVSWidth->SetCusEnable(false); + m_xVSWidth->SetItemText(9, maStrUnits[8]); + } + + if (bValuable) + { + sal_Int64 nVal = OutputDevice::LogicToLogic(lValue, eMapUnit, MapUnit::Map100thMM); + nVal = m_xMFWidth->normalize(nVal); + m_xMFWidth->set_value(nVal, FieldUnit::MM_100TH); + } + else + { + m_xMFWidth->set_text(""); + } + + OUString strCurrValue = m_xMFWidth->get_text(); + sal_uInt16 i = 0; + for (; i < 8; i++) + { + if (strCurrValue == maStrUnits[i]) + { + m_xVSWidth->SetSelItem(i + 1); + break; + } + } + + if (i >= 8) + { + m_bVSFocus = false; + m_xVSWidth->SetSelItem(0); + } + + m_xVSWidth->SetFormat(); + m_xVSWidth->Invalidate(); +} + +void LineWidthPopup::GrabFocus() +{ + if (m_bVSFocus) + m_xVSWidth->GrabFocus(); + else + m_xMFWidth->grab_focus(); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/line/LineWidthValueSet.cxx b/svx/source/sidebar/line/LineWidthValueSet.cxx new file mode 100644 index 000000000..be518fe4f --- /dev/null +++ b/svx/source/sidebar/line/LineWidthValueSet.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 "LineWidthValueSet.hxx" + +#include <i18nlangtag/mslangid.hxx> +#include <vcl/event.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +namespace svx::sidebar { + +LineWidthValueSet::LineWidthValueSet() + : ValueSet(nullptr) + , nSelItem(0) + , bCusEnable(false) +{ +} + +void LineWidthValueSet::Resize() +{ + SetColCount(); + SetLineCount(9); + ValueSet::Resize(); +} + +LineWidthValueSet::~LineWidthValueSet() +{ +} + +void LineWidthValueSet::SetUnit(std::array<OUString,9> const & strUnits) +{ + maStrUnits = strUnits; +} + +void LineWidthValueSet::SetSelItem(sal_uInt16 nSel) +{ + nSelItem = nSel; + if(nSel == 0) + { + SelectItem(1); // ,false); // 'false' nut supported by AOO + SetNoSelection(); + } + else + { + SelectItem(nSelItem); + GrabFocus(); + } +} + +void LineWidthValueSet::SetImage(const Image& img) +{ + imgCus = img; +} + +void LineWidthValueSet::SetCusEnable(bool bEnable) +{ + bCusEnable = bEnable; +} + +void LineWidthValueSet::UserDraw( const UserDrawEvent& rUDEvt ) +{ + tools::Rectangle aRect = rUDEvt.GetRect(); + vcl::RenderContext* pDev = rUDEvt.GetRenderContext(); + sal_uInt16 nItemId = rUDEvt.GetItemId(); + + tools::Long nRectHeight = aRect.GetHeight(); + tools::Long nRectWidth = aRect.GetWidth(); + Point aBLPos = aRect.TopLeft(); + + //const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); + //Color aBackColor(0,0,200); + //const Color aTextColor = rStyleSettings.GetFieldTextColor(); + vcl::Font aOldFont = pDev->GetFont(); + Color aOldColor = pDev->GetLineColor(); + Color aOldFillColor = pDev->GetFillColor(); + + vcl::Font aFont(OutputDevice::GetDefaultFont(DefaultFontType::UI_SANS, MsLangId::getConfiguredSystemLanguage(), GetDefaultFontFlags::OnlyOne)); + Size aSize = aFont.GetFontSize(); + aSize.setHeight( nRectHeight*3/5 ); + aFont.SetFontSize( aSize ); + + Point aLineStart(aBLPos.X() + 5, aBLPos.Y() + ( nRectHeight - nItemId )/2); + Point aLineEnd(aBLPos.X() + nRectWidth * 7 / 9 - 10, aBLPos.Y() + ( nRectHeight - nItemId )/2); + if (nItemId == 9) + { + Point aImgStart(aBLPos.X() + 5, aBLPos.Y() + ( nRectHeight - 23 ) / 2); + pDev->DrawImage(aImgStart, imgCus); + + tools::Rectangle aStrRect = aRect; + aStrRect.AdjustTop(nRectHeight/6 ); + aStrRect.AdjustBottom( -(nRectHeight/6) ); + aStrRect.AdjustLeft(imgCus.GetSizePixel().Width() + 20 ); + if(bCusEnable) + aFont.SetColor(Application::GetSettings().GetStyleSettings().GetFieldTextColor()); + else + aFont.SetColor(Application::GetSettings().GetStyleSettings().GetDisableColor()); + + pDev->SetFont(aFont); + pDev->DrawText(aStrRect, maStrUnits[ nItemId - 1 ], DrawTextFlags::EndEllipsis); + } + else + { + if( nSelItem == nItemId ) + { + tools::Rectangle aBackRect = aRect; + aBackRect.AdjustTop(3 ); + aBackRect.AdjustBottom( -2 ); + pDev->SetFillColor(Color(50,107,197)); + pDev->DrawRect(aBackRect); + } + else + { + pDev->SetFillColor( COL_TRANSPARENT ); + pDev->DrawRect(aRect); + } + + //draw text + if(nSelItem == nItemId ) + aFont.SetColor(COL_WHITE); + else + aFont.SetColor(Application::GetSettings().GetStyleSettings().GetFieldTextColor()); + pDev->SetFont(aFont); + Point aStart(aBLPos.X() + nRectWidth * 7 / 9 , aBLPos.Y() + nRectHeight/6); + pDev->DrawText(aStart, maStrUnits[ nItemId - 1 ]); //can't set DrawTextFlags::EndEllipsis here ,or the text will disappear + + //draw line + if( nSelItem == nItemId ) + pDev->SetLineColor(COL_WHITE); + else + pDev->SetLineColor(Application::GetSettings().GetStyleSettings().GetFieldTextColor()); + + for(sal_uInt16 i = 1; i <= nItemId; i++) + { + pDev->DrawLine(aLineStart,aLineEnd ); + aLineStart.setY(aLineStart.getY() + 1); + aLineEnd.setY (aLineEnd.getY() + 1); + } + } + + Invalidate( aRect ); + pDev->SetLineColor(aOldColor); + pDev->SetFillColor(aOldFillColor); + pDev->SetFont(aOldFont); +} + +void LineWidthValueSet::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + ValueSet::SetDrawingArea(pDrawingArea); + Size aSize(pDrawingArea->get_ref_device().LogicToPixel(Size(80, 12 * 9), MapMode(MapUnit::MapAppFont))); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/line/LineWidthValueSet.hxx b/svx/source/sidebar/line/LineWidthValueSet.hxx new file mode 100644 index 000000000..225e706a6 --- /dev/null +++ b/svx/source/sidebar/line/LineWidthValueSet.hxx @@ -0,0 +1,55 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_LINE_LINEWIDTHVALUESET_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_LINE_LINEWIDTHVALUESET_HXX + +#include <svtools/valueset.hxx> +#include <vcl/image.hxx> +#include <array> + +namespace svx::sidebar { + +class LineWidthValueSet final : public ValueSet +{ +public: + explicit LineWidthValueSet(); + virtual ~LineWidthValueSet() override; + + void SetUnit(std::array<OUString,9> const & strUnits); + void SetSelItem(sal_uInt16 nSel); + sal_uInt16 GetSelItem() const { return nSelItem;} + void SetImage(const Image& img); + void SetCusEnable(bool bEnable); + + virtual void UserDraw( const UserDrawEvent& rUDEvt ) override; + virtual void Resize() override; + virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override; + +private: + sal_uInt16 nSelItem; + std::array<OUString,9> maStrUnits; + Image imgCus; + bool bCusEnable; +}; + +} // end of namespace svx::sidebar + +#endif // INCLUDED_SVX_SOURCE_SIDEBAR_LINE_LINEWIDTHVALUESET_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/lists/ListsPropertyPanel.cxx b/svx/source/sidebar/lists/ListsPropertyPanel.cxx new file mode 100644 index 000000000..58badf679 --- /dev/null +++ b/svx/source/sidebar/lists/ListsPropertyPanel.cxx @@ -0,0 +1,61 @@ +/* -*- 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 "ListsPropertyPanel.hxx" +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +using namespace css; +using namespace css::uno; + +namespace svx::sidebar +{ +std::unique_ptr<PanelLayout> +ListsPropertyPanel::Create(weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to ListsPropertyPanel::Create", + nullptr, 0); + if (!rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to ListsPropertyPanel::Create", + nullptr, 1); + + return std::make_unique<ListsPropertyPanel>(pParent, rxFrame); +} + +ListsPropertyPanel::ListsPropertyPanel(weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) + : PanelLayout(pParent, "ListsPropertyPanel", "svx/ui/sidebarlists.ui") + , mxTBxNumBullet(m_xBuilder->weld_toolbar("numberbullet")) + , mxNumBulletDispatcher(new ToolbarUnoDispatcher(*mxTBxNumBullet, *m_xBuilder, rxFrame)) + , mxTBxOutline(m_xBuilder->weld_toolbar("outline")) + , mxOutlineDispatcher(new ToolbarUnoDispatcher(*mxTBxOutline, *m_xBuilder, rxFrame)) +{ +} + +ListsPropertyPanel::~ListsPropertyPanel() +{ + mxOutlineDispatcher.reset(); + mxTBxOutline.reset(); + mxNumBulletDispatcher.reset(); + mxTBxNumBullet.reset(); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/lists/ListsPropertyPanel.hxx b/svx/source/sidebar/lists/ListsPropertyPanel.hxx new file mode 100644 index 000000000..ec20bb430 --- /dev/null +++ b/svx/source/sidebar/lists/ListsPropertyPanel.hxx @@ -0,0 +1,50 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_LISTS_LISTSPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_LISTS_LISTSPROPERTYPANEL_HXX + +#include <sfx2/weldutils.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> +#include <com/sun/star/frame/XFrame.hpp> + +namespace svx::sidebar +{ +class ListsPropertyPanel : public PanelLayout +{ +public: + virtual ~ListsPropertyPanel() override; + + static std::unique_ptr<PanelLayout> + Create(weld::Widget* pParent, const css::uno::Reference<css::frame::XFrame>& rxFrame); + + ListsPropertyPanel(weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + +private: + std::unique_ptr<weld::Toolbar> mxTBxNumBullet; + std::unique_ptr<ToolbarUnoDispatcher> mxNumBulletDispatcher; + std::unique_ptr<weld::Toolbar> mxTBxOutline; + std::unique_ptr<ToolbarUnoDispatcher> mxOutlineDispatcher; +}; + +} // end of namespace svx::sidebar + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/media/MediaPlaybackPanel.cxx b/svx/source/sidebar/media/MediaPlaybackPanel.cxx new file mode 100644 index 000000000..b23c612ff --- /dev/null +++ b/svx/source/sidebar/media/MediaPlaybackPanel.cxx @@ -0,0 +1,175 @@ +/* -*- 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 "MediaPlaybackPanel.hxx" +#include <avmedia/mediaitem.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/dispatch.hxx> +#include <avmedia/MediaControlBase.hxx> + +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +using namespace avmedia; + +namespace svx::sidebar { + +MediaPlaybackPanel::MediaPlaybackPanel ( + weld::Widget* pParent, + SfxBindings* pBindings) + : PanelLayout(pParent, "MediaPlaybackPanel", "svx/ui/mediaplayback.ui"), + maMediaController(SID_AVMEDIA_TOOLBOX, *pBindings, *this), + maIdle("MediaPlaybackPanel"), + mpBindings(pBindings) +{ + mxTimeEdit = m_xBuilder->weld_entry("timeedit"); + mxPlayToolBox = m_xBuilder->weld_toolbar("playtoolbox"); + mxMuteToolBox = m_xBuilder->weld_toolbar("mutetoolbox"); + mxTimeSlider = m_xBuilder->weld_scale("timeslider"); + mxVolumeSlider = m_xBuilder->weld_scale("volumeslider"); + mxZoomListBox = m_xBuilder->weld_combo_box("zoombox"); + + Initialize(); +} + +std::unique_ptr<PanelLayout> MediaPlaybackPanel::Create( + weld::Widget* pParent, + SfxBindings* pBindings) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to MediaPlaybackPanel::Create", nullptr, 0); + if (pBindings == nullptr) + throw lang::IllegalArgumentException("no SfxBindings given to MediaPlaybackPanel::Create", nullptr, 2); + + return std::make_unique<MediaPlaybackPanel>(pParent, pBindings); +} + +void MediaPlaybackPanel::Initialize() +{ + InitializeWidgets(); + mxVolumeSlider->connect_value_changed(LINK(this, MediaPlaybackPanel, VolumeSlideHdl)); + mxPlayToolBox->connect_clicked(LINK(this, MediaPlaybackPanel, PlayToolBoxSelectHdl)); + mxMuteToolBox->connect_clicked(LINK(this, MediaPlaybackPanel, PlayToolBoxSelectHdl)); + mxTimeSlider->connect_value_changed(LINK(this, MediaPlaybackPanel, SeekHdl)); + + maIdle.SetPriority( TaskPriority::HIGHEST ); + maIdle.SetInvokeHandler( LINK( this, MediaPlaybackPanel, TimeoutHdl ) ); + maIdle.Start(); + mpBindings->Invalidate(SID_AVMEDIA_TOOLBOX); +} + +MediaPlaybackPanel::~MediaPlaybackPanel() +{ + disposeWidgets(); +} + +void MediaPlaybackPanel::NotifyItemUpdate( + const sal_uInt16 nSID, + const SfxItemState eState, + const SfxPoolItem* pState) +{ + if( nSID == SID_AVMEDIA_TOOLBOX ) + { + if(eState >= SfxItemState::DEFAULT) + { + mpMediaItem.reset(pState ? static_cast< MediaItem* >(pState->Clone()) : nullptr); + Update(); + } + } +} + +void MediaPlaybackPanel::UpdateToolBoxes(const MediaItem& rMediaItem) +{ + mxPlayToolBox->set_sensitive(false); + avmedia::MediaControlBase::UpdateToolBoxes(rMediaItem); +} + +void MediaPlaybackPanel::Update() +{ + if (mpMediaItem) + { + UpdateToolBoxes( *mpMediaItem ); + UpdateTimeSlider( *mpMediaItem ); + UpdateVolumeSlider( *mpMediaItem ); + UpdateTimeField( *mpMediaItem, mpMediaItem->getTime() ); + } +} + +IMPL_LINK_NOARG( MediaPlaybackPanel, VolumeSlideHdl, weld::Scale&, void) +{ + MediaItem aItem(SID_AVMEDIA_TOOLBOX); + aItem.setVolumeDB(mxVolumeSlider->get_value()); + mpBindings->GetDispatcher()->ExecuteList(SID_AVMEDIA_TOOLBOX, SfxCallMode::RECORD, { &aItem }); +} + +IMPL_LINK_NOARG( MediaPlaybackPanel, SeekHdl, weld::Scale&, void) +{ + MediaItem aItem(SID_AVMEDIA_TOOLBOX); + double nTime = 0; + if (mpMediaItem) + nTime = mxTimeSlider->get_value() * mpMediaItem->getDuration() / AVMEDIA_TIME_RANGE; + aItem.setTime(nTime); + mpBindings->GetDispatcher()->ExecuteList(SID_AVMEDIA_TOOLBOX, SfxCallMode::RECORD, { &aItem }); + mpBindings->Invalidate(SID_AVMEDIA_TOOLBOX); +} + +IMPL_LINK_NOARG( MediaPlaybackPanel, TimeoutHdl, Timer*, void) +{ + mpBindings->Invalidate(SID_AVMEDIA_TOOLBOX); +} + +IMPL_LINK( MediaPlaybackPanel, PlayToolBoxSelectHdl, const OString&, rId, void) +{ + MediaItem aItem(SID_AVMEDIA_TOOLBOX); + + if (rId == "play") + { + aItem.setState( MediaState::Play ); + + if( !mpMediaItem || (mpMediaItem->getTime() == mpMediaItem->getDuration() )) + aItem.setTime( 0.0 ); + else + aItem.setTime( mpMediaItem->getTime()); + } + else if (rId == "pause") + { + aItem.setState( MediaState::Pause ); + } + else if (rId == "stop") + { + aItem.setState( MediaState::Stop ); + aItem.setTime( 0.0 ); + } + else if (rId == "mute") + { + aItem.setMute( mxMuteToolBox->get_item_active("mute") ); + } + else if (rId == "loop") + { + aItem.setLoop( mxPlayToolBox->get_item_active("loop") ); + } + + if(aItem.getMaskSet() != AVMediaSetMask::NONE) + { + mpBindings->GetDispatcher()->ExecuteList(SID_AVMEDIA_TOOLBOX, SfxCallMode::RECORD, { &aItem } ); + mpBindings->Invalidate(SID_AVMEDIA_TOOLBOX); + } +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/media/MediaPlaybackPanel.hxx b/svx/source/sidebar/media/MediaPlaybackPanel.hxx new file mode 100644 index 000000000..95f3d6eaa --- /dev/null +++ b/svx/source/sidebar/media/MediaPlaybackPanel.hxx @@ -0,0 +1,80 @@ +/* -*- 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 . + */ +#pragma once + +#include <memory> + +#include <sfx2/sidebar/PanelLayout.hxx> +#include <avmedia/mediaitem.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/sidebar/ControllerItem.hxx> +#include <avmedia/MediaControlBase.hxx> +#include <vcl/idle.hxx> + +using namespace css; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::frame; + +namespace svx::sidebar { + +/** This panel provides media playback control in document +*/ +class MediaPlaybackPanel + : public PanelLayout, + public ::sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface, + public ::avmedia::MediaControlBase +{ +public: + MediaPlaybackPanel ( + weld::Widget* pParent, + SfxBindings* pBindings); + static std::unique_ptr<PanelLayout> Create( + weld::Widget* pParent, + SfxBindings* pBindings); + virtual ~MediaPlaybackPanel() override; + +protected: + virtual void UpdateToolBoxes(const avmedia::MediaItem& rMediaItem) override; + +private: + std::unique_ptr< ::avmedia::MediaItem > mpMediaItem; + ::sfx2::sidebar::ControllerItem maMediaController; + Idle maIdle; + SfxBindings* mpBindings; + void Initialize(); + void Update(); + virtual void NotifyItemUpdate( const sal_uInt16 nSID, + const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void GetControlState( + const sal_uInt16 /*nSId*/, + boost::property_tree::ptree& /*rState*/) override {}; + + DECL_LINK(PlayToolBoxSelectHdl, const OString&, void); + DECL_LINK(VolumeSlideHdl, weld::Scale&, void); + DECL_LINK(SeekHdl, weld::Scale&, void); + + DECL_LINK(TimeoutHdl, Timer*, void); +}; + + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/nbdtmg.cxx b/svx/source/sidebar/nbdtmg.cxx new file mode 100644 index 000000000..241b91673 --- /dev/null +++ b/svx/source/sidebar/nbdtmg.cxx @@ -0,0 +1,905 @@ +/* -*- 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 <svx/nbdtmg.hxx> +#include <svx/svxids.hrc> +#include <vcl/svapp.hxx> +#include <svl/itemset.hxx> +#include <sfx2/request.hxx> +#include <svl/stritem.hxx> +#include <svtools/ctrltool.hxx> +#include <sfx2/objsh.hxx> +#include <editeng/flstitem.hxx> +#include <svl/itempool.hxx> +#include <vcl/outdev.hxx> +#include <editeng/brushitem.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <vcl/graph.hxx> +#include <vcl/settings.hxx> + +#include <i18nlangtag/languagetag.hxx> +#include <o3tl/temporary.hxx> +#include <tools/debug.hxx> +#include <tools/urlobj.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <unotools/pathoptions.hxx> +#include <editeng/eeitem.hxx> + +#include <com/sun/star/text/VertOrientation.hpp> +#include <com/sun/star/style/NumberingType.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/text/DefaultNumberingProvider.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <comphelper/processfactory.hxx> +#include <memory> + +using namespace com::sun::star; +using namespace com::sun::star::uno; +using namespace com::sun::star::beans; +using namespace com::sun::star::lang; +using namespace com::sun::star::text; +using namespace com::sun::star::container; +using namespace com::sun::star::style; + +namespace svx::sidebar { + +namespace { + +const vcl::Font& lcl_GetDefaultBulletFont() +{ + static vcl::Font aDefBulletFont = []() + { + static vcl::Font tmp("OpenSymbol", "", Size(0, 14)); + tmp.SetCharSet( RTL_TEXTENCODING_SYMBOL ); + tmp.SetFamily( FAMILY_DONTKNOW ); + tmp.SetPitch( PITCH_DONTKNOW ); + tmp.SetWeight( WEIGHT_DONTKNOW ); + tmp.SetTransparent( true ); + return tmp; + }(); + return aDefBulletFont; +} + +const sal_Unicode aDefaultBulletTypes[] = +{ + 0x2022, + 0x25cf, + 0xe00c, + 0xe00a, + 0x2794, + 0x27a2, + 0x2717, + 0x2714 +}; + +NumSettings_Impl* lcl_CreateNumberingSettingsPtr(const Sequence<PropertyValue>& rLevelProps) +{ + NumSettings_Impl* pNew = new NumSettings_Impl; + for(const PropertyValue& rValue : rLevelProps) + { + if(rValue.Name == "NumberingType") + { + sal_Int16 nTmp; + if (rValue.Value >>= nTmp) + pNew->nNumberType = static_cast<SvxNumType>(nTmp); + } + else if(rValue.Name == "Prefix") + rValue.Value >>= pNew->sPrefix; + else if(rValue.Name == "Suffix") + rValue.Value >>= pNew->sSuffix; + else if(rValue.Name == "ParentNumbering") + rValue.Value >>= pNew->nParentNumbering; + else if(rValue.Name == "BulletChar") + rValue.Value >>= pNew->sBulletChar; + else if(rValue.Name == "BulletFontName") + rValue.Value >>= pNew->sBulletFont; + } + const sal_Unicode cLocalPrefix = pNew->sPrefix.getLength() ? pNew->sPrefix[0] : 0; + const sal_Unicode cLocalSuffix = pNew->sSuffix.getLength() ? pNew->sSuffix[0] : 0; + if( cLocalPrefix == ' ') pNew->sPrefix.clear(); + if( cLocalSuffix == ' ') pNew->sSuffix.clear(); + return pNew; +} + +} + +sal_uInt16 NBOTypeMgrBase:: IsSingleLevel(sal_uInt16 nCurLevel) +{ + sal_uInt16 nLv = sal_uInt16(0xFFFF); + sal_uInt16 nCount = 0; + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < SVX_MAX_NUM; i++ ) + { + if(nCurLevel & nMask) + { + nCount++; + nLv=i; + } + nMask <<= 1 ; + } + + if ( nCount == 1) + return nLv; + else + return sal_uInt16(0xFFFF); +} + +void NBOTypeMgrBase::SetItems(const SfxItemSet* pArg) { + pSet = pArg; + if ( !pSet ) + return; + + SfxAllItemSet aSet(*pSet); + + const SfxStringItem* pBulletCharFmt = aSet.GetItem<SfxStringItem>(SID_BULLET_CHAR_FMT, false); + if (pBulletCharFmt) + aBulletCharFmtName = pBulletCharFmt->GetValue(); + + const SfxStringItem* pNumCharFmt = aSet.GetItem<SfxStringItem>(SID_NUM_CHAR_FMT, false); + if (pNumCharFmt) + aNumCharFmtName = pNumCharFmt->GetValue(); + + const SfxPoolItem* pItem; + SfxItemState eState = pSet->GetItemState(SID_ATTR_NUMBERING_RULE, false, &pItem); + if(eState == SfxItemState::SET) + { + eCoreUnit = pSet->GetPool()->GetMetric(pSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE)); + } else { + //sd use different sid for numbering rule + eState = pSet->GetItemState(EE_PARA_NUMBULLET, false, &pItem); + if(eState == SfxItemState::SET) + { + eCoreUnit = pSet->GetPool()->GetMetric(pSet->GetPool()->GetWhich(EE_PARA_NUMBULLET)); + } + } +} + +void NBOTypeMgrBase::ImplLoad(std::u16string_view filename) +{ + bIsLoading = true; + MapUnit eOldCoreUnit=eCoreUnit; + eCoreUnit = MapUnit::Map100thMM; + INetURLObject aFile( SvtPathOptions().GetUserConfigPath() ); + aFile.Append( filename); + std::unique_ptr<SvStream> xIStm(::utl::UcbStreamHelper::CreateStream( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ )); + if( xIStm ) { + sal_uInt32 nVersion = 0; + sal_Int32 nNumIndex = 0; + xIStm->ReadUInt32( nVersion ); + if (nVersion==DEFAULT_NUMBERING_CACHE_FORMAT_VERSION) //first version + { + xIStm->ReadInt32( nNumIndex ); + while (nNumIndex>=0 && nNumIndex<DEFAULT_NUM_VALUSET_COUNT) { + SvxNumRule aNum(*xIStm); + //bullet color in font properties is not stored correctly. Need set transparency bits manually + for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++) + { + SvxNumberFormat aFmt(aNum.GetLevel(i)); + if (aFmt.GetBulletFont()) { + vcl::Font aFont(*aFmt.GetBulletFont()); + Color c=aFont.GetColor(); + c.SetAlpha(0); + aFont.SetColor(c); + aFmt.SetBulletFont(&aFont); + aNum.SetLevel(i, aFmt); + } + } + RelplaceNumRule(aNum,nNumIndex,0x1/*nLevel*/); + xIStm->ReadInt32( nNumIndex ); + } + } + } + eCoreUnit = eOldCoreUnit; + bIsLoading = false; +} +void NBOTypeMgrBase::ImplStore(std::u16string_view filename) +{ + if (bIsLoading) return; + MapUnit eOldCoreUnit=eCoreUnit; + eCoreUnit = MapUnit::Map100thMM; + INetURLObject aFile( SvtPathOptions().GetUserConfigPath() ); + aFile.Append( filename); + std::unique_ptr<SvStream> xOStm(::utl::UcbStreamHelper::CreateStream( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::WRITE )); + if( xOStm ) { + sal_uInt32 nVersion; + sal_Int32 nNumIndex; + nVersion = DEFAULT_NUMBERING_CACHE_FORMAT_VERSION; + xOStm->WriteUInt32( nVersion ); + for(sal_Int32 nItem = 0; nItem < DEFAULT_NUM_VALUSET_COUNT; nItem++ ) { + if (IsCustomized(nItem)) { + SvxNumRule aDefNumRule( SvxNumRuleFlags::BULLET_REL_SIZE | SvxNumRuleFlags::CONTINUOUS | SvxNumRuleFlags::BULLET_COLOR, + 10, false, + SvxNumRuleType::NUMBERING, SvxNumberFormat::LABEL_ALIGNMENT); + xOStm->WriteInt32( nItem ); + ApplyNumRule(aDefNumRule,nItem,0x1/*nLevel*/,false,true); + aDefNumRule.Store(*xOStm); + } + } + nNumIndex = -1; + xOStm->WriteInt32( nNumIndex ); //write end flag + } + eCoreUnit = eOldCoreUnit; +} + +// Character Bullet Type lib +BulletsSettings* BulletsTypeMgr::pActualBullets[] ={nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr}; +sal_Unicode BulletsTypeMgr::aDynamicBulletTypes[]={' ',' ',' ',' ',' ',' ',' ',' '}; +sal_Unicode BulletsTypeMgr::aDynamicRTLBulletTypes[]={' ',' ',' ',' ',' ',' ',' ',' '}; + +BulletsTypeMgr::BulletsTypeMgr() +{ + Init(); +} + +BulletsTypeMgr& BulletsTypeMgr::GetInstance() +{ + static BulletsTypeMgr theBulletsTypeMgr; + return theBulletsTypeMgr; +} + +void BulletsTypeMgr::Init() +{ + const vcl::Font& rActBulletFont = lcl_GetDefaultBulletFont(); + + for (sal_uInt16 i=0;i<DEFAULT_BULLET_TYPES;i++) + { + pActualBullets[i] = new BulletsSettings; + pActualBullets[i]->cBulletChar = aDefaultBulletTypes[i]; + pActualBullets[i]->aFont = rActBulletFont; + OString id = OString::Concat(RID_SVXSTR_BULLET_DESCRIPTION_0.mpId) + OString::number(i); + pActualBullets[i]->sDescription = SvxResId( TranslateId(RID_SVXSTR_BULLET_DESCRIPTION_0.mpContext, id.getStr()) ); + } +} +sal_uInt16 BulletsTypeMgr::GetNBOIndexForNumRule(SvxNumRule& aNum,sal_uInt16 mLevel,sal_uInt16 nFromIndex) +{ + if ( mLevel == sal_uInt16(0xFFFF) || mLevel == 0) + return sal_uInt16(0xFFFF); + //if ( !lcl_IsNumFmtSet(pNR, mLevel) ) return (sal_uInt16)0xFFFF; + + sal_uInt16 nActLv = IsSingleLevel(mLevel); + + if ( nActLv == sal_uInt16(0xFFFF) ) + return sal_uInt16(0xFFFF); + + const SvxNumberFormat& aFmt(aNum.GetLevel(nActLv)); + sal_UCS4 cChar = aFmt.GetBulletChar(); + for(sal_uInt16 i = nFromIndex; i < DEFAULT_BULLET_TYPES; i++) + { + if ( (cChar == pActualBullets[i]->cBulletChar) || + (cChar == 9830 && 57356 == pActualBullets[i]->cBulletChar) || + (cChar == 9632 && 57354 == pActualBullets[i]->cBulletChar) ) + { + return i+1; + } + } + + return sal_uInt16(0xFFFF); +} + +void BulletsTypeMgr::RelplaceNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel) +{ + if ( mLevel == sal_uInt16(0xFFFF) || mLevel == 0) + return; + + if ( GetNBOIndexForNumRule(aNum,mLevel) != sal_uInt16(0xFFFF) ) + return; + + sal_uInt16 nActLv = IsSingleLevel(mLevel); + + if ( nActLv == sal_uInt16(0xFFFF) ) + return; + + SvxNumberFormat aFmt(aNum.GetLevel(nActLv)); + sal_UCS4 cChar = aFmt.GetBulletChar(); + std::optional<vcl::Font> pFont = aFmt.GetBulletFont(); + if ( nIndex >= DEFAULT_BULLET_TYPES ) + return; + + pActualBullets[nIndex]->cBulletChar = cChar; + if ( pFont ) + pActualBullets[nIndex]->aFont = *pFont; + pActualBullets[nIndex]->bIsCustomized = true; +} + +void BulletsTypeMgr::ApplyNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel, bool /*isDefault*/, bool isResetSize) +{ + if ( nIndex >= DEFAULT_BULLET_TYPES ) + return; + sal_UCS4 cChar = pActualBullets[nIndex]->cBulletChar; + const vcl::Font& rActBulletFont = pActualBullets[nIndex]->aFont; + + sal_uInt16 nMask = 1; + OUString sBulletCharFormatName = GetBulletCharFmtName(); + for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++) + { + if(mLevel & nMask) + { + SvxNumberFormat aFmt(aNum.GetLevel(i)); + aFmt.SetNumberingType( SVX_NUM_CHAR_SPECIAL ); + aFmt.SetBulletFont(&rActBulletFont); + aFmt.SetBulletChar(cChar); + aFmt.SetCharFormatName(sBulletCharFormatName); + aFmt.SetListFormat( "" ); + if (isResetSize) aFmt.SetBulletRelSize(45); + aNum.SetLevel(i, aFmt); + } + nMask <<= 1; + } +} + +OUString BulletsTypeMgr::GetDescription(sal_uInt16 nIndex, bool /*isDefault*/) +{ + OUString sRet; + + if ( nIndex >= DEFAULT_BULLET_TYPES ) + return sRet; + else + sRet = pActualBullets[nIndex]->sDescription; + + return sRet; +} + +bool BulletsTypeMgr::IsCustomized(sal_uInt16 nIndex) +{ + bool bRet = false; + + if ( nIndex >= DEFAULT_BULLET_TYPES ) + bRet = false; + else + bRet = pActualBullets[nIndex]->bIsCustomized; + + return bRet; +} + +// Numbering Type lib +NumberingTypeMgr::NumberingTypeMgr() +{ + Init(); + maDefaultNumberSettingsArr = maNumberSettingsArr; + ImplLoad(u"standard.syb"); +} + +NumberingTypeMgr::~NumberingTypeMgr() +{ +} + +const TranslateId RID_SVXSTR_SINGLENUM_DESCRIPTIONS[] = +{ + RID_SVXSTR_SINGLENUM_DESCRIPTION_0, + RID_SVXSTR_SINGLENUM_DESCRIPTION_1, + RID_SVXSTR_SINGLENUM_DESCRIPTION_2, + RID_SVXSTR_SINGLENUM_DESCRIPTION_3, + RID_SVXSTR_SINGLENUM_DESCRIPTION_4, + RID_SVXSTR_SINGLENUM_DESCRIPTION_5, + RID_SVXSTR_SINGLENUM_DESCRIPTION_6, + RID_SVXSTR_SINGLENUM_DESCRIPTION_7 +}; + +NumberingTypeMgr& NumberingTypeMgr::GetInstance() +{ + static NumberingTypeMgr theNumberingTypeMgr; + return theNumberingTypeMgr; +} + +void NumberingTypeMgr::Init() +{ + Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + Reference<XDefaultNumberingProvider> xDefNum = DefaultNumberingProvider::create( xContext ); + + Sequence< Sequence< PropertyValue > > aNumberings; + Locale aLocale(Application::GetSettings().GetLanguageTag().getLocale()); + try + { + aNumberings = xDefNum->getDefaultContinuousNumberingLevels( aLocale ); + + sal_Int32 nLength = aNumberings.getLength(); + + const Sequence<PropertyValue>* pValuesArr = aNumberings.getConstArray(); + for(sal_Int32 i = 0; i < nLength; i++) + { + NumSettings_Impl* pNew = lcl_CreateNumberingSettingsPtr(pValuesArr[i]); + std::shared_ptr<NumberSettings_Impl> pNumEntry = std::make_shared<NumberSettings_Impl>(); + pNumEntry->pNumSetting = pNew; + if ( i < 8 ) + pNumEntry->sDescription = SvxResId(RID_SVXSTR_SINGLENUM_DESCRIPTIONS[i]); + maNumberSettingsArr.push_back(pNumEntry); + } + } + catch(Exception&) + { + } +} + +sal_uInt16 NumberingTypeMgr::GetNBOIndexForNumRule(SvxNumRule& aNum,sal_uInt16 mLevel,sal_uInt16 nFromIndex) +{ + if ( mLevel == sal_uInt16(0xFFFF) || mLevel > aNum.GetLevelCount() || mLevel == 0) + return sal_uInt16(0xFFFF); + + sal_uInt16 nActLv = IsSingleLevel(mLevel); + + if ( nActLv == sal_uInt16(0xFFFF) ) + return sal_uInt16(0xFFFF); + + const SvxNumberFormat& aFmt(aNum.GetLevel(nActLv)); + //sal_Unicode cPrefix = OUString(aFmt.GetPrefix())[0]; + //sal_Unicode cSuffix = :OUString(aFmt.GetSuffix())[0]; + const OUString& sPrefix = aFmt.GetPrefix(); + const OUString& sLclSuffix = aFmt.GetSuffix(); + sal_Int16 eNumType = aFmt.GetNumberingType(); + + sal_uInt16 nCount = maNumberSettingsArr.size(); + for(sal_uInt16 i = nFromIndex; i < nCount; ++i) + { + NumberSettings_Impl* _pSet = maNumberSettingsArr[i].get(); + sal_Int16 eNType = _pSet->pNumSetting->nNumberType; + OUString sLocalPrefix = _pSet->pNumSetting->sPrefix; + OUString sLocalSuffix = _pSet->pNumSetting->sSuffix; + if (sPrefix == sLocalPrefix && + sLclSuffix == sLocalSuffix && + eNumType == eNType ) + { + return i+1; + } + } + + + return sal_uInt16(0xFFFF); +} + +void NumberingTypeMgr::RelplaceNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel) +{ + sal_uInt16 nActLv = IsSingleLevel(mLevel); + + if ( nActLv == sal_uInt16(0xFFFF) ) + return; + + const SvxNumberFormat& aFmt(aNum.GetLevel(nActLv)); + SvxNumType eNumType = aFmt.GetNumberingType(); + + sal_uInt16 nCount = maNumberSettingsArr.size(); + if ( nIndex >= nCount ) + return; + + NumberSettings_Impl* _pSet = maNumberSettingsArr[nIndex].get(); + + _pSet->pNumSetting->sPrefix = aFmt.GetPrefix(); + _pSet->pNumSetting->sSuffix = aFmt.GetSuffix(); + _pSet->pNumSetting->nNumberType = eNumType; + _pSet->bIsCustomized = true; + + SvxNumRule aTmpRule1(aNum); + SvxNumRule aTmpRule2(aNum); + ApplyNumRule(aTmpRule1,nIndex,mLevel,true); + ApplyNumRule(aTmpRule2,nIndex,mLevel); + if (aTmpRule1==aTmpRule2) _pSet->bIsCustomized=false; + if (!_pSet->bIsCustomized) { + _pSet->sDescription = GetDescription(nIndex,true); + } + ImplStore(u"standard.syb"); +} + +void NumberingTypeMgr::ApplyNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel, bool isDefault, bool isResetSize) +{ + if(maNumberSettingsArr.size() <= nIndex) + return; + NumberSettingsArr_Impl* pCurrentNumberSettingsArr = &maNumberSettingsArr; + if (isDefault) pCurrentNumberSettingsArr = &maDefaultNumberSettingsArr; + NumberSettings_Impl* _pSet = (*pCurrentNumberSettingsArr)[nIndex].get(); + SvxNumType eNewType = _pSet->pNumSetting->nNumberType; + + sal_uInt16 nMask = 1; + OUString sNumCharFmtName = GetNumCharFmtName(); + for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++) + { + if(mLevel & nMask) + { + SvxNumberFormat aFmt(aNum.GetLevel(i)); + if (eNewType!=aFmt.GetNumberingType()) isResetSize=true; + aFmt.SetNumberingType(eNewType); + aFmt.SetListFormat(_pSet->pNumSetting->sPrefix, _pSet->pNumSetting->sSuffix, i); + aFmt.SetCharFormatName(sNumCharFmtName); + if (isResetSize) aFmt.SetBulletRelSize(100); + aNum.SetLevel(i, aFmt); + } + nMask <<= 1 ; + } +} + +OUString NumberingTypeMgr::GetDescription(sal_uInt16 nIndex, bool isDefault) +{ + OUString sRet; + sal_uInt16 nLength = maNumberSettingsArr.size(); + + if ( nIndex >= nLength ) + return sRet; + else + sRet = maNumberSettingsArr[nIndex]->sDescription; + if (isDefault) sRet = maDefaultNumberSettingsArr[nIndex]->sDescription; + + return sRet; +} + +bool NumberingTypeMgr::IsCustomized(sal_uInt16 nIndex) +{ + bool bRet = false; + sal_uInt16 nLength = maNumberSettingsArr.size(); + + if ( nIndex >= nLength ) + bRet = false; + else + bRet = maNumberSettingsArr[nIndex]->bIsCustomized; + + return bRet; +} +// Multi-level /Outline Type lib +OutlineTypeMgr::OutlineTypeMgr() +{ + Init(); + for(sal_Int32 nItem = 0; nItem < DEFAULT_NUM_VALUSET_COUNT; nItem++ ) + { + pDefaultOutlineSettingsArrs[nItem] = pOutlineSettingsArrs[nItem]; + } + //Initial the first time to store the default value. Then do it again for customized value + Init(); + ImplLoad(u"standard.syc"); +} + +OutlineTypeMgr& OutlineTypeMgr::GetInstance() +{ + static OutlineTypeMgr theOutlineTypeMgr; + return theOutlineTypeMgr; +} + +void OutlineTypeMgr::Init() +{ + Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + Reference<XDefaultNumberingProvider> xDefNum = DefaultNumberingProvider::create( xContext ); + + Sequence<Reference<XIndexAccess> > aOutlineAccess; + Locale aLocale(Application::GetSettings().GetLanguageTag().getLocale()); + try + { + aOutlineAccess = xDefNum->getDefaultOutlineNumberings( aLocale ); + + SvxNumRule aDefNumRule( SvxNumRuleFlags::BULLET_REL_SIZE | SvxNumRuleFlags::CONTINUOUS | SvxNumRuleFlags::BULLET_COLOR, + 10, false, + SvxNumRuleType::NUMBERING, SvxNumberFormat::LABEL_ALIGNMENT); + + auto nSize = std::min<sal_Int32>(aOutlineAccess.getLength(), DEFAULT_NUM_VALUSET_COUNT); + for(sal_Int32 nItem = 0; nItem < nSize; nItem++ ) + { + pOutlineSettingsArrs[ nItem ] = new OutlineSettings_Impl; + OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[ nItem ]; + OString id = OString::Concat(RID_SVXSTR_OUTLINENUM_DESCRIPTION_0.mpId) + OString::number(nItem); + pItemArr->sDescription = SvxResId( TranslateId(RID_SVXSTR_OUTLINENUM_DESCRIPTION_0.mpContext, id.getStr()) ); + pItemArr->pNumSettingsArr = new NumSettingsArr_Impl; + Reference<XIndexAccess> xLevel = aOutlineAccess.getConstArray()[nItem]; + for(sal_Int32 nLevel = 0; nLevel < xLevel->getCount() && nLevel < 5; nLevel++) + { + Any aValueAny = xLevel->getByIndex(nLevel); + Sequence<PropertyValue> aLevelProps; + aValueAny >>= aLevelProps; + NumSettings_Impl* pNew = lcl_CreateNumberingSettingsPtr(aLevelProps); + const SvxNumberFormat& aNumFmt( aDefNumRule.GetLevel( nLevel) ); + pNew->eLabelFollowedBy = aNumFmt.GetLabelFollowedBy(); + pNew->nTabValue = aNumFmt.GetListtabPos(); + pNew->eNumAlign = aNumFmt.GetNumAdjust(); + pNew->nNumAlignAt = aNumFmt.GetFirstLineIndent(); + pNew->nNumIndentAt = aNumFmt.GetIndentAt(); + pItemArr->pNumSettingsArr->push_back(std::shared_ptr<NumSettings_Impl>(pNew)); + } + } + } + catch(Exception&) + { + } +} + +sal_uInt16 OutlineTypeMgr::GetNBOIndexForNumRule(SvxNumRule& aNum,sal_uInt16 /*mLevel*/,sal_uInt16 nFromIndex) +{ + sal_uInt16 const nLength = SAL_N_ELEMENTS(pOutlineSettingsArrs); + for(sal_uInt16 iDex = nFromIndex; iDex < nLength; iDex++) + { + bool bNotMatch = false; + OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[iDex]; + sal_uInt16 nCount = pItemArr->pNumSettingsArr->size(); + for (sal_uInt16 iLevel=0;iLevel < nCount;iLevel++) + { + NumSettings_Impl* _pSet = (*pItemArr->pNumSettingsArr)[iLevel].get(); + sal_Int16 eNType = _pSet->nNumberType; + + const SvxNumberFormat& aFmt(aNum.GetLevel(iLevel)); + const OUString& sPrefix = aFmt.GetPrefix(); + const OUString& sLclSuffix = aFmt.GetSuffix(); + sal_Int16 eNumType = aFmt.GetNumberingType(); + if( eNumType == SVX_NUM_CHAR_SPECIAL) + { + sal_UCS4 cChar = aFmt.GetBulletChar(); + + sal_UCS4 ccChar + = _pSet->sBulletChar.iterateCodePoints(&o3tl::temporary(sal_Int32(0))); + + if ( !((cChar == ccChar) && + _pSet->eLabelFollowedBy == aFmt.GetLabelFollowedBy() && + _pSet->nTabValue == aFmt.GetListtabPos() && + _pSet->eNumAlign == aFmt.GetNumAdjust() && + _pSet->nNumAlignAt == aFmt.GetFirstLineIndent() && + _pSet->nNumIndentAt == aFmt.GetIndentAt())) + { + bNotMatch = true; + break; + } + } + else if ((eNumType&(~LINK_TOKEN)) == SVX_NUM_BITMAP ) + { + const SvxBrushItem* pBrsh1 = aFmt.GetBrush(); + const SvxBrushItem* pBrsh2 = _pSet->pBrushItem; + bool bIsMatch = false; + if (pBrsh1==pBrsh2) bIsMatch = true; + if (pBrsh1 && pBrsh2) { + const Graphic* pGrf1 = pBrsh1->GetGraphic(); + const Graphic* pGrf2 = pBrsh2->GetGraphic(); + if (pGrf1==pGrf2) bIsMatch = true; + if (pGrf1 && pGrf2) { + if ( pGrf1->GetBitmapEx() == pGrf2->GetBitmapEx() && + _pSet->aSize == aFmt.GetGraphicSize()) + bIsMatch = true; + } + } + if (!bIsMatch) { + bNotMatch = true; + break; + } + } + else + { + if (!(sPrefix == _pSet->sPrefix && + sLclSuffix == _pSet->sSuffix && + eNumType == eNType && + _pSet->eLabelFollowedBy == aFmt.GetLabelFollowedBy() && + _pSet->nTabValue == aFmt.GetListtabPos() && + _pSet->eNumAlign == aFmt.GetNumAdjust() && + _pSet->nNumAlignAt == aFmt.GetFirstLineIndent() && + _pSet->nNumIndentAt == aFmt.GetIndentAt())) + { + bNotMatch = true; + break; + } + } + } + if ( !bNotMatch ) + return iDex+1; + } + + + return sal_uInt16(0xFFFF); +} + +void OutlineTypeMgr::RelplaceNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel) +{ + sal_uInt16 const nLength = SAL_N_ELEMENTS(pOutlineSettingsArrs); + if ( nIndex >= nLength ) + return; + + OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex]; + sal_uInt16 nCount = pItemArr->pNumSettingsArr->size(); + for (sal_uInt16 iLevel=0;iLevel < nCount;iLevel++) + { + const SvxNumberFormat& aFmt(aNum.GetLevel(iLevel)); + SvxNumType eNumType = aFmt.GetNumberingType(); + + NumSettings_Impl* _pSet = (*pItemArr->pNumSettingsArr)[iLevel].get(); + + _pSet->eLabelFollowedBy = aFmt.GetLabelFollowedBy(); + _pSet->nTabValue = aFmt.GetListtabPos(); + _pSet->eNumAlign = aFmt.GetNumAdjust(); + _pSet->nNumAlignAt = aFmt.GetFirstLineIndent(); + _pSet->nNumIndentAt = aFmt.GetIndentAt(); + + if( eNumType == SVX_NUM_CHAR_SPECIAL) + { + sal_UCS4 cChar = aFmt.GetBulletChar(); + OUString sChar(&cChar, 1); + _pSet->sBulletChar = sChar; + if ( aFmt.GetBulletFont() ) + _pSet->sBulletFont = aFmt.GetBulletFont()->GetFamilyName(); + _pSet->nNumberType = eNumType; + pItemArr->bIsCustomized = true; + }else if ((eNumType&(~LINK_TOKEN)) == SVX_NUM_BITMAP ) { + if (_pSet->pBrushItem) { + delete _pSet->pBrushItem; + _pSet->pBrushItem=nullptr; + } + if (aFmt.GetBrush()) + _pSet->pBrushItem = new SvxBrushItem(*aFmt.GetBrush()); + _pSet->aSize = aFmt.GetGraphicSize(); + _pSet->nNumberType = eNumType; + } else + { + _pSet->sPrefix = aFmt.GetPrefix(); + _pSet->sSuffix = aFmt.GetSuffix(); + _pSet->nNumberType = eNumType; + if ( aFmt.GetBulletFont() ) + _pSet->sBulletFont = aFmt.GetBulletFont()->GetFamilyName(); + pItemArr->bIsCustomized = true; + } + } + SvxNumRule aTmpRule1(aNum); + SvxNumRule aTmpRule2(aNum); + ApplyNumRule(aTmpRule1,nIndex,mLevel,true); + ApplyNumRule(aTmpRule2,nIndex,mLevel); + if (aTmpRule1==aTmpRule2) pItemArr->bIsCustomized=false; + if (!pItemArr->bIsCustomized) { + pItemArr->sDescription = GetDescription(nIndex,true); + } + ImplStore(u"standard.syc"); +} + +void OutlineTypeMgr::ApplyNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 /*mLevel*/, bool isDefault, bool isResetSize) +{ + DBG_ASSERT(DEFAULT_NUM_VALUSET_COUNT > nIndex, "wrong index"); + if(DEFAULT_NUM_VALUSET_COUNT <= nIndex) + return; + + const FontList* pList = nullptr; + + OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex]; + if (isDefault) pItemArr=pDefaultOutlineSettingsArrs[nIndex]; + + NumSettingsArr_Impl *pNumSettingsArr=pItemArr->pNumSettingsArr; + + NumSettings_Impl* pLevelSettings = nullptr; + for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++) + { + if(pNumSettingsArr->size() > i) + pLevelSettings = (*pNumSettingsArr)[i].get(); + + if(!pLevelSettings) + break; + + SvxNumberFormat aFmt(aNum.GetLevel(i)); + const vcl::Font& rActBulletFont = lcl_GetDefaultBulletFont(); + if (pLevelSettings->nNumberType !=aFmt.GetNumberingType()) isResetSize=true; + aFmt.SetNumberingType( pLevelSettings->nNumberType ); + sal_uInt16 nUpperLevelOrChar = static_cast<sal_uInt16>(pLevelSettings->nParentNumbering); + if(aFmt.GetNumberingType() == SVX_NUM_CHAR_SPECIAL) + { + if( pLevelSettings->sBulletFont.getLength() && + pLevelSettings->sBulletFont != rActBulletFont.GetFamilyName() ) + { + //search for the font + if(!pList) + { + if (SfxObjectShell* pCurDocShell = SfxObjectShell::Current()) + { + const SvxFontListItem* pFontListItem = static_cast<const SvxFontListItem*>(pCurDocShell->GetItem(SID_ATTR_CHAR_FONTLIST)); + pList = pFontListItem ? pFontListItem->GetFontList() : nullptr; + } + } + if(pList && pList->IsAvailable( pLevelSettings->sBulletFont ) ) + { + FontMetric aFontMetric = pList->Get(pLevelSettings->sBulletFont,WEIGHT_NORMAL, ITALIC_NONE); + vcl::Font aFont(aFontMetric); + aFmt.SetBulletFont(&aFont); + } + else + { + //if it cannot be found then create a new one + vcl::Font aCreateFont( pLevelSettings->sBulletFont, OUString(), Size( 0, 14 ) ); + aCreateFont.SetCharSet( RTL_TEXTENCODING_DONTKNOW ); + aCreateFont.SetFamily( FAMILY_DONTKNOW ); + aCreateFont.SetPitch( PITCH_DONTKNOW ); + aCreateFont.SetWeight( WEIGHT_DONTKNOW ); + aCreateFont.SetTransparent( true ); + aFmt.SetBulletFont( &aCreateFont ); + } + }else + aFmt.SetBulletFont( &rActBulletFont ); + + sal_UCS4 cChar = 0; + if( !pLevelSettings->sBulletChar.isEmpty() ) + { + cChar + = pLevelSettings->sBulletChar.iterateCodePoints(&o3tl::temporary(sal_Int32(0))); + } + if( AllSettings::GetLayoutRTL() ) + { + if( 0 == i && cChar == BulletsTypeMgr::aDynamicBulletTypes[5] ) + cChar = BulletsTypeMgr::aDynamicRTLBulletTypes[5]; + else if( 1 == i ) + { + const SvxNumberFormat& numberFmt = aNum.GetLevel(0); + if( numberFmt.GetBulletChar() == BulletsTypeMgr::aDynamicRTLBulletTypes[5] ) + cChar = BulletsTypeMgr::aDynamicRTLBulletTypes[4]; + } + } + + aFmt.SetBulletChar(cChar); + aFmt.SetCharFormatName( GetBulletCharFmtName() ); + if (isResetSize) aFmt.SetBulletRelSize(45); + }else if ((aFmt.GetNumberingType()&(~LINK_TOKEN)) == SVX_NUM_BITMAP ) { + if (pLevelSettings->pBrushItem) { + const Graphic* pGrf = pLevelSettings->pBrushItem->GetGraphic(); + Size aSize = pLevelSettings->aSize; + sal_Int16 eOrient = text::VertOrientation::LINE_CENTER; + if (!isResetSize && aFmt.GetGraphicSize()!=Size(0,0)) + aSize = aFmt.GetGraphicSize(); + else if (aSize.IsEmpty() && pGrf) + aSize = SvxNumberFormat::GetGraphicSizeMM100( pGrf ); + aSize = OutputDevice::LogicToLogic(aSize, MapMode(MapUnit::Map100thMM), MapMode(GetMapUnit())); + aFmt.SetGraphicBrush( pLevelSettings->pBrushItem, &aSize, &eOrient ); + } + } else + { + aFmt.SetIncludeUpperLevels(sal::static_int_cast< sal_uInt8 >(0 != nUpperLevelOrChar ? aNum.GetLevelCount() : 1)); + aFmt.SetCharFormatName(GetNumCharFmtName()); + if (isResetSize) aFmt.SetBulletRelSize(100); + } + if(pNumSettingsArr->size() > i) { + aFmt.SetLabelFollowedBy(pLevelSettings->eLabelFollowedBy); + aFmt.SetListtabPos(pLevelSettings->nTabValue); + aFmt.SetNumAdjust(pLevelSettings->eNumAlign); + aFmt.SetFirstLineIndent(pLevelSettings->nNumAlignAt); + aFmt.SetIndentAt(pLevelSettings->nNumIndentAt); + } + aFmt.SetListFormat(pLevelSettings->sPrefix, pLevelSettings->sSuffix, i); + aNum.SetLevel(i, aFmt); + } +} + +OUString OutlineTypeMgr::GetDescription(sal_uInt16 nIndex, bool isDefault) +{ + OUString sRet; + + if ( nIndex >= SAL_N_ELEMENTS(pOutlineSettingsArrs) ) + return sRet; + else + { + OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex]; + if (isDefault) pItemArr = pDefaultOutlineSettingsArrs[nIndex]; + if ( pItemArr ) + { + sRet = pItemArr->sDescription; + } + } + return sRet; +} + +bool OutlineTypeMgr::IsCustomized(sal_uInt16 nIndex) +{ + bool bRet = false; + + if ( nIndex >= SAL_N_ELEMENTS(pOutlineSettingsArrs) ) + return bRet; + else + { + OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex]; + if ( pItemArr ) + { + bRet = pItemArr->bIsCustomized; + } + } + + return bRet; +} + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/nbdtmgfact.cxx b/svx/source/sidebar/nbdtmgfact.cxx new file mode 100644 index 000000000..14dcd64c4 --- /dev/null +++ b/svx/source/sidebar/nbdtmgfact.cxx @@ -0,0 +1,42 @@ +/* -*- 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 <svx/nbdtmgfact.hxx> + +namespace svx::sidebar::NBOutlineTypeMgrFact +{ +NBOTypeMgrBase* CreateInstance(const NBOType aType) +{ + if (aType == NBOType::Bullets) + { + return &BulletsTypeMgr::GetInstance(); + } + else if (aType == NBOType::Numbering) + { + return &NumberingTypeMgr::GetInstance(); + } + else if (aType == NBOType::Outline) + { + return &OutlineTypeMgr::GetInstance(); + } + return nullptr; +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaLineSpacingControl.cxx b/svx/source/sidebar/paragraph/ParaLineSpacingControl.cxx new file mode 100644 index 000000000..fee659817 --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaLineSpacingControl.cxx @@ -0,0 +1,439 @@ +/* -*- 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 "ParaLineSpacingControl.hxx" + +#include <editeng/editids.hrc> +#include <editeng/lspcitem.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/module.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/viewfrm.hxx> +#include <svtools/unitconv.hxx> + +#include <svl/intitem.hxx> +#include <svl/itempool.hxx> + +#include <ParaLineSpacingPopup.hxx> + +#define DEFAULT_LINE_SPACING 200 +#define FIX_DIST_DEF 283 +#define LINESPACE_1 100 +#define LINESPACE_15 150 +#define LINESPACE_2 200 +#define LINESPACE_115 115 + +// values of the mxLineDist listbox +#define LLINESPACE_1 0 +#define LLINESPACE_115 1 +#define LLINESPACE_15 2 +#define LLINESPACE_2 3 +#define LLINESPACE_PROP 4 +#define LLINESPACE_MIN 5 +#define LLINESPACE_DURCH 6 +#define LLINESPACE_FIX 7 + +#define MIN_FIXED_DISTANCE 28 + +using namespace svx; + +ParaLineSpacingControl::ParaLineSpacingControl(SvxLineSpacingToolBoxControl* pControl, weld::Widget* pParent) + : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/paralinespacingcontrol.ui", "ParaLineSpacingControl") + , mxControl(pControl) + , meLNSpaceUnit(MapUnit::Map100thMM) + , mxSpacing1Button(m_xBuilder->weld_button("spacing_1")) + , mxSpacing115Button(m_xBuilder->weld_button("spacing_115")) + , mxSpacing15Button(m_xBuilder->weld_button("spacing_15")) + , mxSpacing2Button(m_xBuilder->weld_button("spacing_2")) + , mxLineDist(m_xBuilder->weld_combo_box("line_dist")) + , mxLineDistLabel(m_xBuilder->weld_label("value_label")) + , mxLineDistAtPercentBox(m_xBuilder->weld_metric_spin_button("percent_box", FieldUnit::PERCENT)) + , mxLineDistAtMetricBox(m_xBuilder->weld_metric_spin_button("metric_box", FieldUnit::CM)) + , mpActLineDistFld(mxLineDistAtPercentBox.get()) +{ + Link<weld::Button&,void> aLink = LINK(this, ParaLineSpacingControl, PredefinedValuesHandler); + mxSpacing1Button->connect_clicked(aLink); + mxSpacing115Button->connect_clicked(aLink); + mxSpacing15Button->connect_clicked(aLink); + mxSpacing2Button->connect_clicked(aLink); + + Link<weld::ComboBox&,void> aLink3 = LINK( this, ParaLineSpacingControl, LineSPDistHdl_Impl ); + mxLineDist->connect_changed(aLink3); + SelectEntryPos(LLINESPACE_1); + + Link<weld::MetricSpinButton&,void> aLink2 = LINK( this, ParaLineSpacingControl, LineSPDistAtHdl_Impl ); + mxLineDistAtPercentBox->connect_value_changed( aLink2 ); + mxLineDistAtMetricBox->connect_value_changed( aLink2 ); + + FieldUnit eUnit = FieldUnit::INCH; + const SfxUInt16Item* pItem = nullptr; + SfxViewFrame* pCurrent = SfxViewFrame::Current(); + if (pCurrent && pCurrent->GetBindings().GetDispatcher()->QueryState(SID_ATTR_METRIC, pItem) >= SfxItemState::DEFAULT) + eUnit = static_cast<FieldUnit>(pItem->GetValue()); + else + eUnit = SfxModule::GetCurrentFieldUnit(); + + SetFieldUnit(*mxLineDistAtMetricBox, eUnit); + + Initialize(); +} + +void ParaLineSpacingControl::GrabFocus() +{ + switch (mxLineDist->get_active()) + { + case LLINESPACE_1: + mxSpacing1Button->grab_focus(); + break; + case LLINESPACE_115: + mxSpacing115Button->grab_focus(); + break; + case LLINESPACE_15: + mxSpacing15Button->grab_focus(); + break; + case LLINESPACE_2: + mxSpacing2Button->grab_focus(); + break; + default: + mxLineDist->grab_focus(); + break; + } +} + +ParaLineSpacingControl::~ParaLineSpacingControl() +{ +} + +void ParaLineSpacingControl::Initialize() +{ + const SvxLineSpacingItem* pItem(nullptr); + SfxViewFrame* pCurrent = SfxViewFrame::Current(); + const bool bItemStateSet(nullptr != pCurrent); + const SfxItemState eState(bItemStateSet + ? pCurrent->GetBindings().GetDispatcher()->QueryState(SID_ATTR_PARA_LINESPACE, pItem) + : SfxItemState::DEFAULT); + + mxLineDist->set_sensitive(true); + + if( bItemStateSet && (eState == SfxItemState::DEFAULT || eState == SfxItemState::SET) ) + { + const SvxLineSpacingItem* currSPItem = pItem; + MapUnit eUnit = pCurrent->GetPool().GetMetric(currSPItem->Which()); + meLNSpaceUnit = eUnit; + + switch( currSPItem->GetLineSpaceRule() ) + { + case SvxLineSpaceRule::Auto: + { + SvxInterLineSpaceRule eInter = currSPItem->GetInterLineSpaceRule(); + + switch( eInter ) + { + case SvxInterLineSpaceRule::Off: + SelectEntryPos(LLINESPACE_1); + break; + + case SvxInterLineSpaceRule::Prop: + { + if ( LINESPACE_1 == currSPItem->GetPropLineSpace() ) + { + SelectEntryPos(LLINESPACE_1); + } + else if ( LINESPACE_115 == currSPItem->GetPropLineSpace() ) + { + SelectEntryPos(LLINESPACE_115); + } + else if ( LINESPACE_15 == currSPItem->GetPropLineSpace() ) + { + SelectEntryPos(LLINESPACE_15); + } + else if ( LINESPACE_2 == currSPItem->GetPropLineSpace() ) + { + SelectEntryPos(LLINESPACE_2); + } + else + { + SelectEntryPos(LLINESPACE_PROP); + mxLineDistAtPercentBox->set_value(mxLineDistAtPercentBox->normalize(currSPItem->GetPropLineSpace()), FieldUnit::PERCENT); + } + } + break; + + case SvxInterLineSpaceRule::Fix: + { + SelectEntryPos(LLINESPACE_DURCH); + SetMetricValue(*mxLineDistAtMetricBox, currSPItem->GetInterLineSpace(), eUnit); + } + break; + default: + break; + } + } + break; + case SvxLineSpaceRule::Fix: + { + SelectEntryPos(LLINESPACE_FIX); + SetMetricValue(*mxLineDistAtMetricBox, currSPItem->GetLineHeight(), eUnit); + } + break; + + case SvxLineSpaceRule::Min: + { + SelectEntryPos(LLINESPACE_MIN); + SetMetricValue(*mxLineDistAtMetricBox, currSPItem->GetLineHeight(), eUnit); + } + break; + default: + break; + } + } + else if( bItemStateSet && eState == SfxItemState::DISABLED ) + { + mxLineDist->set_sensitive(false); + mxLineDistLabel->set_sensitive(false); + mpActLineDistFld->set_sensitive(false); + mpActLineDistFld->set_text(""); + + } + else // !bItemStateSet || eState == SfxItemState::DONTCARE || eState == SfxItemState::UNKNOWN + { + mxLineDistLabel->set_sensitive(false); + mpActLineDistFld->set_sensitive(false); + mpActLineDistFld->set_text(""); + mxLineDist->set_active(-1); + } + + mxLineDist->save_value(); +} + +void ParaLineSpacingControl::UpdateMetricFields() +{ + switch (mxLineDist->get_active()) + { + case LLINESPACE_1: + case LLINESPACE_115: + case LLINESPACE_15: + case LLINESPACE_2: + if (mpActLineDistFld == mxLineDistAtPercentBox.get()) + mxLineDistAtMetricBox->hide(); + else + mxLineDistAtPercentBox->hide(); + + mxLineDistLabel->set_sensitive(false); + mpActLineDistFld->show(); + mpActLineDistFld->set_sensitive(false); + mpActLineDistFld->set_text(""); + break; + + case LLINESPACE_DURCH: + mxLineDistAtPercentBox->hide(); + + mpActLineDistFld = mxLineDistAtMetricBox.get(); + mxLineDistAtMetricBox->set_min(0, FieldUnit::NONE); + + if (mxLineDistAtMetricBox->get_text().isEmpty()) + mxLineDistAtMetricBox->set_value(mxLineDistAtMetricBox->normalize(0), FieldUnit::NONE); + + mxLineDistLabel->set_sensitive(true); + mpActLineDistFld->show(); + mpActLineDistFld->set_sensitive(true); + break; + + case LLINESPACE_MIN: + mxLineDistAtPercentBox->hide(); + + mpActLineDistFld = mxLineDistAtMetricBox.get(); + mxLineDistAtMetricBox->set_min(0, FieldUnit::NONE); + + if (mxLineDistAtMetricBox->get_text().isEmpty()) + mxLineDistAtMetricBox->set_value(mxLineDistAtMetricBox->normalize(0), FieldUnit::TWIP); + + mxLineDistLabel->set_sensitive(true); + mpActLineDistFld->show(); + mpActLineDistFld->set_sensitive(true); + break; + + case LLINESPACE_PROP: + mxLineDistAtMetricBox->hide(); + + mpActLineDistFld = mxLineDistAtPercentBox.get(); + + if (mxLineDistAtPercentBox->get_text().isEmpty()) + mxLineDistAtPercentBox->set_value(mxLineDistAtPercentBox->normalize(100), FieldUnit::TWIP); + + mxLineDistLabel->set_sensitive(true); + mpActLineDistFld->show(); + mpActLineDistFld->set_sensitive(true); + break; + + case LLINESPACE_FIX: + mxLineDistAtPercentBox->hide(); + + mpActLineDistFld = mxLineDistAtMetricBox.get(); + sal_Int64 nTemp = mxLineDistAtMetricBox->get_value(FieldUnit::NONE); + mxLineDistAtMetricBox->set_min(mxLineDistAtMetricBox->normalize(MIN_FIXED_DISTANCE), FieldUnit::TWIP); + + if (mxLineDistAtMetricBox->get_value(FieldUnit::NONE) != nTemp) + SetMetricValue(*mxLineDistAtMetricBox, FIX_DIST_DEF, MapUnit::MapTwip); + + mxLineDistLabel->set_sensitive(true); + mpActLineDistFld->show(); + mpActLineDistFld->set_sensitive(true); + break; + } +} + +void ParaLineSpacingControl::SelectEntryPos(sal_Int32 nPos) +{ + mxLineDist->set_active(nPos); + UpdateMetricFields(); +} + +IMPL_LINK_NOARG(ParaLineSpacingControl, LineSPDistHdl_Impl, weld::ComboBox&, void) +{ + UpdateMetricFields(); + ExecuteLineSpace(); +} + +IMPL_LINK_NOARG( ParaLineSpacingControl, LineSPDistAtHdl_Impl, weld::MetricSpinButton&, void ) +{ + ExecuteLineSpace(); +} + +void ParaLineSpacingControl::ExecuteLineSpace() +{ + mxLineDist->save_value(); + + SvxLineSpacingItem aSpacing(DEFAULT_LINE_SPACING, SID_ATTR_PARA_LINESPACE); + const sal_Int32 nPos = mxLineDist->get_active(); + + switch ( nPos ) + { + case LLINESPACE_1: + case LLINESPACE_115: + case LLINESPACE_15: + case LLINESPACE_2: + SetLineSpace(aSpacing, nPos); + break; + + case LLINESPACE_PROP: + SetLineSpace(aSpacing, nPos, mxLineDistAtPercentBox->denormalize(static_cast<tools::Long>(mxLineDistAtPercentBox->get_value(FieldUnit::PERCENT)))); + break; + + case LLINESPACE_MIN: + case LLINESPACE_DURCH: + case LLINESPACE_FIX: + SetLineSpace(aSpacing, nPos, GetCoreValue(*mxLineDistAtMetricBox, meLNSpaceUnit)); + break; + + default: + break; + } + + if (SfxViewFrame* pViewFrm = SfxViewFrame::Current()) + { + pViewFrm->GetBindings().GetDispatcher()->ExecuteList( + SID_ATTR_PARA_LINESPACE, SfxCallMode::RECORD, { &aSpacing }); + } +} + +void ParaLineSpacingControl::SetLineSpace(SvxLineSpacingItem& rLineSpace, sal_Int32 eSpace, tools::Long lValue) +{ + switch ( eSpace ) + { + case LLINESPACE_1: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); + break; + + case LLINESPACE_115: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( LINESPACE_115 ); + break; + + case LLINESPACE_15: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( LINESPACE_15 ); + break; + + case LLINESPACE_2: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( LINESPACE_2 ); + break; + + case LLINESPACE_PROP: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( static_cast<sal_uInt16>(lValue) ); + break; + + case LLINESPACE_MIN: + rLineSpace.SetLineHeight( static_cast<sal_uInt16>(lValue) ); + rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); + break; + + case LLINESPACE_DURCH: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetInterLineSpace( static_cast<sal_uInt16>(lValue) ); + break; + + case LLINESPACE_FIX: + rLineSpace.SetLineHeight(static_cast<sal_uInt16>(lValue)); + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Fix ); + rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); + break; + } +} + +IMPL_LINK(ParaLineSpacingControl, PredefinedValuesHandler, weld::Button&, rControl, void) +{ + if (&rControl == mxSpacing1Button.get()) + { + ExecuteLineSpacing(LLINESPACE_1); + } + else if (&rControl == mxSpacing115Button.get()) + { + ExecuteLineSpacing(LLINESPACE_115); + } + else if (&rControl == mxSpacing15Button.get()) + { + ExecuteLineSpacing(LLINESPACE_15); + } + else if (&rControl == mxSpacing2Button.get()) + { + ExecuteLineSpacing(LLINESPACE_2); + } +} + +void ParaLineSpacingControl::ExecuteLineSpacing(sal_Int32 nEntry) +{ + SvxLineSpacingItem aSpacing(DEFAULT_LINE_SPACING, SID_ATTR_PARA_LINESPACE); + + SetLineSpace(aSpacing, nEntry); + + if (SfxViewFrame* pViewFrm = SfxViewFrame::Current()) + { + pViewFrm->GetBindings().GetDispatcher()->ExecuteList( + SID_ATTR_PARA_LINESPACE, SfxCallMode::RECORD, { &aSpacing }); + } + + // close when the user used the buttons + mxControl->EndPopupMode(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaLineSpacingControl.hxx b/svx/source/sidebar/paragraph/ParaLineSpacingControl.hxx new file mode 100644 index 000000000..e49556f16 --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaLineSpacingControl.hxx @@ -0,0 +1,80 @@ +/* -*- 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 . + */ +#pragma once + +#include <svtools/toolbarmenu.hxx> + +class SvxLineSpacingItem; + +namespace svx +{ +class SvxLineSpacingToolBoxControl; + +class ParaLineSpacingControl : public WeldToolbarPopup +{ +public: + explicit ParaLineSpacingControl(SvxLineSpacingToolBoxControl* pControl, weld::Widget* pParent); + virtual ~ParaLineSpacingControl() override; + + /// Setup the widgets with values from the document. + void Initialize(); + + virtual void GrabFocus() override; + +private: + rtl::Reference<SvxLineSpacingToolBoxControl> mxControl; + + MapUnit meLNSpaceUnit; + + std::unique_ptr<weld::Button> mxSpacing1Button; + std::unique_ptr<weld::Button> mxSpacing115Button; + std::unique_ptr<weld::Button> mxSpacing15Button; + std::unique_ptr<weld::Button> mxSpacing2Button; + + std::unique_ptr<weld::ComboBox> mxLineDist; + + std::unique_ptr<weld::Label> mxLineDistLabel; + std::unique_ptr<weld::MetricSpinButton> mxLineDistAtPercentBox; + std::unique_ptr<weld::MetricSpinButton> mxLineDistAtMetricBox; + weld::MetricSpinButton* mpActLineDistFld; + +private: + /// Take the values from the widgets, and update the paragraph accordingly. + void ExecuteLineSpace(); + + /// Set one particular value. + static void SetLineSpace(SvxLineSpacingItem& rLineSpace, sal_Int32 eSpace, + tools::Long lValue = 0); + + /// For the buttons - set the values, and close the popup. + void ExecuteLineSpacing(sal_Int32 aEntry); + + /// Set mpActlineDistFld and visibility of mpLineDist* fields according to what is just selected. + void UpdateMetricFields(); + + /// Set the entry and update the metric fields. + void SelectEntryPos(sal_Int32 nPos); + + DECL_LINK(LineSPDistHdl_Impl, weld::ComboBox&, void); + DECL_LINK(LineSPDistAtHdl_Impl, weld::MetricSpinButton&, void); + DECL_LINK(PredefinedValuesHandler, weld::Button&, void); +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaLineSpacingPopup.cxx b/svx/source/sidebar/paragraph/ParaLineSpacingPopup.cxx new file mode 100644 index 000000000..d8e427840 --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaLineSpacingPopup.cxx @@ -0,0 +1,99 @@ +/* -*- 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 "ParaLineSpacingControl.hxx" + +#include <ParaLineSpacingPopup.hxx> +#include <vcl/toolbox.hxx> + +using namespace svx; + +SvxLineSpacingToolBoxControl::SvxLineSpacingToolBoxControl( + const css::uno::Reference<css::uno::XComponentContext>& rContext) + : PopupWindowController(rContext, nullptr, OUString()) +{ +} + +SvxLineSpacingToolBoxControl::~SvxLineSpacingToolBoxControl() {} + +void SvxLineSpacingToolBoxControl::initialize(const css::uno::Sequence<css::uno::Any>& rArguments) +{ + PopupWindowController::initialize(rArguments); + + if (m_pToolbar) + { + mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar)); + m_pToolbar->set_item_popover(m_aCommandURL.toUtf8(), mxPopoverContainer->getTopLevel()); + } + + ToolBox* pToolBox = nullptr; + ToolBoxItemId nId; + if (getToolboxId(nId, &pToolBox)) + pToolBox->SetItemBits(nId, ToolBoxItemBits::DROPDOWNONLY | pToolBox->GetItemBits(nId)); +} + +void SAL_CALL SvxLineSpacingToolBoxControl::execute(sal_Int16 /*KeyModifier*/) +{ + if (m_pToolbar) + { + // Toggle the popup also when toolbutton is activated + const OString aId(m_aCommandURL.toUtf8()); + m_pToolbar->set_menu_item_active(aId, !m_pToolbar->get_menu_item_active(aId)); + } + else + { + // Open the popup also when Enter key is pressed. + createPopupWindow(); + } +} + +std::unique_ptr<WeldToolbarPopup> SvxLineSpacingToolBoxControl::weldPopupWindow() +{ + return std::make_unique<ParaLineSpacingControl>(this, m_pToolbar); +} + +VclPtr<vcl::Window> SvxLineSpacingToolBoxControl::createVclPopupWindow(vcl::Window* pParent) +{ + mxInterimPopover = VclPtr<InterimToolbarPopup>::Create( + getFrameInterface(), pParent, + std::make_unique<ParaLineSpacingControl>(this, pParent->GetFrameWeld())); + + mxInterimPopover->Show(); + + return mxInterimPopover; +} + +OUString SvxLineSpacingToolBoxControl::getImplementationName() +{ + return "com.sun.star.comp.svx.LineSpacingToolBoxControl"; +} + +css::uno::Sequence<OUString> SvxLineSpacingToolBoxControl::getSupportedServiceNames() +{ + return { "com.sun.star.frame.ToolbarController" }; +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +com_sun_star_comp_svx_LineSpacingToolBoxControl_get_implementation( + css::uno::XComponentContext* rContext, css::uno::Sequence<css::uno::Any> const&) +{ + return cppu::acquire(new SvxLineSpacingToolBoxControl(rContext)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaPropertyPanel.cxx b/svx/source/sidebar/paragraph/ParaPropertyPanel.cxx new file mode 100644 index 000000000..f4e2fd83b --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaPropertyPanel.cxx @@ -0,0 +1,491 @@ +/* -*- 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 "ParaPropertyPanel.hxx" +#include <sfx2/dispatch.hxx> +#include <sfx2/module.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/weldutils.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/ulspitem.hxx> +#include <svx/dlgctrl.hxx> +#include <svx/svxids.hrc> +#include <svl/intitem.hxx> +#include <sfx2/objsh.hxx> +#include <svtools/unitconv.hxx> +#include <sal/log.hxx> + +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +using namespace css; +using namespace css::uno; + +namespace svx::sidebar { +#define DEFAULT_VALUE 0 + +#define MAX_DURCH 31680 // tdf#68335: 1584 pt for UX interoperability with Word + +#define MAX_SW 1709400 +#define MAX_SC_SD 116220200 +#define NEGA_MAXVALUE -10000000 + +std::unique_ptr<PanelLayout> ParaPropertyPanel::Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to ParaPropertyPanel::Create", nullptr, 0); + if ( ! rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to ParaPropertyPanel::Create", nullptr, 1); + if (pBindings == nullptr) + throw lang::IllegalArgumentException("no SfxBindings given to ParaPropertyPanel::Create", nullptr, 2); + + return std::make_unique<ParaPropertyPanel>(pParent, rxFrame, pBindings, rxSidebar); +} + +void ParaPropertyPanel::HandleContextChange ( + const vcl::EnumContext& rContext) +{ + if (maContext == rContext) + { + // Nothing to do. + return; + } + + maContext = rContext; + switch (maContext.GetCombinedContext_DI()) + { + case CombinedEnumContext(Application::Calc, Context::DrawText): + case CombinedEnumContext(Application::WriterVariants, Context::DrawText): + mxTBxVertAlign->show(); + mxTBxBackColor->hide(); + mxTBxNumBullet->hide(); + ReSize(); + break; + + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::DrawImpress, Context::TextObject): + case CombinedEnumContext(Application::DrawImpress, Context::Graphic): + case CombinedEnumContext(Application::DrawImpress, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::Table): + mxTBxVertAlign->show(); + mxTBxBackColor->hide(); + mxTBxNumBullet->hide(); + ReSize(); + break; + + case CombinedEnumContext(Application::WriterVariants, Context::Default): + case CombinedEnumContext(Application::WriterVariants, Context::Text): + mxTBxVertAlign->hide(); + mxTBxBackColor->show(); + mxTBxNumBullet->show(); + ReSize(); + break; + + case CombinedEnumContext(Application::WriterVariants, Context::Table): + mxTBxVertAlign->show(); + mxTBxBackColor->show(); + mxTBxNumBullet->show(); + ReSize(); + break; + + case CombinedEnumContext(Application::WriterVariants, Context::Annotation): + mxTBxVertAlign->hide(); + mxTBxBackColor->hide(); + mxTBxNumBullet->hide(); + ReSize(); + break; + + case CombinedEnumContext(Application::Calc, Context::EditCell): + case CombinedEnumContext(Application::Calc, Context::Cell): + case CombinedEnumContext(Application::Calc, Context::Pivot): + case CombinedEnumContext(Application::Calc, Context::Sparkline): + case CombinedEnumContext(Application::DrawImpress, Context::Text): + case CombinedEnumContext(Application::DrawImpress, Context::OutlineText): + break; + + default: + break; + } +} + +void ParaPropertyPanel::ReSize() +{ + if (mxSidebar.is()) + mxSidebar->requestLayout(); +} + +void ParaPropertyPanel::InitToolBoxIndent() +{ + Link<weld::MetricSpinButton&,void> aLink = LINK( this, ParaPropertyPanel, ModifyIndentHdl_Impl ); + mxLeftIndent->connect_value_changed( aLink ); + mxRightIndent->connect_value_changed( aLink ); + mxFLineIndent->connect_value_changed( aLink ); + + m_eLRSpaceUnit = maLRSpaceControl.GetCoreMetric(); +} + +void ParaPropertyPanel::InitToolBoxSpacing() +{ + Link<weld::MetricSpinButton&,void> aLink = LINK( this, ParaPropertyPanel, ULSpaceHdl_Impl ); + mxTopDist->connect_value_changed(aLink); + mxBottomDist->connect_value_changed( aLink ); + + m_eULSpaceUnit = maULSpaceControl.GetCoreMetric(); +} + +void ParaPropertyPanel::initial() +{ + limitMetricWidths(); + + //toolbox + InitToolBoxIndent(); + InitToolBoxSpacing(); +} + +// for Paragraph Indent +IMPL_LINK_NOARG( ParaPropertyPanel, ModifyIndentHdl_Impl, weld::MetricSpinButton&, void) +{ + SvxLRSpaceItem aMargin( SID_ATTR_PARA_LRSPACE ); + aMargin.SetTextLeft(mxLeftIndent->GetCoreValue(m_eLRSpaceUnit)); + aMargin.SetRight(mxRightIndent->GetCoreValue(m_eLRSpaceUnit)); + aMargin.SetTextFirstLineOffset(static_cast<short>(mxFLineIndent->GetCoreValue(m_eLRSpaceUnit))); + + GetBindings()->GetDispatcher()->ExecuteList( + SID_ATTR_PARA_LRSPACE, SfxCallMode::RECORD, { &aMargin }); +} + + +// for Paragraph Spacing +IMPL_LINK_NOARG( ParaPropertyPanel, ULSpaceHdl_Impl, weld::MetricSpinButton&, void) +{ + SvxULSpaceItem aMargin( SID_ATTR_PARA_ULSPACE ); + aMargin.SetUpper( static_cast<sal_uInt16>(mxTopDist->GetCoreValue(m_eULSpaceUnit))); + aMargin.SetLower( static_cast<sal_uInt16>(mxBottomDist->GetCoreValue(m_eULSpaceUnit))); + + GetBindings()->GetDispatcher()->ExecuteList( + SID_ATTR_PARA_ULSPACE, SfxCallMode::RECORD, { &aMargin }); +} + +// for Paragraph State change +void ParaPropertyPanel::NotifyItemUpdate( + sal_uInt16 nSID, + SfxItemState eState, + const SfxPoolItem* pState) +{ + switch (nSID) + { + case SID_ATTR_METRIC: + { + m_eMetricUnit = GetCurrentUnit(eState,pState); + if( m_eMetricUnit!=m_last_eMetricUnit ) + { + mxLeftIndent->SetFieldUnit(m_eMetricUnit); + mxRightIndent->SetFieldUnit(m_eMetricUnit); + mxFLineIndent->SetFieldUnit(m_eMetricUnit); + mxTopDist->SetFieldUnit(m_eMetricUnit); + mxBottomDist->SetFieldUnit(m_eMetricUnit); + + limitMetricWidths(); + } + m_last_eMetricUnit = m_eMetricUnit; + } + break; + + case SID_ATTR_PARA_LRSPACE: + StateChangedIndentImpl( eState, pState ); + break; + + case SID_ATTR_PARA_ULSPACE: + StateChangedULImpl( eState, pState ); + break; + } +} + +void ParaPropertyPanel::StateChangedIndentImpl( SfxItemState eState, const SfxPoolItem* pState ) +{ + switch (maContext.GetCombinedContext_DI()) + { + + case CombinedEnumContext(Application::WriterVariants, Context::DrawText): + case CombinedEnumContext(Application::WriterVariants, Context::Annotation): + case CombinedEnumContext(Application::Calc, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::DrawImpress, Context::TextObject): + case CombinedEnumContext(Application::DrawImpress, Context::Graphic): + case CombinedEnumContext(Application::DrawImpress, Context::Table): + { + mxLeftIndent->set_min( DEFAULT_VALUE, FieldUnit::NONE ); + mxRightIndent->set_min( DEFAULT_VALUE, FieldUnit::NONE ); + mxFLineIndent->set_min( DEFAULT_VALUE, FieldUnit::NONE ); + } + break; + case CombinedEnumContext(Application::WriterVariants, Context::Default): + case CombinedEnumContext(Application::WriterVariants, Context::Text): + case CombinedEnumContext(Application::WriterVariants, Context::Table): + { + mxLeftIndent->set_min( NEGA_MAXVALUE, FieldUnit::MM_100TH ); + mxRightIndent->set_min( NEGA_MAXVALUE, FieldUnit::MM_100TH ); + mxFLineIndent->set_min( NEGA_MAXVALUE, FieldUnit::MM_100TH ); + } + break; + } + + bool bDisabled = eState == SfxItemState::DISABLED; + mxLeftIndent->set_sensitive(!bDisabled); + mxRightIndent->set_sensitive(!bDisabled); + mxFLineIndent->set_sensitive(!bDisabled); + + if (pState && eState >= SfxItemState::DEFAULT) + { + const SvxLRSpaceItem* pSpace = static_cast<const SvxLRSpaceItem*>(pState); + maTxtLeft = pSpace->GetTextLeft(); + maTxtLeft = OutputDevice::LogicToLogic(maTxtLeft, m_eLRSpaceUnit, MapUnit::MapTwip); + + tools::Long aTxtRight = pSpace->GetRight(); + aTxtRight = OutputDevice::LogicToLogic(aTxtRight, m_eLRSpaceUnit, MapUnit::MapTwip); + + tools::Long aTxtFirstLineOfst = pSpace->GetTextFirstLineOffset(); + aTxtFirstLineOfst = OutputDevice::LogicToLogic( aTxtFirstLineOfst, m_eLRSpaceUnit, MapUnit::MapTwip ); + + tools::Long nVal = o3tl::convert(maTxtLeft, o3tl::Length::twip, o3tl::Length::mm100); + nVal = static_cast<tools::Long>(mxLeftIndent->normalize( nVal )); + + if ( maContext.GetCombinedContext_DI() != CombinedEnumContext(Application::WriterVariants, Context::Text) + && maContext.GetCombinedContext_DI() != CombinedEnumContext(Application::WriterVariants, Context::Default) + && maContext.GetCombinedContext_DI() != CombinedEnumContext(Application::WriterVariants, Context::Table)) + { + mxFLineIndent->set_min( nVal*-1, FieldUnit::MM_100TH ); + } + + tools::Long nrVal = o3tl::convert(aTxtRight, o3tl::Length::twip, o3tl::Length::mm100); + nrVal = static_cast<tools::Long>(mxRightIndent->normalize( nrVal )); + + switch (maContext.GetCombinedContext_DI()) + { + case CombinedEnumContext(Application::WriterVariants, Context::DrawText): + case CombinedEnumContext(Application::WriterVariants, Context::Text): + case CombinedEnumContext(Application::WriterVariants, Context::Default): + case CombinedEnumContext(Application::WriterVariants, Context::Table): + case CombinedEnumContext(Application::WriterVariants, Context::Annotation): + { + mxLeftIndent->set_max( MAX_SW - nrVal, FieldUnit::MM_100TH ); + mxRightIndent->set_max( MAX_SW - nVal, FieldUnit::MM_100TH ); + mxFLineIndent->set_max( MAX_SW - nVal - nrVal, FieldUnit::MM_100TH ); + } + break; + case CombinedEnumContext(Application::DrawImpress, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::DrawImpress, Context::Table): + case CombinedEnumContext(Application::DrawImpress, Context::TextObject): + case CombinedEnumContext(Application::DrawImpress, Context::Graphic): + { + mxLeftIndent->set_max( MAX_SC_SD - nrVal, FieldUnit::MM_100TH ); + mxRightIndent->set_max( MAX_SC_SD - nVal, FieldUnit::MM_100TH ); + mxFLineIndent->set_max( MAX_SC_SD - nVal - nrVal, FieldUnit::MM_100TH ); + } + } + + mxLeftIndent->set_value( nVal, FieldUnit::MM_100TH ); + mxRightIndent->set_value( nrVal, FieldUnit::MM_100TH ); + + tools::Long nfVal = o3tl::convert(aTxtFirstLineOfst, o3tl::Length::twip, o3tl::Length::mm100); + nfVal = static_cast<tools::Long>(mxFLineIndent->normalize( nfVal )); + mxFLineIndent->set_value( nfVal, FieldUnit::MM_100TH ); + } + else if (eState != SfxItemState::DISABLED ) + { + mxLeftIndent->set_text(""); + mxRightIndent->set_text(""); + mxFLineIndent->set_text(""); + } + + limitMetricWidths(); +} + +void ParaPropertyPanel::StateChangedULImpl( SfxItemState eState, const SfxPoolItem* pState ) +{ + mxTopDist->set_max( mxTopDist->normalize( MAX_DURCH ), MapToFieldUnit(m_eULSpaceUnit) ); + mxBottomDist->set_max( mxBottomDist->normalize( MAX_DURCH ), MapToFieldUnit(m_eULSpaceUnit) ); + + bool bDisabled = eState == SfxItemState::DISABLED; + mxTopDist->set_sensitive(!bDisabled); + mxBottomDist->set_sensitive(!bDisabled); + + if( pState && eState >= SfxItemState::DEFAULT ) + { + const SvxULSpaceItem* pOldItem = static_cast<const SvxULSpaceItem*>(pState); + + maUpper = pOldItem->GetUpper(); + maUpper = OutputDevice::LogicToLogic(maUpper, m_eULSpaceUnit, MapUnit::MapTwip); + + maLower = pOldItem->GetLower(); + maLower = OutputDevice::LogicToLogic(maLower, m_eULSpaceUnit, MapUnit::MapTwip); + + sal_Int64 nVal = o3tl::convert(maUpper, o3tl::Length::twip, o3tl::Length::mm100); + nVal = mxTopDist->normalize( nVal ); + mxTopDist->set_value( nVal, FieldUnit::MM_100TH ); + + nVal = o3tl::convert(maLower, o3tl::Length::twip, o3tl::Length::mm100); + nVal = mxBottomDist->normalize( nVal ); + mxBottomDist->set_value( nVal, FieldUnit::MM_100TH ); + } + else if (eState != SfxItemState::DISABLED ) + { + mxTopDist->set_text(""); + mxBottomDist->set_text(""); + } + limitMetricWidths(); +} + +FieldUnit ParaPropertyPanel::GetCurrentUnit( SfxItemState eState, const SfxPoolItem* pState ) +{ + FieldUnit eUnit = FieldUnit::NONE; + + if ( pState && eState >= SfxItemState::DEFAULT ) + eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pState)->GetValue()); + else + { + SfxViewFrame* pFrame = SfxViewFrame::Current(); + SfxObjectShell* pSh = nullptr; + if ( pFrame ) + pSh = pFrame->GetObjectShell(); + if ( pSh ) //the object shell is not always available during reload + { + SfxModule* pModule = pSh->GetModule(); + if ( pModule ) + { + const SfxPoolItem* pItem = pModule->GetItem( SID_ATTR_METRIC ); + if ( pItem ) + eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pItem)->GetValue()); + } + else + { + SAL_WARN("svx.sidebar", "GetModuleFieldUnit(): no module found"); + } + } + } + + return eUnit; +} + +ParaPropertyPanel::ParaPropertyPanel(weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar) + : PanelLayout(pParent, "ParaPropertyPanel", "svx/ui/sidebarparagraph.ui"), + //Alignment + mxTBxHorzAlign(m_xBuilder->weld_toolbar("horizontalalignment")), + mxHorzAlignDispatch(new ToolbarUnoDispatcher(*mxTBxHorzAlign, *m_xBuilder, rxFrame)), + mxTBxVertAlign(m_xBuilder->weld_toolbar("verticalalignment")), + mxVertAlignDispatch(new ToolbarUnoDispatcher(*mxTBxVertAlign, *m_xBuilder, rxFrame)), + //NumBullet&Backcolor + mxTBxNumBullet(m_xBuilder->weld_toolbar("numberbullet")), + mxNumBulletDispatch(new ToolbarUnoDispatcher(*mxTBxNumBullet, *m_xBuilder, rxFrame)), + mxTBxBackColor(m_xBuilder->weld_toolbar("backgroundcolor")), + mxBackColorDispatch(new ToolbarUnoDispatcher(*mxTBxBackColor, *m_xBuilder, rxFrame)), + mxTBxWriteDirection(m_xBuilder->weld_toolbar("writedirection")), + mxWriteDirectionDispatch(new ToolbarUnoDispatcher(*mxTBxWriteDirection, *m_xBuilder, rxFrame)), + mxTBxParaSpacing(m_xBuilder->weld_toolbar("paraspacing")), + mxParaSpacingDispatch(new ToolbarUnoDispatcher(*mxTBxParaSpacing, *m_xBuilder, rxFrame)), + mxTBxLineSpacing(m_xBuilder->weld_toolbar("linespacing")), + mxLineSpacingDispatch(new ToolbarUnoDispatcher(*mxTBxLineSpacing, *m_xBuilder, rxFrame)), + mxTBxIndent(m_xBuilder->weld_toolbar("indent")), + mxIndentDispatch(new ToolbarUnoDispatcher(*mxTBxIndent, *m_xBuilder, rxFrame)), + //Paragraph spacing + mxTopDist(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("aboveparaspacing", FieldUnit::CM))), + mxBottomDist(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("belowparaspacing", FieldUnit::CM))), + mxLeftIndent(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("beforetextindent", FieldUnit::CM))), + mxRightIndent(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("aftertextindent", FieldUnit::CM))), + mxFLineIndent(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("firstlineindent", FieldUnit::CM))), + maTxtLeft (0), + maUpper (0), + maLower (0), + m_eMetricUnit(FieldUnit::NONE), + m_last_eMetricUnit(FieldUnit::NONE), + m_eLRSpaceUnit(), + m_eULSpaceUnit(), + maLRSpaceControl (SID_ATTR_PARA_LRSPACE,*pBindings,*this), + maULSpaceControl (SID_ATTR_PARA_ULSPACE, *pBindings,*this), + m_aMetricCtl (SID_ATTR_METRIC, *pBindings,*this), + mpBindings(pBindings), + mxSidebar(rxSidebar) +{ + // tdf#130197 We want to give this toolbar a width as if it had 5 entries + // (the parent grid has homogeneous width set so both columns will have the + // same width). This ParaPropertyPanel is a default panel in writer, so + // subsequent panels, e.g. the TableEditPanel panel can have up to 5 + // entries in each of its column and remain in alignment with this panel + padWidthForSidebar(*mxTBxIndent, rxFrame); + + initial(); + m_aMetricCtl.RequestUpdate(); +} + +void ParaPropertyPanel::limitMetricWidths() +{ + limitWidthForSidebar(*mxTopDist); + limitWidthForSidebar(*mxBottomDist); + limitWidthForSidebar(*mxLeftIndent); + limitWidthForSidebar(*mxRightIndent); + limitWidthForSidebar(*mxFLineIndent); +} + +ParaPropertyPanel::~ParaPropertyPanel() +{ + mxHorzAlignDispatch.reset(); + mxTBxHorzAlign.reset(); + + mxVertAlignDispatch.reset(); + mxTBxVertAlign.reset(); + + mxNumBulletDispatch.reset(); + mxTBxNumBullet.reset(); + + mxBackColorDispatch.reset(); + mxTBxBackColor.reset(); + + mxWriteDirectionDispatch.reset(); + mxTBxWriteDirection.reset(); + + mxParaSpacingDispatch.reset(); + mxTBxParaSpacing.reset(); + + mxLineSpacingDispatch.reset(); + mxTBxLineSpacing.reset(); + + mxIndentDispatch.reset(); + mxTBxIndent.reset(); + + mxTopDist.reset(); + mxBottomDist.reset(); + mxLeftIndent.reset(); + mxRightIndent.reset(); + mxFLineIndent.reset(); + + maLRSpaceControl.dispose(); + maULSpaceControl.dispose(); + m_aMetricCtl.dispose(); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaPropertyPanel.hxx b/svx/source/sidebar/paragraph/ParaPropertyPanel.hxx new file mode 100644 index 000000000..bd252eb1a --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaPropertyPanel.hxx @@ -0,0 +1,135 @@ +/* -*- 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 . + */ +#pragma once + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <sfx2/sidebar/IContextChangeReceiver.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> +#include <svx/relfld.hxx> + +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/ui/XSidebar.hpp> + +#include <svl/poolitem.hxx> +#include <tools/fldunit.hxx> +#include <vcl/EnumContext.hxx> + +class ToolbarUnoDispatcher; + +namespace svx::sidebar { + +class ParaPropertyPanel + : public PanelLayout, + public ::sfx2::sidebar::IContextChangeReceiver, + public ::sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface +{ +public: + virtual ~ParaPropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar); + + SfxBindings* GetBindings() { return mpBindings;} + + virtual void HandleContextChange ( + const vcl::EnumContext& rContext) override; + + virtual void NotifyItemUpdate( + const sal_uInt16 nSId, + const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void GetControlState( + const sal_uInt16 /*nSId*/, + boost::property_tree::ptree& /*rState*/) override {}; + + static FieldUnit GetCurrentUnit( SfxItemState eState, const SfxPoolItem* pState ); + + ParaPropertyPanel ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar); + +private: + // UI controls + //Alignment + std::unique_ptr<weld::Toolbar> mxTBxHorzAlign; + std::unique_ptr<ToolbarUnoDispatcher> mxHorzAlignDispatch; + std::unique_ptr<weld::Toolbar> mxTBxVertAlign; + std::unique_ptr<ToolbarUnoDispatcher> mxVertAlignDispatch; + //NumBullet&Backcolor + std::unique_ptr<weld::Toolbar> mxTBxNumBullet; + std::unique_ptr<ToolbarUnoDispatcher> mxNumBulletDispatch; + std::unique_ptr<weld::Toolbar> mxTBxBackColor; + std::unique_ptr<ToolbarUnoDispatcher> mxBackColorDispatch; + + std::unique_ptr<weld::Toolbar> mxTBxWriteDirection; + std::unique_ptr<ToolbarUnoDispatcher> mxWriteDirectionDispatch; + std::unique_ptr<weld::Toolbar> mxTBxParaSpacing; + std::unique_ptr<ToolbarUnoDispatcher> mxParaSpacingDispatch; + std::unique_ptr<weld::Toolbar> mxTBxLineSpacing; + std::unique_ptr<ToolbarUnoDispatcher> mxLineSpacingDispatch; + std::unique_ptr<weld::Toolbar> mxTBxIndent; + std::unique_ptr<ToolbarUnoDispatcher> mxIndentDispatch; + + //Paragraph spacing + std::unique_ptr<SvxRelativeField> mxTopDist; + std::unique_ptr<SvxRelativeField> mxBottomDist; + std::unique_ptr<SvxRelativeField> mxLeftIndent; + std::unique_ptr<SvxRelativeField> mxRightIndent; + std::unique_ptr<SvxRelativeField> mxFLineIndent; + + // Data Member + tools::Long maTxtLeft; + tools::Long maUpper; + tools::Long maLower; + + FieldUnit m_eMetricUnit; + FieldUnit m_last_eMetricUnit; + MapUnit m_eLRSpaceUnit; + MapUnit m_eULSpaceUnit; + // Control Items + ::sfx2::sidebar::ControllerItem maLRSpaceControl; + ::sfx2::sidebar::ControllerItem maULSpaceControl; + ::sfx2::sidebar::ControllerItem m_aMetricCtl; + + vcl::EnumContext maContext; + SfxBindings* mpBindings; + css::uno::Reference<css::ui::XSidebar> mxSidebar; + + DECL_LINK(ModifyIndentHdl_Impl, weld::MetricSpinButton&, void); + DECL_LINK(ULSpaceHdl_Impl, weld::MetricSpinButton&, void); + + void StateChangedIndentImpl( SfxItemState eState, const SfxPoolItem* pState ); + void StateChangedULImpl( SfxItemState eState, const SfxPoolItem* pState ); + + void initial(); + void ReSize(); + void InitToolBoxIndent(); + void InitToolBoxSpacing(); + void limitMetricWidths(); +}; + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaSpacingControl.cxx b/svx/source/sidebar/paragraph/ParaSpacingControl.cxx new file mode 100644 index 000000000..5b4c40969 --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaSpacingControl.cxx @@ -0,0 +1,257 @@ +/* -*- 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 "ParaSpacingWindow.hxx" + +#include <cppuhelper/queryinterface.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/editids.hrc> +#include <svx/ParaSpacingControl.hxx> +#include <vcl/toolbox.hxx> +#include <sfx2/sfxsids.hrc> +#include <svl/intitem.hxx> +#include <comphelper/processfactory.hxx> + +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp> +#include <com/sun/star/ui/XContextChangeEventMultiplexer.hpp> + +using namespace svx; + +SFX_IMPL_TOOLBOX_CONTROL(ParaAboveSpacingControl, SvxULSpaceItem); +SFX_IMPL_TOOLBOX_CONTROL(ParaBelowSpacingControl, SvxULSpaceItem); + +SFX_IMPL_TOOLBOX_CONTROL(ParaLeftSpacingControl, SvxLRSpaceItem); +SFX_IMPL_TOOLBOX_CONTROL(ParaRightSpacingControl, SvxLRSpaceItem); +SFX_IMPL_TOOLBOX_CONTROL(ParaFirstLineSpacingControl, SvxLRSpaceItem); + +ParaULSpacingControl::ParaULSpacingControl(sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) + : SfxToolBoxControl(nSlotId, nId, rTbx) +{ + addStatusListener(".uno:MetricUnit"); +} + +ParaULSpacingControl::~ParaULSpacingControl() +{ +} + +void ParaULSpacingControl::StateChangedAtToolBoxControl(sal_uInt16 nSID, SfxItemState eState, + const SfxPoolItem* pState) +{ + ToolBoxItemId nId = GetId(); + ToolBox& rTbx = GetToolBox(); + ParaULSpacingWindow* pWindow = static_cast<ParaULSpacingWindow*>(rTbx.GetItemWindow(nId)); + + DBG_ASSERT( pWindow, "Control not found!" ); + + if(SfxItemState::DISABLED == eState) + pWindow->Disable(); + else + pWindow->Enable(); + + rTbx.EnableItem(nId, SfxItemState::DISABLED != eState); + + if(nSID == SID_ATTR_METRIC && pState && eState >= SfxItemState::DEFAULT) + { + const SfxUInt16Item* pMetricItem = static_cast<const SfxUInt16Item*>(pState); + pWindow->SetUnit(static_cast<FieldUnit>(pMetricItem->GetValue())); + } + else if((nSID == SID_ATTR_PARA_ULSPACE + || nSID == SID_ATTR_PARA_ABOVESPACE + || nSID == SID_ATTR_PARA_BELOWSPACE ) + && pState && eState >= SfxItemState::DEFAULT) + pWindow->SetValue(static_cast<const SvxULSpaceItem*>(pState)); +} + +// ParaAboveSpacingControl + +ParaAboveSpacingControl::ParaAboveSpacingControl(sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) + : ParaULSpacingControl(nSlotId, nId, rTbx) +{ +} + +VclPtr<InterimItemWindow> ParaAboveSpacingControl::CreateItemWindow(vcl::Window* pParent) +{ + VclPtr<ParaAboveSpacingWindow> pWindow = VclPtr<ParaAboveSpacingWindow>::Create(pParent); + pWindow->Show(); + + return pWindow; +} + +// ParaBelowSpacingControl + +ParaBelowSpacingControl::ParaBelowSpacingControl(sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) + : ParaULSpacingControl(nSlotId, nId, rTbx) +{ +} + +VclPtr<InterimItemWindow> ParaBelowSpacingControl::CreateItemWindow(vcl::Window* pParent) +{ + VclPtr<ParaBelowSpacingWindow> pWindow = VclPtr<ParaBelowSpacingWindow>::Create(pParent); + pWindow->Show(); + + return pWindow; +} + +// ParaLRSpacingControl + +ParaLRSpacingControl::ParaLRSpacingControl(sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) + : SfxToolBoxControl(nSlotId, nId, rTbx) +{ + addStatusListener(".uno:MetricUnit"); +} + +ParaLRSpacingControl::~ParaLRSpacingControl() +{ +} + +void SAL_CALL ParaLRSpacingControl::dispose() +{ + if(m_xMultiplexer.is()) + { + m_xMultiplexer->removeAllContextChangeEventListeners(this); + m_xMultiplexer.clear(); + } + + SfxToolBoxControl::dispose(); +} + +void ParaLRSpacingControl::StateChangedAtToolBoxControl(sal_uInt16 nSID, SfxItemState eState, + const SfxPoolItem* pState) +{ + ToolBoxItemId nId = GetId(); + ToolBox& rTbx = GetToolBox(); + ParaLRSpacingWindow* pWindow = static_cast<ParaLRSpacingWindow*>(rTbx.GetItemWindow(nId)); + + DBG_ASSERT( pWindow, "Control not found!" ); + + if(SfxItemState::DISABLED == eState) + pWindow->Disable(); + else + pWindow->Enable(); + + if(!m_xMultiplexer.is() && m_xFrame.is()) + { + m_xMultiplexer = css::ui::ContextChangeEventMultiplexer::get( + ::comphelper::getProcessComponentContext()); + + m_xMultiplexer->addContextChangeEventListener(this, m_xFrame->getController()); + } + + if(nSID == SID_ATTR_METRIC && pState && eState >= SfxItemState::DEFAULT) + { + const SfxUInt16Item* pMetricItem = static_cast<const SfxUInt16Item*>(pState); + pWindow->SetUnit(static_cast<FieldUnit>(pMetricItem->GetValue())); + } + else if(nSID == SID_ATTR_PARA_LRSPACE + || nSID == SID_ATTR_PARA_LEFTSPACE + || nSID == SID_ATTR_PARA_RIGHTSPACE + || nSID == SID_ATTR_PARA_FIRSTLINESPACE + ) + { + pWindow->SetValue(eState, pState); + } +} + +void SAL_CALL ParaLRSpacingControl::notifyContextChangeEvent(const css::ui::ContextChangeEventObject& rEvent) +{ + ToolBoxItemId nId = GetId(); + ToolBox& rTbx = GetToolBox(); + ParaLRSpacingWindow* pWindow = static_cast<ParaLRSpacingWindow*>(rTbx.GetItemWindow(nId)); + + if(pWindow) + { + vcl::EnumContext eContext( + vcl::EnumContext::GetApplicationEnum(rEvent.ApplicationName), + vcl::EnumContext::GetContextEnum(rEvent.ContextName)); + pWindow->SetContext(eContext); + } +} + +::css::uno::Any SAL_CALL ParaLRSpacingControl::queryInterface(const ::css::uno::Type& aType) +{ + ::css::uno::Any a(SfxToolBoxControl::queryInterface(aType)); + if (a.hasValue()) + return a; + + return ::cppu::queryInterface(aType, static_cast<css::ui::XContextChangeEventListener*>(this)); +} + +void SAL_CALL ParaLRSpacingControl::acquire() noexcept +{ + SfxToolBoxControl::acquire(); +} + +void SAL_CALL ParaLRSpacingControl::disposing(const ::css::lang::EventObject&) +{ + SfxToolBoxControl::disposing(); +} + +void SAL_CALL ParaLRSpacingControl::release() noexcept +{ + SfxToolBoxControl::release(); +} + +// ParaLeftSpacingControl + +ParaLeftSpacingControl::ParaLeftSpacingControl(sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) +: ParaLRSpacingControl(nSlotId, nId, rTbx) +{ +} + +VclPtr<InterimItemWindow> ParaLeftSpacingControl::CreateItemWindow(vcl::Window* pParent) +{ + VclPtr<ParaLeftSpacingWindow> pWindow = VclPtr<ParaLeftSpacingWindow>::Create(pParent); + pWindow->Show(); + + return pWindow; +} + +// ParaRightSpacingControl + +ParaRightSpacingControl::ParaRightSpacingControl(sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) +: ParaLRSpacingControl(nSlotId, nId, rTbx) +{ +} + +VclPtr<InterimItemWindow> ParaRightSpacingControl::CreateItemWindow(vcl::Window* pParent) +{ + VclPtr<ParaRightSpacingWindow> pWindow = VclPtr<ParaRightSpacingWindow>::Create(pParent); + pWindow->Show(); + + return pWindow; +} + +// ParaFirstLineSpacingControl + +ParaFirstLineSpacingControl::ParaFirstLineSpacingControl(sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) +: ParaLRSpacingControl(nSlotId, nId, rTbx) +{ +} + +VclPtr<InterimItemWindow> ParaFirstLineSpacingControl::CreateItemWindow(vcl::Window* pParent) +{ + VclPtr<ParaFirstLineSpacingWindow> pWindow = VclPtr<ParaFirstLineSpacingWindow>::Create(pParent); + pWindow->Show(); + + return pWindow; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaSpacingWindow.cxx b/svx/source/sidebar/paragraph/ParaSpacingWindow.cxx new file mode 100644 index 000000000..fa164dd02 --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaSpacingWindow.cxx @@ -0,0 +1,341 @@ +/* -*- 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 "ParaSpacingWindow.hxx" +#include <editeng/editids.hrc> +#include <editeng/lrspitem.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/app.hxx> +#include <sfx2/viewfrm.hxx> +#include <svl/itempool.hxx> + +using namespace svx; + +#define DEFAULT_VALUE 0 +#define MAX_DURCH 31680 // tdf#68335: 1584 pt for UX interoperability with Word +#define MAX_SW 1709400 +#define MAX_SC_SD 116220200 +#define NEGA_MAXVALUE -10000000 + +// ParaULSpacingWindow + +ParaULSpacingWindow::ParaULSpacingWindow(vcl::Window* pParent) + : InterimItemWindow(pParent, "svx/ui/paraulspacing.ui", "ParaULSpacingWindow") + , m_eUnit(MapUnit::MapTwip) +{ + m_xAboveSpacing = std::make_unique<SvxRelativeField>(m_xBuilder->weld_metric_spin_button("aboveparaspacing", FieldUnit::CM)); + m_xBelowSpacing = std::make_unique<SvxRelativeField>(m_xBuilder->weld_metric_spin_button("belowparaspacing", FieldUnit::CM)); + m_xAboveContainer = m_xBuilder->weld_container("above"); + m_xBelowContainer = m_xBuilder->weld_container("below"); + + Link<weld::MetricSpinButton&,void> aLink = LINK(this, ParaULSpacingWindow, ModifySpacingHdl); + m_xAboveSpacing->connect_value_changed(aLink); + m_xBelowSpacing->connect_value_changed(aLink); + + /// set the initial values of max width + m_xAboveSpacing->set_max(m_xAboveSpacing->normalize(MAX_DURCH), FieldUnit::CM); + m_xBelowSpacing->set_max(m_xBelowSpacing->normalize(MAX_DURCH), FieldUnit::CM); +} + +ParaULSpacingWindow::~ParaULSpacingWindow() +{ + disposeOnce(); +} + +void ParaULSpacingWindow::dispose() +{ + m_xAboveSpacing.reset(); + m_xBelowSpacing.reset(); + m_xAboveContainer.reset(); + m_xBelowContainer.reset(); + + InterimItemWindow::dispose(); +} + +void ParaULSpacingWindow::SetUnit(FieldUnit eUnit) +{ + m_xAboveSpacing->SetFieldUnit(eUnit); + m_xBelowSpacing->SetFieldUnit(eUnit); + + SfxItemPool &rPool = SfxGetpApp()->GetPool(); + m_eUnit = rPool.GetMetric(SID_ATTR_PARA_ULSPACE); + + m_xAboveSpacing->set_max(m_xAboveSpacing->normalize(MAX_DURCH), MapToFieldUnit(m_eUnit)); + m_xBelowSpacing->set_max(m_xBelowSpacing->normalize(MAX_DURCH), MapToFieldUnit(m_eUnit)); +} + +void ParaULSpacingWindow::SetValue(const SvxULSpaceItem* pItem) +{ + sal_Int64 nVal = pItem->GetUpper(); + nVal = m_xAboveSpacing->normalize(nVal); + m_xAboveSpacing->set_value(nVal, FieldUnit::MM_100TH); + + nVal = pItem->GetLower(); + nVal = m_xBelowSpacing->normalize(nVal); + m_xBelowSpacing->set_value(nVal, FieldUnit::MM_100TH); +} + +IMPL_LINK_NOARG(ParaULSpacingWindow, ModifySpacingHdl, weld::MetricSpinButton&, void) +{ + SfxViewFrame* pFrame = SfxViewFrame::Current(); + if (!pFrame) + return; + SfxDispatcher* pDisp = pFrame->GetBindings().GetDispatcher(); + if(pDisp) + { + SvxULSpaceItem aMargin(SID_ATTR_PARA_ULSPACE); + aMargin.SetUpper(m_xAboveSpacing->GetCoreValue(m_eUnit)); + aMargin.SetLower(m_xBelowSpacing->GetCoreValue(m_eUnit)); + pDisp->ExecuteList(SID_ATTR_PARA_ULSPACE, SfxCallMode::RECORD, {&aMargin}); + } +} + +// ParaAboveSpacingWindow +ParaAboveSpacingWindow::ParaAboveSpacingWindow(vcl::Window* pParent) + : ParaULSpacingWindow(pParent) +{ + InitControlBase(&m_xAboveSpacing->get_widget()); + + m_xAboveContainer->show(); + m_xBelowContainer->hide(); + + SetSizePixel(get_preferred_size()); +} + +// ParaBelowSpacingWindow +ParaBelowSpacingWindow::ParaBelowSpacingWindow(vcl::Window* pParent) + : ParaULSpacingWindow(pParent) +{ + InitControlBase(&m_xBelowSpacing->get_widget()); + + m_xAboveContainer->hide(); + m_xBelowContainer->show(); + + SetSizePixel(get_preferred_size()); +} + +// ParaLRSpacingWindow +ParaLRSpacingWindow::ParaLRSpacingWindow(vcl::Window* pParent) + : InterimItemWindow(pParent, "svx/ui/paralrspacing.ui", "ParaLRSpacingWindow") + , m_eUnit(MapUnit::MapTwip) +{ + m_xBeforeSpacing = std::make_unique<SvxRelativeField>(m_xBuilder->weld_metric_spin_button("beforetextindent", FieldUnit::CM)); + m_xAfterSpacing = std::make_unique<SvxRelativeField>(m_xBuilder->weld_metric_spin_button("aftertextindent", FieldUnit::CM)); + m_xFLSpacing = std::make_unique<SvxRelativeField>(m_xBuilder->weld_metric_spin_button("firstlineindent", FieldUnit::CM)); + m_xBeforeContainer = m_xBuilder->weld_container("before"); + m_xAfterContainer = m_xBuilder->weld_container("after"); + m_xFirstLineContainer = m_xBuilder->weld_container("firstline"); + + Link<weld::MetricSpinButton&,void> aLink = LINK(this, ParaLRSpacingWindow, ModifySpacingHdl); + m_xBeforeSpacing->connect_value_changed(aLink); + m_xAfterSpacing->connect_value_changed(aLink); + m_xFLSpacing->connect_value_changed(aLink); + + /// set the initial values of max width + m_xBeforeSpacing->set_min(NEGA_MAXVALUE, FieldUnit::MM_100TH); + m_xAfterSpacing->set_min(NEGA_MAXVALUE, FieldUnit::MM_100TH); + m_xFLSpacing->set_min(NEGA_MAXVALUE, FieldUnit::MM_100TH); +} + +ParaLRSpacingWindow::~ParaLRSpacingWindow() +{ + disposeOnce(); +} + +void ParaLRSpacingWindow::dispose() +{ + m_xBeforeSpacing.reset(); + m_xAfterSpacing.reset(); + m_xFLSpacing.reset(); + m_xBeforeContainer.reset(); + m_xAfterContainer.reset(); + m_xFirstLineContainer.reset(); + + InterimItemWindow::dispose(); +} + +void ParaLRSpacingWindow::SetContext(const vcl::EnumContext& eContext) +{ + m_aContext = eContext; +} + +void ParaLRSpacingWindow::SetValue(SfxItemState eState, const SfxPoolItem* pState) +{ + switch(m_aContext.GetCombinedContext_DI()) + { + + case CombinedEnumContext(Application::WriterVariants, Context::DrawText): + case CombinedEnumContext(Application::WriterVariants, Context::Annotation): + case CombinedEnumContext(Application::Calc, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::DrawImpress, Context::TextObject): + case CombinedEnumContext(Application::DrawImpress, Context::Graphic): + case CombinedEnumContext(Application::DrawImpress, Context::Table): + { + m_xBeforeSpacing->set_min(DEFAULT_VALUE, FieldUnit::NONE); + m_xAfterSpacing->set_min(DEFAULT_VALUE, FieldUnit::NONE); + m_xFLSpacing->set_min(DEFAULT_VALUE, FieldUnit::NONE); + } + break; + case CombinedEnumContext(Application::WriterVariants, Context::Default): + case CombinedEnumContext(Application::WriterVariants, Context::Text): + case CombinedEnumContext(Application::WriterVariants, Context::Table): + { + m_xBeforeSpacing->set_min(NEGA_MAXVALUE, FieldUnit::MM_100TH); + m_xAfterSpacing->set_min(NEGA_MAXVALUE, FieldUnit::MM_100TH); + m_xFLSpacing->set_min(NEGA_MAXVALUE, FieldUnit::MM_100TH); + } + break; + } + + if(pState && eState >= SfxItemState::DEFAULT) + { + m_xBeforeSpacing->set_sensitive(true); + m_xAfterSpacing->set_sensitive(true); + m_xFLSpacing->set_sensitive(true); + + const SvxLRSpaceItem* pSpace = static_cast<const SvxLRSpaceItem*>(pState); + tools::Long aTxtLeft = pSpace->GetTextLeft(); + tools::Long aTxtRight = pSpace->GetRight(); + tools::Long aTxtFirstLineOfst = pSpace->GetTextFirstLineOffset(); + + aTxtLeft = m_xBeforeSpacing->normalize(aTxtLeft); + + if(m_aContext.GetCombinedContext_DI() != CombinedEnumContext(Application::WriterVariants, Context::Text) + && m_aContext.GetCombinedContext_DI() != CombinedEnumContext(Application::WriterVariants, Context::Default) + && m_aContext.GetCombinedContext_DI() != CombinedEnumContext(Application::WriterVariants, Context::Table)) + { + m_xFLSpacing->set_min(aTxtLeft*-1, FieldUnit::MM_100TH); + } + + aTxtRight = m_xAfterSpacing->normalize(aTxtRight); + + switch(m_aContext.GetCombinedContext_DI()) + { + case CombinedEnumContext(Application::WriterVariants, Context::DrawText): + case CombinedEnumContext(Application::WriterVariants, Context::Text): + case CombinedEnumContext(Application::WriterVariants, Context::Default): + case CombinedEnumContext(Application::WriterVariants, Context::Table): + case CombinedEnumContext(Application::WriterVariants, Context::Annotation): + { + m_xBeforeSpacing->set_max(MAX_SW - aTxtRight, FieldUnit::MM_100TH); + m_xAfterSpacing->set_max(MAX_SW - aTxtLeft, FieldUnit::MM_100TH); + m_xFLSpacing->set_max(MAX_SW - aTxtLeft - aTxtRight, FieldUnit::MM_100TH); + } + break; + case CombinedEnumContext(Application::DrawImpress, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::DrawImpress, Context::Table): + case CombinedEnumContext(Application::DrawImpress, Context::TextObject): + case CombinedEnumContext(Application::DrawImpress, Context::Graphic): + { + m_xBeforeSpacing->set_max(MAX_SC_SD - aTxtRight, FieldUnit::MM_100TH); + m_xAfterSpacing->set_max(MAX_SC_SD - aTxtLeft, FieldUnit::MM_100TH); + m_xFLSpacing->set_max(MAX_SC_SD - aTxtLeft - aTxtRight, FieldUnit::MM_100TH); + } + } + + m_xBeforeSpacing->set_value(aTxtLeft, FieldUnit::MM_100TH); + m_xAfterSpacing->set_value(aTxtRight, FieldUnit::MM_100TH); + + aTxtFirstLineOfst = m_xFLSpacing->normalize(aTxtFirstLineOfst); + m_xFLSpacing->set_value(aTxtFirstLineOfst, FieldUnit::MM_100TH); + } + else if(eState == SfxItemState::DISABLED) + { + m_xBeforeSpacing->set_sensitive(false); + m_xAfterSpacing->set_sensitive(false); + m_xFLSpacing->set_sensitive(false); + } + else + { + m_xBeforeSpacing->set_text(""); + m_xAfterSpacing->set_text(""); + m_xFLSpacing->set_text(""); + } +} + +void ParaLRSpacingWindow::SetUnit(FieldUnit eUnit) +{ + m_xBeforeSpacing->SetFieldUnit(eUnit); + m_xAfterSpacing->SetFieldUnit(eUnit); + m_xFLSpacing->SetFieldUnit(eUnit); + + SfxItemPool &rPool = SfxGetpApp()->GetPool(); + m_eUnit = rPool.GetMetric(SID_ATTR_PARA_LRSPACE); +} + +IMPL_LINK_NOARG(ParaLRSpacingWindow, ModifySpacingHdl, weld::MetricSpinButton&, void) +{ + SfxViewFrame* pFrame = SfxViewFrame::Current(); + if (!pFrame) + return; + SfxDispatcher* pDisp = pFrame->GetBindings().GetDispatcher(); + if(pDisp) + { + SvxLRSpaceItem aMargin(SID_ATTR_PARA_LRSPACE); + aMargin.SetTextLeft(m_xBeforeSpacing->GetCoreValue(m_eUnit)); + aMargin.SetRight(m_xAfterSpacing->GetCoreValue(m_eUnit)); + aMargin.SetTextFirstLineOffset(m_xFLSpacing->GetCoreValue(m_eUnit)); + + pDisp->ExecuteList(SID_ATTR_PARA_LRSPACE, SfxCallMode::RECORD, {&aMargin}); + } +} + +// ParaLeftSpacingWindow +ParaLeftSpacingWindow::ParaLeftSpacingWindow(vcl::Window* pParent) + : ParaLRSpacingWindow(pParent) +{ + InitControlBase(&m_xBeforeSpacing->get_widget()); + + m_xBeforeContainer->show(); + m_xAfterContainer->hide(); + m_xFirstLineContainer->hide(); + + SetSizePixel(get_preferred_size()); +} + +// ParaRightSpacingWindow +ParaRightSpacingWindow::ParaRightSpacingWindow(vcl::Window* pParent) + : ParaLRSpacingWindow(pParent) +{ + InitControlBase(&m_xAfterSpacing->get_widget()); + + m_xBeforeContainer->hide(); + m_xAfterContainer->show(); + m_xFirstLineContainer->hide(); + + SetSizePixel(get_preferred_size()); +} + +// ParaFirstLineSpacingWindow +ParaFirstLineSpacingWindow::ParaFirstLineSpacingWindow(vcl::Window* pParent) + : ParaLRSpacingWindow(pParent) +{ + InitControlBase(&m_xFLSpacing->get_widget()); + + m_xBeforeContainer->hide(); + m_xAfterContainer->hide(); + m_xFirstLineContainer->show(); + + SetSizePixel(get_preferred_size()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/paragraph/ParaSpacingWindow.hxx b/svx/source/sidebar/paragraph/ParaSpacingWindow.hxx new file mode 100644 index 000000000..f1730f933 --- /dev/null +++ b/svx/source/sidebar/paragraph/ParaSpacingWindow.hxx @@ -0,0 +1,110 @@ +/* -*- 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 . + */ +#pragma once + +#include <editeng/ulspitem.hxx> +#include <vcl/EnumContext.hxx> +#include <vcl/InterimItemWindow.hxx> +#include <svx/relfld.hxx> + +using namespace com::sun::star; + +namespace svx +{ +class ParaULSpacingWindow : public InterimItemWindow +{ +public: + virtual ~ParaULSpacingWindow() override; + virtual void dispose() override; + + void SetValue(const SvxULSpaceItem* pItem); + void SetUnit(FieldUnit eUnit); + +protected: + ParaULSpacingWindow(vcl::Window* pParent); + + std::unique_ptr<SvxRelativeField> m_xAboveSpacing; + std::unique_ptr<SvxRelativeField> m_xBelowSpacing; + std::unique_ptr<weld::Container> m_xAboveContainer; + std::unique_ptr<weld::Container> m_xBelowContainer; + + MapUnit m_eUnit; + + DECL_LINK(ModifySpacingHdl, weld::MetricSpinButton&, void); +}; + +class ParaAboveSpacingWindow : public ParaULSpacingWindow +{ +public: + explicit ParaAboveSpacingWindow(vcl::Window* pParent); +}; + +class ParaBelowSpacingWindow : public ParaULSpacingWindow +{ +public: + explicit ParaBelowSpacingWindow(vcl::Window* pParent); +}; + +class ParaLRSpacingWindow : public InterimItemWindow +{ +public: + virtual ~ParaLRSpacingWindow() override; + virtual void dispose() override; + + void SetValue(SfxItemState eState, const SfxPoolItem* pState); + void SetUnit(FieldUnit eUnit); + void SetContext(const vcl::EnumContext& eContext); + +protected: + ParaLRSpacingWindow(vcl::Window* pParent); + + std::unique_ptr<SvxRelativeField> m_xBeforeSpacing; + std::unique_ptr<SvxRelativeField> m_xAfterSpacing; + std::unique_ptr<SvxRelativeField> m_xFLSpacing; + std::unique_ptr<weld::Container> m_xBeforeContainer; + std::unique_ptr<weld::Container> m_xAfterContainer; + std::unique_ptr<weld::Container> m_xFirstLineContainer; + + MapUnit m_eUnit; + + vcl::EnumContext m_aContext; + + DECL_LINK(ModifySpacingHdl, weld::MetricSpinButton&, void); +}; + +class ParaLeftSpacingWindow : public ParaLRSpacingWindow +{ +public: + explicit ParaLeftSpacingWindow(vcl::Window* pParent); +}; + +class ParaRightSpacingWindow : public ParaLRSpacingWindow +{ +public: + explicit ParaRightSpacingWindow(vcl::Window* pParent); +}; + +class ParaFirstLineSpacingWindow : public ParaLRSpacingWindow +{ +public: + explicit ParaFirstLineSpacingWindow(vcl::Window* pParent); +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/possize/PosSizePropertyPanel.cxx b/svx/source/sidebar/possize/PosSizePropertyPanel.cxx new file mode 100644 index 000000000..da9e067b2 --- /dev/null +++ b/svx/source/sidebar/possize/PosSizePropertyPanel.cxx @@ -0,0 +1,1079 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> + +#include <algorithm> + +#include "PosSizePropertyPanel.hxx" +#include <sal/log.hxx> +#include <svx/svxids.hrc> +#include <sfx2/dispatch.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/module.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/weldutils.hxx> +#include <svx/dialcontrol.hxx> +#include <svx/dialmgr.hxx> +#include <svx/rectenum.hxx> +#include <svx/sdangitm.hxx> +#include <unotools/viewoptions.hxx> +#include <unotools/localedatawrapper.hxx> +#include <vcl/canvastools.hxx> +#include <vcl/fieldvalues.hxx> +#include <svl/intitem.hxx> +#include <svx/strings.hrc> +#include <svx/svdpagv.hxx> +#include <svx/svdview.hxx> +#include <svx/transfrmhelper.hxx> +#include <boost/property_tree/ptree.hpp> + +#include <svtools/unitconv.hxx> + +using namespace css; +using namespace css::uno; + +constexpr OUStringLiteral USERITEM_NAME = u"FitItem"; + +namespace svx::sidebar { + +PosSizePropertyPanel::PosSizePropertyPanel( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar) +: PanelLayout(pParent, "PosSizePropertyPanel", "svx/ui/sidebarpossize.ui"), + mxFtPosX(m_xBuilder->weld_label("horizontallabel")), + mxMtrPosX(m_xBuilder->weld_metric_spin_button("horizontalpos", FieldUnit::CM)), + mxFtPosY(m_xBuilder->weld_label("verticallabel")), + mxMtrPosY(m_xBuilder->weld_metric_spin_button("verticalpos", FieldUnit::CM)), + mxFtWidth(m_xBuilder->weld_label("widthlabel")), + mxMtrWidth(m_xBuilder->weld_metric_spin_button("selectwidth", FieldUnit::CM)), + mxFtHeight(m_xBuilder->weld_label("heightlabel")), + mxMtrHeight(m_xBuilder->weld_metric_spin_button("selectheight", FieldUnit::CM)), + mxCbxScale(m_xBuilder->weld_check_button("ratio")), + mxFtAngle(m_xBuilder->weld_label("rotationlabel")), + mxMtrAngle(m_xBuilder->weld_metric_spin_button("rotation", FieldUnit::DEGREE)), + mxCtrlDial(new DialControl), + mxDial(new weld::CustomWeld(*m_xBuilder, "orientationcontrol", *mxCtrlDial)), + mxFtFlip(m_xBuilder->weld_label("fliplabel")), + mxFlipTbx(m_xBuilder->weld_toolbar("selectrotationtype")), + mxFlipDispatch(new ToolbarUnoDispatcher(*mxFlipTbx, *m_xBuilder, rxFrame)), + mxArrangeTbx(m_xBuilder->weld_toolbar("arrangetoolbar")), + mxArrangeDispatch(new ToolbarUnoDispatcher(*mxArrangeTbx, *m_xBuilder, rxFrame)), + mxArrangeTbx2(m_xBuilder->weld_toolbar("arrangetoolbar2")), + mxArrangeDispatch2(new ToolbarUnoDispatcher(*mxArrangeTbx2, *m_xBuilder, rxFrame)), + mxAlignTbx(m_xBuilder->weld_toolbar("aligntoolbar")), + mxAlignDispatch(new ToolbarUnoDispatcher(*mxAlignTbx, *m_xBuilder, rxFrame)), + mxAlignTbx2(m_xBuilder->weld_toolbar("aligntoolbar2")), + mxAlignDispatch2(new ToolbarUnoDispatcher(*mxAlignTbx2, *m_xBuilder, rxFrame)), + mxBtnEditOLEObject(m_xBuilder->weld_button("btnEditObject")), + mpView(nullptr), + mlOldWidth(1), + mlOldHeight(1), + mlRotX(0), + mlRotY(0), + mePoolUnit(), + meDlgUnit(FieldUnit::INCH), // #i124409# init with fallback default + maTransfPosXControl(SID_ATTR_TRANSFORM_POS_X, *pBindings, *this), + maTransfPosYControl(SID_ATTR_TRANSFORM_POS_Y, *pBindings, *this), + maTransfWidthControl(SID_ATTR_TRANSFORM_WIDTH, *pBindings, *this), + maTransfHeightControl(SID_ATTR_TRANSFORM_HEIGHT, *pBindings, *this), + maSvxAngleControl( SID_ATTR_TRANSFORM_ANGLE, *pBindings, *this), + maRotXControl(SID_ATTR_TRANSFORM_ROT_X, *pBindings, *this), + maRotYControl(SID_ATTR_TRANSFORM_ROT_Y, *pBindings, *this), + maProPosControl(SID_ATTR_TRANSFORM_PROTECT_POS, *pBindings, *this), + maProSizeControl(SID_ATTR_TRANSFORM_PROTECT_SIZE, *pBindings, *this), + maAutoWidthControl(SID_ATTR_TRANSFORM_AUTOWIDTH, *pBindings, *this), + maAutoHeightControl(SID_ATTR_TRANSFORM_AUTOHEIGHT, *pBindings, *this), + m_aMetricCtl(SID_ATTR_METRIC, *pBindings, *this), + mpBindings(pBindings), + mbSizeProtected(false), + mbPositionProtected(false), + mbAutoWidth(false), + mbAutoHeight(false), + mbAdjustEnabled(false), + mxSidebar(rxSidebar) +{ + Initialize(); + + // A guesstimate of the longest label in the various sidebar panes to use + // to get this pane's contents to align with them, for lack of a better + // solution + auto nWidth = mxFtWidth->get_preferred_size().Width(); + OUString sLabel = mxFtWidth->get_label(); + mxFtWidth->set_label(SvxResId(RID_SVXSTR_TRANSPARENCY)); + nWidth = std::max(nWidth, mxFtWidth->get_preferred_size().Width());; + mxFtWidth->set_label(sLabel); + mxFtWidth->set_size_request(nWidth, -1); + + mpBindings->Update( SID_ATTR_METRIC ); + mpBindings->Update( SID_ATTR_TRANSFORM_WIDTH ); + mpBindings->Update( SID_ATTR_TRANSFORM_HEIGHT ); + mpBindings->Update( SID_ATTR_TRANSFORM_PROTECT_SIZE ); +} + +PosSizePropertyPanel::~PosSizePropertyPanel() +{ + mxFtPosX.reset(); + mxMtrPosX.reset(); + mxFtPosY.reset(); + mxMtrPosY.reset(); + mxFtWidth.reset(); + mxMtrWidth.reset(); + mxFtHeight.reset(); + mxMtrHeight.reset(); + mxCbxScale.reset(); + mxFtAngle.reset(); + mxMtrAngle.reset(); + mxDial.reset(); + mxCtrlDial.reset(); + mxFtFlip.reset(); + mxFlipDispatch.reset(); + mxFlipTbx.reset(); + mxAlignDispatch.reset(); + mxAlignDispatch2.reset(); + mxAlignTbx.reset(); + mxAlignTbx2.reset(); + mxArrangeDispatch.reset(); + mxArrangeDispatch2.reset(); + mxArrangeTbx.reset(); + mxArrangeTbx2.reset(); + mxBtnEditOLEObject.reset(); + + maTransfPosXControl.dispose(); + maTransfPosYControl.dispose(); + maTransfWidthControl.dispose(); + maTransfHeightControl.dispose(); + + maSvxAngleControl.dispose(); + maRotXControl.dispose(); + maRotYControl.dispose(); + maProPosControl.dispose(); + maProSizeControl.dispose(); + maAutoWidthControl.dispose(); + maAutoHeightControl.dispose(); + m_aMetricCtl.dispose(); +} + +namespace +{ + bool hasText(const SdrView& rSdrView) + { + const SdrMarkList& rMarkList = rSdrView.GetMarkedObjectList(); + + if(1 == rMarkList.GetMarkCount()) + { + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + const SdrObjKind eKind(pObj->GetObjIdentifier()); + + if((pObj->GetObjInventor() == SdrInventor::Default) && (SdrObjKind::Text == eKind || SdrObjKind::TitleText == eKind || SdrObjKind::OutlineText == eKind)) + { + const SdrTextObj* pSdrTextObj = dynamic_cast< const SdrTextObj* >(pObj); + + if(pSdrTextObj && pSdrTextObj->HasText()) + { + return true; + } + } + } + + return false; + } +} // end of anonymous namespace + + +void PosSizePropertyPanel::Initialize() +{ + //Position : Horizontal / Vertical + mxMtrPosX->connect_value_changed( LINK( this, PosSizePropertyPanel, ChangePosXHdl ) ); + mxMtrPosY->connect_value_changed( LINK( this, PosSizePropertyPanel, ChangePosYHdl ) ); + + //Size : Width / Height + mxMtrWidth->connect_value_changed( LINK( this, PosSizePropertyPanel, ChangeWidthHdl ) ); + mxMtrHeight->connect_value_changed( LINK( this, PosSizePropertyPanel, ChangeHeightHdl ) ); + + //Size : Keep ratio + mxCbxScale->connect_toggled( LINK( this, PosSizePropertyPanel, ClickAutoHdl ) ); + + //rotation control + mxCtrlDial->SetLinkedField(mxMtrAngle.get(), 2); + mxCtrlDial->SetModifyHdl(LINK( this, PosSizePropertyPanel, RotationHdl)); + + //use same logic as DialControl_Impl::SetSize + weld::DrawingArea* pDrawingArea = mxCtrlDial->GetDrawingArea(); + int nDim = (std::min<int>(pDrawingArea->get_approximate_digit_width() * 6, + pDrawingArea->get_text_height() * 3) - 1) | 1; + Size aSize(nDim, nDim); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + mxCtrlDial->Init(aSize); + + mxBtnEditOLEObject->connect_clicked( LINK( this, PosSizePropertyPanel, ClickObjectEditHdl ) ); + + SfxViewShell* pCurSh = SfxViewShell::Current(); + if ( pCurSh ) + mpView = pCurSh->GetDrawView(); + else + mpView = nullptr; + + if ( mpView != nullptr ) + { + maUIScale = mpView->GetModel()->GetUIScale(); + mbAdjustEnabled = hasText(*mpView); + } + + mePoolUnit = maTransfWidthControl.GetCoreMetric(); +} + +std::unique_ptr<PanelLayout> PosSizePropertyPanel::Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to PosSizePropertyPanel::Create", nullptr, 0); + if ( ! rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to PosSizePropertyPanel::Create", nullptr, 1); + if (pBindings == nullptr) + throw lang::IllegalArgumentException("no SfxBindings given to PosSizePropertyPanel::Create", nullptr, 2); + + return std::make_unique<PosSizePropertyPanel>(pParent, rxFrame, pBindings, rxSidebar); +} + +void PosSizePropertyPanel::HandleContextChange( + const vcl::EnumContext& rContext) +{ + if (maContext == rContext) + { + // Nothing to do. + return; + } + + maContext = rContext; + + bool bShowPosition = false; + bool bShowAngle = false; + bool bShowFlip = false; + bool bShowEditObject = false; + bool bShowArrangeTbx2 = false; + + switch (maContext.GetCombinedContext_DI()) + { + case CombinedEnumContext(Application::WriterVariants, Context::Draw): + bShowAngle = true; + bShowFlip = true; + bShowArrangeTbx2 = true; + break; + + case CombinedEnumContext(Application::WriterVariants, Context::Graphic): + bShowFlip = true; + bShowAngle = true; // RotGrfFlyFrame: Writer FlyFrames for Graphics now support angle + break; + + case CombinedEnumContext(Application::Calc, Context::Draw): + case CombinedEnumContext(Application::Calc, Context::DrawLine): + case CombinedEnumContext(Application::Calc, Context::Graphic): + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::DrawImpress, Context::DrawLine): + case CombinedEnumContext(Application::DrawImpress, Context::TextObject): + case CombinedEnumContext(Application::DrawImpress, Context::Graphic): + bShowPosition = true; + bShowAngle = true; + bShowFlip = true; + break; + + case CombinedEnumContext(Application::WriterVariants, Context::OLE): + bShowEditObject = true; + break; + + case CombinedEnumContext(Application::Calc, Context::OLE): + case CombinedEnumContext(Application::DrawImpress, Context::OLE): + bShowPosition = true; + bShowEditObject = true; + break; + + case CombinedEnumContext(Application::Calc, Context::Chart): + case CombinedEnumContext(Application::Calc, Context::Form): + case CombinedEnumContext(Application::Calc, Context::Media): + case CombinedEnumContext(Application::Calc, Context::MultiObject): + case CombinedEnumContext(Application::DrawImpress, Context::Media): + case CombinedEnumContext(Application::DrawImpress, Context::Form): + case CombinedEnumContext(Application::DrawImpress, Context::ThreeDObject): + case CombinedEnumContext(Application::DrawImpress, Context::MultiObject): + bShowPosition = true; + break; + } + + // Position + mxFtPosX->set_visible(bShowPosition); + mxMtrPosX->set_visible(bShowPosition); + mxFtPosY->set_visible(bShowPosition); + mxMtrPosY->set_visible(bShowPosition); + + // Rotation + mxFtAngle->set_visible(bShowAngle); + mxMtrAngle->set_visible(bShowAngle); + mxCtrlDial->set_visible(bShowAngle); + + // Flip + mxFtFlip->set_visible(bShowFlip); + mxFlipTbx->set_visible(bShowFlip); + + // Edit Object + mxBtnEditOLEObject->set_visible(bShowEditObject); + + // Arrange tool bar 2 + mxArrangeTbx2->set_visible(bShowArrangeTbx2); + + if (mxSidebar.is()) + mxSidebar->requestLayout(); +} + + +IMPL_LINK_NOARG( PosSizePropertyPanel, ChangeWidthHdl, weld::MetricSpinButton&, void ) +{ + if( mxCbxScale->get_active() && + mxCbxScale->get_sensitive() ) + { + tools::Long nHeight = static_cast<tools::Long>( (static_cast<double>(mlOldHeight) * static_cast<double>(mxMtrWidth->get_value(FieldUnit::NONE))) / static_cast<double>(mlOldWidth) ); + if( nHeight <= mxMtrHeight->get_max( FieldUnit::NONE ) ) + { + mxMtrHeight->set_value( nHeight, FieldUnit::NONE ); + } + else + { + nHeight = static_cast<tools::Long>(mxMtrHeight->get_max( FieldUnit::NONE )); + mxMtrHeight->set_value(nHeight, FieldUnit::NONE); + const tools::Long nWidth = static_cast<tools::Long>( (static_cast<double>(mlOldWidth) * static_cast<double>(nHeight)) / static_cast<double>(mlOldHeight) ); + mxMtrWidth->set_value( nWidth, FieldUnit::NONE ); + } + } + executeSize(); +} + + +IMPL_LINK_NOARG( PosSizePropertyPanel, ChangeHeightHdl, weld::MetricSpinButton&, void ) +{ + if( mxCbxScale->get_active() && + mxCbxScale->get_sensitive() ) + { + tools::Long nWidth = static_cast<tools::Long>( (static_cast<double>(mlOldWidth) * static_cast<double>(mxMtrHeight->get_value(FieldUnit::NONE))) / static_cast<double>(mlOldHeight) ); + if( nWidth <= mxMtrWidth->get_max( FieldUnit::NONE ) ) + { + mxMtrWidth->set_value( nWidth, FieldUnit::NONE ); + } + else + { + nWidth = static_cast<tools::Long>(mxMtrWidth->get_max( FieldUnit::NONE )); + mxMtrWidth->set_value( nWidth, FieldUnit::NONE ); + const tools::Long nHeight = static_cast<tools::Long>( (static_cast<double>(mlOldHeight) * static_cast<double>(nWidth)) / static_cast<double>(mlOldWidth) ); + mxMtrHeight->set_value( nHeight, FieldUnit::NONE ); + } + } + executeSize(); +} + + +IMPL_LINK_NOARG( PosSizePropertyPanel, ChangePosXHdl, weld::MetricSpinButton&, void ) +{ + if ( mxMtrPosX->get_value_changed_from_saved()) + { + tools::Long lX = GetCoreValue( *mxMtrPosX, mePoolUnit ); + + Fraction aUIScale = mpView->GetModel()->GetUIScale(); + lX = tools::Long( lX * aUIScale ); + + SfxInt32Item aPosXItem( SID_ATTR_TRANSFORM_POS_X,static_cast<sal_uInt32>(lX)); + + GetBindings()->GetDispatcher()->ExecuteList( + SID_ATTR_TRANSFORM, SfxCallMode::RECORD, { &aPosXItem }); + } +} + +IMPL_LINK_NOARG( PosSizePropertyPanel, ChangePosYHdl, weld::MetricSpinButton&, void ) +{ + if ( mxMtrPosY->get_value_changed_from_saved() ) + { + tools::Long lY = GetCoreValue( *mxMtrPosY, mePoolUnit ); + + Fraction aUIScale = mpView->GetModel()->GetUIScale(); + lY = tools::Long( lY * aUIScale ); + + SfxInt32Item aPosYItem( SID_ATTR_TRANSFORM_POS_Y,static_cast<sal_uInt32>(lY)); + + GetBindings()->GetDispatcher()->ExecuteList( + SID_ATTR_TRANSFORM, SfxCallMode::RECORD, { &aPosYItem }); + } +} + +IMPL_LINK_NOARG( PosSizePropertyPanel, ClickAutoHdl, weld::Toggleable&, void ) +{ + if ( mxCbxScale->get_active() ) + { + mlOldWidth = std::max(GetCoreValue(*mxMtrWidth, mePoolUnit), SAL_CONST_INT64(1)); + mlOldHeight = std::max(GetCoreValue(*mxMtrHeight, mePoolUnit), SAL_CONST_INT64(1)); + } + + // mxCbxScale must synchronized with that on Position and Size tabpage on Shape Properties dialog + SvtViewOptions aPageOpt(EViewType::TabPage, "cui/ui/possizetabpage/PositionAndSize"); + aPageOpt.SetUserItem( USERITEM_NAME, css::uno::Any( OUString::number( int(mxCbxScale->get_active()) ) ) ); +} + +IMPL_LINK_NOARG( PosSizePropertyPanel, RotationHdl, DialControl&, void ) +{ + Degree100 nTmp = mxCtrlDial->GetRotation(); + + // #i123993# Need to take UIScale into account when executing rotations + const double fUIScale(mpView && mpView->GetModel() ? double(mpView->GetModel()->GetUIScale()) : 1.0); + SdrAngleItem aAngleItem( SID_ATTR_TRANSFORM_ANGLE, nTmp); + SfxInt32Item aRotXItem( SID_ATTR_TRANSFORM_ROT_X, basegfx::fround(mlRotX * fUIScale)); + SfxInt32Item aRotYItem( SID_ATTR_TRANSFORM_ROT_Y, basegfx::fround(mlRotY * fUIScale)); + + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_TRANSFORM, + SfxCallMode::RECORD, { &aAngleItem, &aRotXItem, &aRotYItem }); +} + +IMPL_STATIC_LINK_NOARG( PosSizePropertyPanel, ClickObjectEditHdl, weld::Button&, void ) +{ + SfxViewShell* pCurSh = SfxViewShell::Current(); + if ( pCurSh) + { + pCurSh->DoVerb( -1 ); + } +} + +namespace +{ + void limitWidth(weld::MetricSpinButton& rMetricSpinButton) + { + // space is limited in the sidebar, so limit MetricSpinButtons to a width of 7 digits + const int nMaxDigits = 7; + + weld::SpinButton& rSpinButton = rMetricSpinButton.get_widget(); + rSpinButton.set_width_chars(std::min(rSpinButton.get_width_chars(), nMaxDigits)); + } +} + +void PosSizePropertyPanel::NotifyItemUpdate( + sal_uInt16 nSID, + SfxItemState eState, + const SfxPoolItem* pState) +{ + mxFtAngle->set_sensitive(true); + mxMtrAngle->set_sensitive(true); + mxDial->set_sensitive(true); + mxFtFlip->set_sensitive(true); + mxFlipTbx->set_sensitive(true); + + const SfxUInt32Item* pWidthItem; + const SfxUInt32Item* pHeightItem; + + SfxViewShell* pCurSh = SfxViewShell::Current(); + if ( pCurSh ) + mpView = pCurSh->GetDrawView(); + else + mpView = nullptr; + + if ( mpView == nullptr ) + return; + + mbAdjustEnabled = hasText(*mpView); + + // Pool unit and dialog unit may have changed, make sure that we + // have the current values. + mePoolUnit = maTransfWidthControl.GetCoreMetric(); + + switch (nSID) + { + case SID_ATTR_TRANSFORM_WIDTH: + if ( SfxItemState::DEFAULT == eState ) + { + pWidthItem = dynamic_cast< const SfxUInt32Item* >(pState); + + if(pWidthItem) + { + tools::Long lOldWidth1 = tools::Long( pWidthItem->GetValue() / maUIScale ); + SetFieldUnit( *mxMtrWidth, meDlgUnit, true ); + SetMetricValue( *mxMtrWidth, lOldWidth1, mePoolUnit ); + limitWidth(*mxMtrWidth); + mlOldWidth = lOldWidth1; + mxMtrWidth->save_value(); + break; + } + } + + mxMtrWidth->set_text( "" ); + break; + + case SID_ATTR_TRANSFORM_HEIGHT: + if ( SfxItemState::DEFAULT == eState ) + { + pHeightItem = dynamic_cast< const SfxUInt32Item* >(pState); + + if(pHeightItem) + { + tools::Long nTmp = tools::Long( pHeightItem->GetValue() / maUIScale); + SetFieldUnit( *mxMtrHeight, meDlgUnit, true ); + SetMetricValue( *mxMtrHeight, nTmp, mePoolUnit ); + limitWidth(*mxMtrHeight); + mlOldHeight = nTmp; + mxMtrHeight->save_value(); + break; + } + } + + mxMtrHeight->set_text( ""); + break; + + case SID_ATTR_TRANSFORM_POS_X: + if(SfxItemState::DEFAULT == eState) + { + const SfxInt32Item* pItem = dynamic_cast< const SfxInt32Item* >(pState); + + if(pItem) + { + tools::Long nTmp = tools::Long(pItem->GetValue() / maUIScale); + SetFieldUnit( *mxMtrPosX, meDlgUnit, true ); + SetMetricValue( *mxMtrPosX, nTmp, mePoolUnit ); + limitWidth(*mxMtrPosX); + mxMtrPosX->save_value(); + break; + } + } + + mxMtrPosX->set_text( "" ); + break; + + case SID_ATTR_TRANSFORM_POS_Y: + if(SfxItemState::DEFAULT == eState) + { + const SfxInt32Item* pItem = dynamic_cast< const SfxInt32Item* >(pState); + + if(pItem) + { + tools::Long nTmp = tools::Long(pItem->GetValue() / maUIScale); + SetFieldUnit( *mxMtrPosY, meDlgUnit, true ); + SetMetricValue( *mxMtrPosY, nTmp, mePoolUnit ); + limitWidth(*mxMtrPosY); + mxMtrPosY->save_value(); + break; + } + } + + mxMtrPosY->set_text( "" ); + break; + + case SID_ATTR_TRANSFORM_ROT_X: + if (SfxItemState::DEFAULT == eState) + { + const SfxInt32Item* pItem = dynamic_cast< const SfxInt32Item* >(pState); + + if(pItem) + { + mlRotX = pItem->GetValue(); + mlRotX = tools::Long( mlRotX / maUIScale ); + } + } + break; + + case SID_ATTR_TRANSFORM_ROT_Y: + if (SfxItemState::DEFAULT == eState) + { + const SfxInt32Item* pItem = dynamic_cast< const SfxInt32Item* >(pState); + + if(pItem) + { + mlRotY = pItem->GetValue(); + mlRotY = tools::Long( mlRotY / maUIScale ); + } + } + break; + + case SID_ATTR_TRANSFORM_PROTECT_POS: + if(SfxItemState::DEFAULT == eState) + { + const SfxBoolItem* pItem = dynamic_cast< const SfxBoolItem* >(pState); + + if(pItem) + { + // record the state of position protect + mbPositionProtected = pItem->GetValue(); + break; + } + } + + mbPositionProtected = false; + break; + + case SID_ATTR_TRANSFORM_PROTECT_SIZE: + if(SfxItemState::DEFAULT == eState) + { + const SfxBoolItem* pItem = dynamic_cast< const SfxBoolItem* >(pState); + + if(pItem) + { + // record the state of size protect + mbSizeProtected = pItem->GetValue(); + break; + } + } + + mbSizeProtected = false; + break; + + case SID_ATTR_TRANSFORM_AUTOWIDTH: + if(SfxItemState::DEFAULT == eState) + { + const SfxBoolItem* pItem = dynamic_cast< const SfxBoolItem* >(pState); + + if(pItem) + { + mbAutoWidth = pItem->GetValue(); + } + } + break; + + case SID_ATTR_TRANSFORM_AUTOHEIGHT: + if(SfxItemState::DEFAULT == eState) + { + const SfxBoolItem* pItem = dynamic_cast< const SfxBoolItem* >(pState); + + if(pItem) + { + mbAutoHeight = pItem->GetValue(); + } + } + break; + + case SID_ATTR_TRANSFORM_ANGLE: + if (eState >= SfxItemState::DEFAULT) + { + const SdrAngleItem* pItem = dynamic_cast< const SdrAngleItem* >(pState); + + if(pItem) + { + Degree100 nTmp = NormAngle36000(pItem->GetValue()); + + mxMtrAngle->set_value(nTmp.get(), FieldUnit::DEGREE); + mxCtrlDial->SetRotation(nTmp); + + break; + } + } + + mxMtrAngle->set_text( "" ); + mxCtrlDial->SetRotation( 0_deg100 ); + break; + + case SID_ATTR_METRIC: + MetricState( eState, pState ); + UpdateUIScale(); + break; + + default: + break; + } + + const sal_Int32 nCombinedContext(maContext.GetCombinedContext_DI()); + const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); + + switch (rMarkList.GetMarkCount()) + { + case 0: + break; + + case 1: + { + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + const SdrObjKind eKind(pObj->GetObjIdentifier()); + + if(((nCombinedContext == CombinedEnumContext(Application::DrawImpress, Context::Draw) + || nCombinedContext == CombinedEnumContext(Application::DrawImpress, Context::TextObject) + ) && SdrObjKind::Edge == eKind) + || SdrObjKind::Caption == eKind) + { + mxFtAngle->set_sensitive(false); + mxMtrAngle->set_sensitive(false); + mxDial->set_sensitive(false); + mxFlipTbx->set_sensitive(false); + mxFtFlip->set_sensitive(false); + } + break; + } + + default: + { + sal_uInt16 nMarkObj = 0; + bool isNoEdge = true; + + while(isNoEdge && rMarkList.GetMark(nMarkObj)) + { + const SdrObject* pObj = rMarkList.GetMark(nMarkObj)->GetMarkedSdrObj(); + const SdrObjKind eKind(pObj->GetObjIdentifier()); + + if(((nCombinedContext == CombinedEnumContext(Application::DrawImpress, Context::Draw) + || nCombinedContext == CombinedEnumContext(Application::DrawImpress, Context::TextObject) + ) && SdrObjKind::Edge == eKind) + || SdrObjKind::Caption == eKind) + { + isNoEdge = false; + break; + } + nMarkObj++; + } + + if(!isNoEdge) + { + mxFtAngle->set_sensitive(false); + mxMtrAngle->set_sensitive(false); + mxDial->set_sensitive(false); + mxFlipTbx->set_sensitive(false); + mxFtFlip->set_sensitive(false); + } + break; + } + } + + if(nCombinedContext == CombinedEnumContext(Application::DrawImpress, Context::TextObject)) + { + mxFlipTbx->set_sensitive(false); + mxFtFlip->set_sensitive(false); + } + + DisableControls(); + + // mxCbxScale must synchronized with that on Position and Size tabpage on Shape Properties dialog + SvtViewOptions aPageOpt(EViewType::TabPage, "cui/ui/possizetabpage/PositionAndSize"); + OUString sUserData; + css::uno::Any aUserItem = aPageOpt.GetUserItem( USERITEM_NAME ); + OUString aTemp; + if ( aUserItem >>= aTemp ) + sUserData = aTemp; + mxCbxScale->set_active(static_cast<bool>(sUserData.toInt32())); +} + +void PosSizePropertyPanel::GetControlState(const sal_uInt16 nSID, boost::property_tree::ptree& rState) +{ + weld::MetricSpinButton* pControl = nullptr; + switch (nSID) + { + case SID_ATTR_TRANSFORM_POS_X: + pControl = mxMtrPosX.get(); + break; + case SID_ATTR_TRANSFORM_POS_Y: + pControl = mxMtrPosY.get(); + break; + case SID_ATTR_TRANSFORM_WIDTH: + pControl = mxMtrWidth.get(); + break; + case SID_ATTR_TRANSFORM_HEIGHT: + pControl = mxMtrHeight.get(); + break; + } + + if (pControl && !pControl->get_text().isEmpty()) + { + OUString sValue = Application::GetSettings().GetNeutralLocaleDataWrapper(). + getNum(pControl->get_value(pControl->get_unit()), pControl->get_digits(), false, false); + rState.put(pControl->get_buildable_name().getStr(), sValue.toUtf8().getStr()); + } +} + +void PosSizePropertyPanel::executeSize() +{ + if ( !mxMtrWidth->get_value_changed_from_saved() && !mxMtrHeight->get_value_changed_from_saved()) + return; + + Fraction aUIScale = mpView->GetModel()->GetUIScale(); + + // get Width + double nWidth = static_cast<double>(mxMtrWidth->get_value(FieldUnit::MM_100TH)); + tools::Long lWidth = tools::Long(nWidth * static_cast<double>(aUIScale)); + lWidth = OutputDevice::LogicToLogic( lWidth, MapUnit::Map100thMM, mePoolUnit ); + lWidth = static_cast<tools::Long>(mxMtrWidth->denormalize( lWidth )); + + // get Height + double nHeight = static_cast<double>(mxMtrHeight->get_value(FieldUnit::MM_100TH)); + tools::Long lHeight = tools::Long(nHeight * static_cast<double>(aUIScale)); + lHeight = OutputDevice::LogicToLogic( lHeight, MapUnit::Map100thMM, mePoolUnit ); + lHeight = static_cast<tools::Long>(mxMtrHeight->denormalize( lHeight )); + + // put Width & Height to itemset + SfxUInt32Item aWidthItem( SID_ATTR_TRANSFORM_WIDTH, static_cast<sal_uInt32>(lWidth)); + SfxUInt32Item aHeightItem( SID_ATTR_TRANSFORM_HEIGHT, static_cast<sal_uInt32>(lHeight)); + SfxUInt16Item aPointItem (SID_ATTR_TRANSFORM_SIZE_POINT, sal_uInt16(RectPoint::LT)); + const sal_Int32 nCombinedContext(maContext.GetCombinedContext_DI()); + + if( nCombinedContext == CombinedEnumContext(Application::WriterVariants, Context::Graphic) + || nCombinedContext == CombinedEnumContext(Application::WriterVariants, Context::OLE) + ) + { + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_TRANSFORM, + SfxCallMode::RECORD, { &aWidthItem, &aHeightItem, &aPointItem }); + } + else + { + if ( (mxMtrWidth->get_value_changed_from_saved()) && (mxMtrHeight->get_value_changed_from_saved())) + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_TRANSFORM, + SfxCallMode::RECORD, { &aWidthItem, &aHeightItem, &aPointItem }); + else if( mxMtrWidth->get_value_changed_from_saved()) + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_TRANSFORM, + SfxCallMode::RECORD, { &aWidthItem, &aPointItem }); + else if ( mxMtrHeight->get_value_changed_from_saved()) + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_TRANSFORM, + SfxCallMode::RECORD, { &aHeightItem, &aPointItem }); + } +} + +void PosSizePropertyPanel::DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) +{ + if (meDlgUnit != GetCurrentUnit(SfxItemState::DEFAULT, nullptr)) + { + mpBindings->Update( SID_ATTR_METRIC ); + } + + PanelLayout::DumpAsPropertyTree(rJsonWriter); +} + +void PosSizePropertyPanel::MetricState( SfxItemState eState, const SfxPoolItem* pState ) +{ + bool bPosXBlank = false; + bool bPosYBlank = false; + bool bWidthBlank = false; + bool bHeightBlank = false; + + // #i124409# use the given Item to get the correct UI unit and initialize it + // and the Fields using it + meDlgUnit = GetCurrentUnit(eState,pState); + + if (mxMtrPosX->get_text().isEmpty()) + bPosXBlank = true; + SetFieldUnit( *mxMtrPosX, meDlgUnit, true ); + if(bPosXBlank) + mxMtrPosX->set_text(OUString()); + + if (mxMtrPosY->get_text().isEmpty()) + bPosYBlank = true; + SetFieldUnit( *mxMtrPosY, meDlgUnit, true ); + if(bPosYBlank) + mxMtrPosY->set_text(OUString()); + SetPosSizeMinMax(); + + if (mxMtrWidth->get_text().isEmpty()) + bWidthBlank = true; + SetFieldUnit( *mxMtrWidth, meDlgUnit, true ); + if(bWidthBlank) + mxMtrWidth->set_text(OUString()); + + if (mxMtrHeight->get_text().isEmpty()) + bHeightBlank = true; + SetFieldUnit( *mxMtrHeight, meDlgUnit, true ); + if(bHeightBlank) + mxMtrHeight->set_text(OUString()); +} + + +FieldUnit PosSizePropertyPanel::GetCurrentUnit( SfxItemState eState, const SfxPoolItem* pState ) +{ + FieldUnit eUnit = FieldUnit::NONE; + + if ( pState && eState >= SfxItemState::DEFAULT ) + { + eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pState)->GetValue()); + } + else + { + SfxViewFrame* pFrame = SfxViewFrame::Current(); + SfxObjectShell* pSh = nullptr; + if ( pFrame ) + pSh = pFrame->GetObjectShell(); + if ( pSh ) + { + SfxModule* pModule = pSh->GetModule(); + if ( pModule ) + { + const SfxPoolItem* pItem = pModule->GetItem( SID_ATTR_METRIC ); + if ( pItem ) + eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pItem)->GetValue()); + } + else + { + SAL_WARN("svx.sidebar", "GetModuleFieldUnit(): no module found"); + } + } + } + + return eUnit; +} + + +void PosSizePropertyPanel::DisableControls() +{ + if( mbPositionProtected ) + { + // the position is protected("Position protect" option in modal dialog is checked), + // disable all the Position controls in sidebar + mxFtPosX->set_sensitive(false); + mxMtrPosX->set_sensitive(false); + mxFtPosY->set_sensitive(false); + mxMtrPosY->set_sensitive(false); + mxFtAngle->set_sensitive(false); + mxMtrAngle->set_sensitive(false); + mxDial->set_sensitive(false); + mxFtFlip->set_sensitive(false); + mxFlipTbx->set_sensitive(false); + + mxFtWidth->set_sensitive(false); + mxMtrWidth->set_sensitive(false); + mxFtHeight->set_sensitive(false); + mxMtrHeight->set_sensitive(false); + mxCbxScale->set_sensitive(false); + } + else + { + mxFtPosX->set_sensitive(true); + mxMtrPosX->set_sensitive(true); + mxFtPosY->set_sensitive(true); + mxMtrPosY->set_sensitive(true); + + if( mbSizeProtected ) + { + mxFtWidth->set_sensitive(false); + mxMtrWidth->set_sensitive(false); + mxFtHeight->set_sensitive(false); + mxMtrHeight->set_sensitive(false); + mxCbxScale->set_sensitive(false); + } + else + { + if( mbAdjustEnabled ) + { + if( mbAutoWidth ) + { + mxFtWidth->set_sensitive(false); + mxMtrWidth->set_sensitive(false); + mxCbxScale->set_sensitive(false); + } + else + { + mxFtWidth->set_sensitive(true); + mxMtrWidth->set_sensitive(true); + } + if( mbAutoHeight ) + { + mxFtHeight->set_sensitive(false); + mxMtrHeight->set_sensitive(false); + mxCbxScale->set_sensitive(false); + } + else + { + mxFtHeight->set_sensitive(true); + mxMtrHeight->set_sensitive(true); + } + if( !mbAutoWidth && !mbAutoHeight ) + mxCbxScale->set_sensitive(true); + } + else + { + mxFtWidth->set_sensitive(true); + mxMtrWidth->set_sensitive(true); + mxFtHeight->set_sensitive(true); + mxMtrHeight->set_sensitive(true); + mxCbxScale->set_sensitive(true); + } + } + } +} + +void PosSizePropertyPanel::SetPosSizeMinMax() +{ + SdrPageView* pPV = mpView->GetSdrPageView(); + if (!pPV) + return; + tools::Rectangle aTmpRect(mpView->GetAllMarkedRect()); + pPV->LogicToPagePos(aTmpRect); + maRect = vcl::unotools::b2DRectangleFromRectangle(aTmpRect); + + tools::Rectangle aTmpRect2(mpView->GetWorkArea()); + pPV->LogicToPagePos(aTmpRect2); + maWorkArea = vcl::unotools::b2DRectangleFromRectangle(aTmpRect2); + + const Fraction aUIScale(mpView->GetModel()->GetUIScale()); + TransfrmHelper::ScaleRect( maWorkArea, aUIScale ); + TransfrmHelper::ScaleRect( maRect, aUIScale ); + + const sal_uInt16 nDigits(mxMtrPosX->get_digits()); + TransfrmHelper::ConvertRect( maWorkArea, nDigits, mePoolUnit, meDlgUnit ); + TransfrmHelper::ConvertRect( maRect, nDigits, mePoolUnit, meDlgUnit ); + + double fLeft(maWorkArea.getMinX()); + double fTop(maWorkArea.getMinY()); + double fRight(maWorkArea.getMaxX()); + double fBottom(maWorkArea.getMaxY()); + + // seems that sidebar defaults to top left reference point + // and there's no way to set it to something else + fRight -= maRect.getWidth(); + fBottom -= maRect.getHeight(); + + const double fMaxLong(static_cast<double>(vcl::ConvertValue( LONG_MAX, 0, MapUnit::Map100thMM, meDlgUnit ) - 1)); + fLeft = std::clamp(fLeft, -fMaxLong, fMaxLong); + fRight = std::clamp(fRight, -fMaxLong, fMaxLong); + fTop = std::clamp(fTop, - fMaxLong, fMaxLong); + fBottom = std::clamp(fBottom, -fMaxLong, fMaxLong); + + mxMtrPosX->set_range(basegfx::fround64(fLeft), basegfx::fround64(fRight), FieldUnit::NONE); + limitWidth(*mxMtrPosX); + mxMtrPosY->set_range(basegfx::fround64(fTop), basegfx::fround64(fBottom), FieldUnit::NONE); + limitWidth(*mxMtrPosY); + + double fMaxWidth = maWorkArea.getWidth() - (maRect.getWidth() - fLeft); + double fMaxHeight = maWorkArea.getHeight() - (maRect.getHeight() - fTop); + mxMtrWidth->set_max(std::min<sal_Int64>(INT_MAX, basegfx::fround64(fMaxWidth*100)), FieldUnit::NONE); + limitWidth(*mxMtrWidth); + mxMtrHeight->set_max(std::min<sal_Int64>(INT_MAX, basegfx::fround64(fMaxHeight*100)), FieldUnit::NONE); + limitWidth(*mxMtrHeight); +} + +void PosSizePropertyPanel::UpdateUIScale() +{ + const Fraction aUIScale (mpView->GetModel()->GetUIScale()); + if (maUIScale == aUIScale) + return; + + // UI scale has changed. + + // Remember the new UI scale. + maUIScale = aUIScale; + + // The content of the position and size boxes is only updated when item changes are notified. + // Request such notifications without changing the actual item values. + GetBindings()->Invalidate(SID_ATTR_TRANSFORM_POS_X, true); + GetBindings()->Invalidate(SID_ATTR_TRANSFORM_POS_Y, true); + GetBindings()->Invalidate(SID_ATTR_TRANSFORM_WIDTH, true); + GetBindings()->Invalidate(SID_ATTR_TRANSFORM_HEIGHT, true); +} + + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/possize/PosSizePropertyPanel.hxx b/svx/source/sidebar/possize/PosSizePropertyPanel.hxx new file mode 100644 index 000000000..ede3d3e44 --- /dev/null +++ b/svx/source/sidebar/possize/PosSizePropertyPanel.hxx @@ -0,0 +1,193 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_POSSIZE_POSSIZEPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_POSSIZE_POSSIZEPROPERTYPANEL_HXX + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <sfx2/sidebar/IContextChangeReceiver.hxx> +#include <sfx2/weldutils.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> +#include <svl/poolitem.hxx> +#include <tools/fldunit.hxx> +#include <tools/fract.hxx> +#include <com/sun/star/ui/XSidebar.hpp> +#include <basegfx/range/b2drange.hxx> +#include <vcl/EnumContext.hxx> +#include <vcl/customweld.hxx> +#include <vcl/weld.hxx> + +class SdrView; + +namespace svx { +class DialControl; +}; + +namespace svx::sidebar { + +class PosSizePropertyPanel +: public PanelLayout, + public ::sfx2::sidebar::IContextChangeReceiver, + public ::sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface +{ +public: + virtual ~PosSizePropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar); + + virtual void HandleContextChange( + const vcl::EnumContext& rContext) override; + + virtual void NotifyItemUpdate( + const sal_uInt16 nSId, + const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; + + SfxBindings* GetBindings() { return mpBindings;} + + // constructor/destructor + PosSizePropertyPanel( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + SfxBindings* pBindings, + const css::uno::Reference<css::ui::XSidebar>& rxSidebar); + + virtual void GetControlState( + const sal_uInt16 nSId, + boost::property_tree::ptree& rState) override; + +private: + //Position + std::unique_ptr<weld::Label> mxFtPosX; + std::unique_ptr<weld::MetricSpinButton> mxMtrPosX; + std::unique_ptr<weld::Label> mxFtPosY; + std::unique_ptr<weld::MetricSpinButton> mxMtrPosY; + + // size + std::unique_ptr<weld::Label> mxFtWidth; + std::unique_ptr<weld::MetricSpinButton> mxMtrWidth; + std::unique_ptr<weld::Label> mxFtHeight; + std::unique_ptr<weld::MetricSpinButton> mxMtrHeight; + std::unique_ptr<weld::CheckButton> mxCbxScale; + + //rotation + std::unique_ptr<weld::Label> mxFtAngle; + std::unique_ptr<weld::MetricSpinButton> mxMtrAngle; + + //rotation control + std::unique_ptr<svx::DialControl> mxCtrlDial; + std::unique_ptr<weld::CustomWeld> mxDial; + + //flip + std::unique_ptr<weld::Label> mxFtFlip; + std::unique_ptr<weld::Toolbar> mxFlipTbx; + std::unique_ptr<ToolbarUnoDispatcher> mxFlipDispatch; + + std::unique_ptr<weld::Toolbar> mxArrangeTbx; + std::unique_ptr<ToolbarUnoDispatcher> mxArrangeDispatch; + std::unique_ptr<weld::Toolbar> mxArrangeTbx2; + std::unique_ptr<ToolbarUnoDispatcher> mxArrangeDispatch2; + + std::unique_ptr<weld::Toolbar> mxAlignTbx; + std::unique_ptr<ToolbarUnoDispatcher> mxAlignDispatch; + std::unique_ptr<weld::Toolbar> mxAlignTbx2; + std::unique_ptr<ToolbarUnoDispatcher> mxAlignDispatch2; + + //edit objects button for online's mobile view + std::unique_ptr<weld::Button> mxBtnEditOLEObject; + + // Internal variables + basegfx::B2DRange maRect; + basegfx::B2DRange maWorkArea; + const SdrView* mpView; + sal_uInt32 mlOldWidth; + sal_uInt32 mlOldHeight; + tools::Long mlRotX; + tools::Long mlRotY; + Fraction maUIScale; + MapUnit mePoolUnit; + FieldUnit meDlgUnit; + + // Controller Items + ::sfx2::sidebar::ControllerItem maTransfPosXControl; + ::sfx2::sidebar::ControllerItem maTransfPosYControl; + ::sfx2::sidebar::ControllerItem maTransfWidthControl; + ::sfx2::sidebar::ControllerItem maTransfHeightControl; + + ::sfx2::sidebar::ControllerItem maSvxAngleControl; + ::sfx2::sidebar::ControllerItem maRotXControl; + ::sfx2::sidebar::ControllerItem maRotYControl; + ::sfx2::sidebar::ControllerItem maProPosControl; + ::sfx2::sidebar::ControllerItem maProSizeControl; + ::sfx2::sidebar::ControllerItem maAutoWidthControl; + ::sfx2::sidebar::ControllerItem maAutoHeightControl; + ::sfx2::sidebar::ControllerItem m_aMetricCtl; + + vcl::EnumContext maContext; + SfxBindings* mpBindings; + + bool mbSizeProtected : 1; + bool mbPositionProtected : 1; + bool mbAutoWidth : 1; + bool mbAutoHeight : 1; + bool mbAdjustEnabled : 1; + + css::uno::Reference<css::ui::XSidebar> mxSidebar; + + DECL_LINK( ChangePosXHdl, weld::MetricSpinButton&, void ); + DECL_LINK( ChangePosYHdl, weld::MetricSpinButton&, void ); + DECL_LINK( ChangeWidthHdl, weld::MetricSpinButton&, void ); + DECL_LINK( ChangeHeightHdl, weld::MetricSpinButton&, void ); + DECL_LINK( ClickAutoHdl, weld::Toggleable&, void ); + DECL_LINK( RotationHdl, svx::DialControl&, void ); + DECL_STATIC_LINK( PosSizePropertyPanel, ClickObjectEditHdl, weld::Button&, void ); + + void Initialize(); + void executeSize(); + + void MetricState( SfxItemState eState, const SfxPoolItem* pState ); + static FieldUnit GetCurrentUnit( SfxItemState eState, const SfxPoolItem* pState ); + void DisableControls(); + void SetPosSizeMinMax(); + + /** Check if the UI scale has changed and handle such a change. + UI scale is an SD only feature. The UI scale is represented by items + ATTR_OPTIONS_SCALE_X and + ATTR_OPTIONS_SCALE_Y. + As we have no direct access (there is no dependency of svx on sd) we have to + use a small trick (aka hack): + a) call this method whenever a change of the metric item is notified, + b) check if the UI scale has changed (strangely, the UI scale value is available at the SdrModel. + c) invalidate the items for position and size to trigger notifications of their current values. + */ + void UpdateUIScale(); +}; + + +} // end of namespace svx::sidebar + + +#endif // INCLUDED_SVX_SOURCE_SIDEBAR_POSSIZE_POSSIZEPROPERTYPANEL_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/shadow/ShadowPropertyPanel.cxx b/svx/source/sidebar/shadow/ShadowPropertyPanel.cxx new file mode 100644 index 000000000..93259adc2 --- /dev/null +++ b/svx/source/sidebar/shadow/ShadowPropertyPanel.cxx @@ -0,0 +1,362 @@ +/* -*- 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 "ShadowPropertyPanel.hxx" +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <svx/colorbox.hxx> +#include <svx/svxids.hrc> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <unotools/localedatawrapper.hxx> +#include <svx/sdooitm.hxx> +#include <svx/sdshitm.hxx> +#include <svx/sdshtitm.hxx> +#include <svx/sdprcitm.hxx> +#include <svx/sdsxyitm.hxx> +#include <svx/sdshcitm.hxx> +#include <comphelper/lok.hxx> + +using namespace css; +using namespace css::uno; + +namespace svx::sidebar { + +ShadowPropertyPanel::ShadowPropertyPanel( + weld::Widget* pParent, + SfxBindings* pBindings) +: PanelLayout(pParent, "ShadowPropertyPanel", "svx/ui/sidebarshadow.ui"), + maShadowController(SID_ATTR_FILL_SHADOW, *pBindings, *this), + maShadowTransController(SID_ATTR_SHADOW_TRANSPARENCE, *pBindings, *this), + maShadowBlurController(SID_ATTR_SHADOW_BLUR, *pBindings, *this), + maShadowColorController(SID_ATTR_SHADOW_COLOR, *pBindings, *this), + maShadowXDistanceController(SID_ATTR_SHADOW_XDISTANCE, *pBindings, *this), + maShadowYDistanceController(SID_ATTR_SHADOW_YDISTANCE, *pBindings, *this), + mpBindings(pBindings), + nX(0), + nY(0), + nXY(0), + mxShowShadow(m_xBuilder->weld_check_button("SHOW_SHADOW")), + mxShadowDistance(m_xBuilder->weld_metric_spin_button("LB_DISTANCE", FieldUnit::POINT)), + mxLBShadowColor(new ColorListBox(m_xBuilder->weld_menu_button("LB_SHADOW_COLOR"), [this]{ return GetFrameWeld(); })), + mxShadowAngle(m_xBuilder->weld_combo_box("LB_ANGLE")), + mxFTAngle(m_xBuilder->weld_label("angle")), + mxFTDistance(m_xBuilder->weld_label("distance")), + mxFTTransparency(m_xBuilder->weld_label("transparency_label")), + mxFTBlur(m_xBuilder->weld_label("blur_label")), + mxFTColor(m_xBuilder->weld_label("color")), + mxShadowTransSlider(m_xBuilder->weld_scale("transparency_slider")), + mxShadowTransMetric(m_xBuilder->weld_metric_spin_button("FIELD_TRANSPARENCY", FieldUnit::PERCENT)), + mxShadowBlurMetric(m_xBuilder->weld_metric_spin_button("LB_SHADOW_BLUR", FieldUnit::POINT)) +{ + Initialize(); +} + +ShadowPropertyPanel::~ShadowPropertyPanel() +{ + mxShowShadow.reset(); + mxFTAngle.reset(); + mxShadowAngle.reset(); + mxFTDistance.reset(); + mxShadowDistance.reset(); + mxFTTransparency.reset(); + mxShadowTransSlider.reset(); + mxShadowTransMetric.reset(); + mxShadowBlurMetric.reset(); + mxFTBlur.reset(); + mxFTColor.reset(); + mxLBShadowColor.reset(); + + maShadowController.dispose(); + maShadowTransController.dispose(); + maShadowBlurController.dispose(); + maShadowColorController.dispose(); + maShadowXDistanceController.dispose(); + maShadowYDistanceController.dispose(); +} + +void ShadowPropertyPanel::Initialize() +{ + mxShowShadow->set_state( TRISTATE_FALSE ); + mxShowShadow->connect_toggled( LINK(this, ShadowPropertyPanel, ClickShadowHdl ) ); + mxShadowTransMetric->connect_value_changed( LINK(this, ShadowPropertyPanel, ModifyShadowTransMetricHdl) ); + mxLBShadowColor->SetSelectHdl( LINK( this, ShadowPropertyPanel, ModifyShadowColorHdl ) ); + mxShadowAngle->connect_changed( LINK(this, ShadowPropertyPanel, ModifyShadowAngleHdl) ); + mxShadowDistance->connect_value_changed( LINK(this, ShadowPropertyPanel, ModifyShadowDistanceHdl) ); + mxShadowTransSlider->set_range(0, 100); + mxShadowTransSlider->connect_value_changed( LINK(this, ShadowPropertyPanel, ModifyShadowTransSliderHdl) ); + mxShadowBlurMetric->set_range(0, 150, FieldUnit::POINT); + mxShadowBlurMetric->connect_value_changed(LINK(this, ShadowPropertyPanel, ModifyShadowBlurMetricHdl)); + InsertAngleValues(); +} + +IMPL_LINK_NOARG(ShadowPropertyPanel, ClickShadowHdl, weld::Toggleable&, void) +{ + if( mxShowShadow->get_state() == TRISTATE_FALSE ) + { + SdrOnOffItem aItem(makeSdrShadowItem(false)); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_SHADOW, + SfxCallMode::RECORD, { &aItem }); + + if (comphelper::LibreOfficeKit::isActive()) + { + mxShowShadow->set_state( TRISTATE_FALSE ); + UpdateControls(); + } + } + else + { + SdrOnOffItem aItem(makeSdrShadowItem(true)); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_FILL_SHADOW, + SfxCallMode::RECORD, { &aItem }); + + if (mxShadowDistance->get_value(FieldUnit::POINT) == 0) + mxShadowDistance->set_value( 8, FieldUnit::POINT ); + + if (comphelper::LibreOfficeKit::isActive()) + { + mxShowShadow->set_state( TRISTATE_TRUE ); + UpdateControls(); + } + } +} + +IMPL_LINK_NOARG(ShadowPropertyPanel, ModifyShadowColorHdl, ColorListBox&, void) +{ + XColorItem aItem(makeSdrShadowColorItem(mxLBShadowColor->GetSelectEntryColor())); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_SHADOW_COLOR, + SfxCallMode::RECORD, { &aItem }); +} + +IMPL_LINK_NOARG(ShadowPropertyPanel, ModifyShadowTransMetricHdl, weld::MetricSpinButton&, void) +{ + sal_uInt16 nVal = mxShadowTransMetric->get_value(FieldUnit::PERCENT); + SetTransparencyValue(nVal); + SdrPercentItem aItem( makeSdrShadowTransparenceItem(nVal) ); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_SHADOW_TRANSPARENCE, + SfxCallMode::RECORD, { &aItem }); +} + +IMPL_LINK_NOARG(ShadowPropertyPanel, ModifyShadowBlurMetricHdl, weld::MetricSpinButton&, void) +{ + SdrMetricItem aItem(SDRATTR_SHADOWBLUR, mxShadowBlurMetric->get_value(FieldUnit::MM_100TH)); + + mpBindings->GetDispatcher()->ExecuteList(SID_ATTR_SHADOW_BLUR, SfxCallMode::RECORD, { &aItem }); +} + +IMPL_LINK_NOARG(ShadowPropertyPanel, ModifyShadowTransSliderHdl, weld::Scale&, void) +{ + sal_uInt16 nVal = mxShadowTransSlider->get_value(); + SetTransparencyValue(nVal); + SdrPercentItem aItem( makeSdrShadowTransparenceItem(nVal) ); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_SHADOW_TRANSPARENCE, + SfxCallMode::RECORD, { &aItem }); +} + +IMPL_LINK_NOARG(ShadowPropertyPanel, ModifyShadowAngleHdl, weld::ComboBox&, void) +{ + ModifyShadowDistance(); +} + +IMPL_LINK_NOARG(ShadowPropertyPanel, ModifyShadowDistanceHdl, weld::MetricSpinButton&, void) +{ + ModifyShadowDistance(); +} + +void ShadowPropertyPanel::ModifyShadowDistance() +{ + auto nAngle = mxShadowAngle->get_active_id().toInt32(); + nXY = mxShadowDistance->get_value(FieldUnit::MM_100TH); + switch (nAngle) + { + case 0: nX = nXY; nY = 0; break; + case 45: nX = nXY; nY = -nXY; break; + case 90: nX = 0; nY = - nXY; break; + case 135: nX = nY = -nXY; break; + case 180: nX = -nXY; nY = 0; break; + case 225: nX = -nXY; nY = nXY; break; + case 270: nX = 0; nY = nXY; break; + case 315: nX = nY = nXY; break; + } + SdrMetricItem aXItem(makeSdrShadowXDistItem(nX)); + SdrMetricItem aYItem(makeSdrShadowYDistItem(nY)); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_SHADOW_XDISTANCE, + SfxCallMode::RECORD, { &aXItem }); + GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_SHADOW_YDISTANCE, + SfxCallMode::RECORD, { &aYItem }); +} + +void ShadowPropertyPanel::UpdateControls() +{ + if (mxShowShadow->get_state() == TRISTATE_FALSE) + { + mxShadowDistance->set_sensitive(false); + mxLBShadowColor->set_sensitive(false); + mxShadowAngle->set_sensitive(false); + mxFTAngle->set_sensitive(false); + mxFTDistance->set_sensitive(false); + mxFTTransparency->set_sensitive(false); + mxFTBlur->set_sensitive(false); + mxFTColor->set_sensitive(false); + mxShadowTransSlider->set_sensitive(false); + mxShadowTransMetric->set_sensitive(false); + mxShadowBlurMetric->set_sensitive(false); + + return; + } + else + { + mxShadowDistance->set_sensitive(true); + mxLBShadowColor->set_sensitive(true); + mxShadowAngle->set_sensitive(true); + mxFTAngle->set_sensitive(true); + mxFTDistance->set_sensitive(true); + mxFTTransparency->set_sensitive(true); + mxFTBlur->set_sensitive(true); + mxFTColor->set_sensitive(true); + mxShadowTransSlider->set_sensitive(true); + mxShadowTransMetric->set_sensitive(true); + mxShadowBlurMetric->set_sensitive(true); + } + + if(nX > 0 && nY == 0) { mxShadowAngle->set_active(0); nXY = nX; } + else if( nX > 0 && nY < 0 ) { mxShadowAngle->set_active(1); nXY = nX; } + else if( nX == 0 && nY < 0 ) { mxShadowAngle->set_active(2); nXY = -nY; } + else if( nX < 0 && nY < 0 ) { mxShadowAngle->set_active(3); nXY = -nY; } + else if( nX < 0 && nY == 0 ) { mxShadowAngle->set_active(4); nXY = -nX; } + else if( nX < 0 && nY > 0 ) { mxShadowAngle->set_active(5); nXY = nY; } + else if( nX == 0 && nY > 0 ) { mxShadowAngle->set_active(6); nXY = nY; } + else if( nX > 0 && nY > 0 ) { mxShadowAngle->set_active(7); nXY = nX; } + else { nXY = 0; } + mxShadowDistance->set_value(nXY, FieldUnit::MM_100TH); +} + +void ShadowPropertyPanel::SetTransparencyValue(tools::Long nVal) +{ + mxShadowTransSlider->set_value(nVal); + mxShadowTransMetric->set_value(nVal, FieldUnit::PERCENT); +} + +void ShadowPropertyPanel::InsertAngleValues() +{ + OUString sSuffix = weld::MetricSpinButton::MetricToString(FieldUnit::DEGREE); + + const LocaleDataWrapper& rLocaleData = Application::GetSettings().GetLocaleDataWrapper(); + + mxShadowAngle->append(OUString::number(0), rLocaleData.getNum(0, 0, true, true) + sSuffix); + mxShadowAngle->append(OUString::number(45), rLocaleData.getNum(45, 0, true, true) + sSuffix); + mxShadowAngle->append(OUString::number(90), rLocaleData.getNum(90, 0, true, true) + sSuffix); + mxShadowAngle->append(OUString::number(135), rLocaleData.getNum(135, 0, true, true) + sSuffix); + mxShadowAngle->append(OUString::number(180), rLocaleData.getNum(180, 0, true, true) + sSuffix); + mxShadowAngle->append(OUString::number(225), rLocaleData.getNum(225, 0, true, true) + sSuffix); + mxShadowAngle->append(OUString::number(270), rLocaleData.getNum(270, 0, true, true) + sSuffix); + mxShadowAngle->append(OUString::number(315), rLocaleData.getNum(315, 0, true, true) + sSuffix); +} + +void ShadowPropertyPanel::NotifyItemUpdate( + sal_uInt16 nSID, + SfxItemState eState, + const SfxPoolItem* pState) +{ + switch(nSID) + { + case SID_ATTR_FILL_SHADOW: + { + if(eState >= SfxItemState::DEFAULT) + { + const SdrOnOffItem* pItem = dynamic_cast< const SdrOnOffItem* >(pState); + if (pItem && pItem->GetValue()) + mxShowShadow->set_state(TRISTATE_TRUE); + else + mxShowShadow->set_state(TRISTATE_FALSE); + } + } + break; + + case SID_ATTR_SHADOW_TRANSPARENCE: + { + if(eState >= SfxItemState::DEFAULT) + { + const SdrPercentItem* pTransparencyItem = dynamic_cast< const SdrPercentItem* >(pState); + if(pTransparencyItem) + { + const sal_uInt16 nVal = pTransparencyItem->GetValue(); + SetTransparencyValue(nVal); + } + else + SetTransparencyValue(0); + } + } + break; + case SID_ATTR_SHADOW_BLUR: + { + if (eState >= SfxItemState::DEFAULT) + { + const SdrMetricItem* pRadiusItem = dynamic_cast<const SdrMetricItem*>(pState); + if (pRadiusItem) + { + mxShadowBlurMetric->set_value(pRadiusItem->GetValue(), FieldUnit::MM_100TH); + } + } + } + break; + case SID_ATTR_SHADOW_COLOR: + { + if(eState >= SfxItemState::DEFAULT) + { + const XColorItem* pColorItem = dynamic_cast< const XColorItem* >(pState); + if(pColorItem) + { + mxLBShadowColor->SelectEntry(pColorItem->GetColorValue()); + } + } + } + break; + case SID_ATTR_SHADOW_XDISTANCE: + { + if(eState >= SfxItemState::DEFAULT) + { + const SdrMetricItem* pXDistItem = dynamic_cast< const SdrMetricItem* >(pState); + if(pXDistItem) + { + nX = pXDistItem->GetValue(); + } + } + } + break; + case SID_ATTR_SHADOW_YDISTANCE: + { + if(eState >= SfxItemState::DEFAULT) + { + const SdrMetricItem* pYDistItem = dynamic_cast< const SdrMetricItem* >(pState); + if(pYDistItem) + { + nY = pYDistItem->GetValue(); + } + } + } + break; + } + UpdateControls(); +} + +std::unique_ptr<PanelLayout> ShadowPropertyPanel::Create ( + weld::Widget* pParent, + SfxBindings* pBindings) +{ + if(pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to ShadowPropertyPanel::Create", nullptr, 0); + if(pBindings == nullptr) + throw lang::IllegalArgumentException("no SfxBindings given to ShadowPropertyPanel::Create", nullptr, 2); + + return std::make_unique<ShadowPropertyPanel>(pParent, pBindings); +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/shadow/ShadowPropertyPanel.hxx b/svx/source/sidebar/shadow/ShadowPropertyPanel.hxx new file mode 100644 index 000000000..a68405eb0 --- /dev/null +++ b/svx/source/sidebar/shadow/ShadowPropertyPanel.hxx @@ -0,0 +1,89 @@ +/* -*- 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/. + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_AREA_SHADOWPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_AREA_SHADOWPROPERTYPANEL_HXX + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> + +class ColorListBox; + +namespace svx::sidebar { + +class ShadowPropertyPanel +: public PanelLayout, + public ::sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface +{ +public: + virtual ~ShadowPropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create( + weld::Widget* pParent, + SfxBindings* pBindings); + + virtual void NotifyItemUpdate( + const sal_uInt16 nSId, + const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void GetControlState( + const sal_uInt16 /*nSId*/, + boost::property_tree::ptree& /*rState*/) override {}; + + SfxBindings* GetBindings() { return mpBindings;} + + void Initialize(); + + ShadowPropertyPanel( + weld::Widget* pParent, + SfxBindings* pBindings); + +private: + ::sfx2::sidebar::ControllerItem maShadowController; + ::sfx2::sidebar::ControllerItem maShadowTransController; + ::sfx2::sidebar::ControllerItem maShadowBlurController; + ::sfx2::sidebar::ControllerItem maShadowColorController; + ::sfx2::sidebar::ControllerItem maShadowXDistanceController; + ::sfx2::sidebar::ControllerItem maShadowYDistanceController; + + SfxBindings* mpBindings; + tools::Long nX,nY,nXY; + + std::unique_ptr<weld::CheckButton> mxShowShadow; + std::unique_ptr<weld::MetricSpinButton> mxShadowDistance; + std::unique_ptr<ColorListBox> mxLBShadowColor; + std::unique_ptr<weld::ComboBox> mxShadowAngle; + std::unique_ptr<weld::Label> mxFTAngle; + std::unique_ptr<weld::Label> mxFTDistance; + std::unique_ptr<weld::Label> mxFTTransparency; + std::unique_ptr<weld::Label> mxFTBlur; + std::unique_ptr<weld::Label> mxFTColor; + std::unique_ptr<weld::Scale> mxShadowTransSlider; + std::unique_ptr<weld::MetricSpinButton> mxShadowTransMetric; + std::unique_ptr<weld::MetricSpinButton> mxShadowBlurMetric; + + void InsertAngleValues(); + void SetTransparencyValue(tools::Long); + void UpdateControls(); + void ModifyShadowDistance(); + + DECL_LINK(ClickShadowHdl, weld::Toggleable&, void); + DECL_LINK(ModifyShadowColorHdl, ColorListBox&, void); + DECL_LINK(ModifyShadowTransMetricHdl, weld::MetricSpinButton&, void); + DECL_LINK(ModifyShadowAngleHdl, weld::ComboBox&, void); + DECL_LINK(ModifyShadowDistanceHdl, weld::MetricSpinButton&, void); + DECL_LINK(ModifyShadowTransSliderHdl, weld::Scale&, void); + DECL_LINK(ModifyShadowBlurMetricHdl, weld::MetricSpinButton&, void); +}; + +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/shapes/DefaultShapesPanel.cxx b/svx/source/sidebar/shapes/DefaultShapesPanel.cxx new file mode 100644 index 000000000..2dc8092a5 --- /dev/null +++ b/svx/source/sidebar/shapes/DefaultShapesPanel.cxx @@ -0,0 +1,155 @@ +/* -*- 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 <DefaultShapesPanel.hxx> + +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <comphelper/dispatchcommand.hxx> +#include <vcl/commandinfoprovider.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +namespace svx::sidebar { + +DefaultShapesPanel::DefaultShapesPanel ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) + : PanelLayout(pParent, "DefaultShapesPanel", "svx/ui/defaultshapespanel.ui") + , mxLineArrowSet(new ValueSet(nullptr)) + , mxLineArrowSetWin(new weld::CustomWeld(*m_xBuilder, "LinesArrows", *mxLineArrowSet)) + , mxCurveSet(new ValueSet(nullptr)) + , mxCurveSetWin(new weld::CustomWeld(*m_xBuilder, "Curves", *mxCurveSet)) + , mxConnectorSet(new ValueSet(nullptr)) + , mxConnectorSetWin(new weld::CustomWeld(*m_xBuilder, "Connectors", *mxConnectorSet)) + , mxBasicShapeSet(new ValueSet(nullptr)) + , mxBasicShapeSetWin(new weld::CustomWeld(*m_xBuilder, "BasicShapes", *mxBasicShapeSet)) + , mxSymbolShapeSet(new ValueSet(nullptr)) + , mxSymbolShapeSetWin(new weld::CustomWeld(*m_xBuilder, "SymbolShapes", *mxSymbolShapeSet)) + , mxBlockArrowSet(new ValueSet(nullptr)) + , mxBlockArrowSetWin(new weld::CustomWeld(*m_xBuilder, "BlockArrows", *mxBlockArrowSet)) + , mxFlowchartSet(new ValueSet(nullptr)) + , mxFlowchartSetWin(new weld::CustomWeld(*m_xBuilder, "Flowcharts", *mxFlowchartSet)) + , mxCalloutSet(new ValueSet(nullptr)) + , mxCalloutSetWin(new weld::CustomWeld(*m_xBuilder, "Callouts", *mxCalloutSet)) + , mxStarSet(new ValueSet(nullptr)) + , mxStarSetWin(new weld::CustomWeld(*m_xBuilder, "Stars", *mxStarSet)) + , mx3DObjectSet(new ValueSet(nullptr)) + , mx3DObjectSetWin(new weld::CustomWeld(*m_xBuilder, "3DObjects", *mx3DObjectSet)) + , mxFrame(rxFrame) +{ + Initialize(); + pParent->set_size_request(pParent->get_approximate_digit_width() * 20, -1); + m_xContainer->set_size_request(m_xContainer->get_approximate_digit_width() * 25, -1); +} + +std::unique_ptr<PanelLayout> DefaultShapesPanel::Create( + weld::Widget* pParent, + const Reference< XFrame >& rxFrame) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to DefaultShapesPanel::Create", nullptr, 0); + if ( ! rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to DefaultShapesPanel::Create", nullptr, 1); + + return std::make_unique<DefaultShapesPanel>(pParent, rxFrame); +} + +void DefaultShapesPanel::Initialize() +{ + mpShapesSetMap = decltype(mpShapesSetMap){ + { mxLineArrowSet.get(), mpLineShapes }, + { mxCurveSet.get(), mpCurveShapes }, + { mxConnectorSet.get(), mpConnectorShapes }, + { mxBasicShapeSet.get(), mpBasicShapes }, + { mxSymbolShapeSet.get(), mpSymbolShapes }, + { mxBlockArrowSet.get(), mpBlockArrowShapes }, + { mxFlowchartSet.get(), mpFlowchartShapes }, + { mxCalloutSet.get(), mpCalloutShapes }, + { mxStarSet.get(), mpStarShapes }, + { mx3DObjectSet.get(), mp3DShapes } + }; + populateShapes(); + for(auto& aSetMap: mpShapesSetMap) + { + aSetMap.first->SetColor(Application::GetSettings().GetStyleSettings().GetDialogColor()); + aSetMap.first->SetSelectHdl(LINK(this, DefaultShapesPanel, ShapeSelectHdl)); + } +} + +DefaultShapesPanel::~DefaultShapesPanel() +{ + mpShapesSetMap.clear(); + mxLineArrowSetWin.reset(); + mxLineArrowSet.reset(); + mxCurveSetWin.reset(); + mxCurveSet.reset(); + mxConnectorSetWin.reset(); + mxConnectorSet.reset(); + mxBasicShapeSetWin.reset(); + mxBasicShapeSet.reset(); + mxSymbolShapeSetWin.reset(); + mxSymbolShapeSet.reset(); + mxBlockArrowSetWin.reset(); + mxBlockArrowSet.reset(); + mxFlowchartSetWin.reset(); + mxFlowchartSet.reset(); + mxCalloutSetWin.reset(); + mxCalloutSet.reset(); + mxStarSetWin.reset(); + mxStarSet.reset(); + mx3DObjectSetWin.reset(); + mx3DObjectSet.reset(); +} + +IMPL_LINK(DefaultShapesPanel, ShapeSelectHdl, ValueSet*, rValueSet, void) +{ + for(auto& aSetMap : mpShapesSetMap) + { + if(rValueSet == aSetMap.first) + { + sal_uInt16 nSelectionId = aSetMap.first->GetSelectedItemId(); + comphelper::dispatchCommand(aSetMap.second[nSelectionId - 1], {}); + } + else + aSetMap.first->SetNoSelection(); + } +} + +void DefaultShapesPanel::populateShapes() +{ + OUString sSlotStr, sLabel; + Image aSlotImage; + for(auto& aSet : mpShapesSetMap) + { + aSet.first->SetColCount(6); + for(std::map<sal_uInt16, OUString>::size_type i = 0; i < aSet.second.size(); i++) + { + sSlotStr = aSet.second[i]; + aSlotImage = vcl::CommandInfoProvider::GetImageForCommand(sSlotStr, mxFrame); + auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(sSlotStr, + vcl::CommandInfoProvider::GetModuleIdentifier(mxFrame)); + sLabel = vcl::CommandInfoProvider::GetTooltipForCommand(sSlotStr, aProperties, mxFrame); + sal_uInt16 nSelectionId = i + 1; // tdf#142767 id 0 is reserved for nothing-selected + aSet.first->InsertItem(nSelectionId, aSlotImage, sLabel); + } + } +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/shapes/ShapesUtil.cxx b/svx/source/sidebar/shapes/ShapesUtil.cxx new file mode 100644 index 000000000..ffd1acb62 --- /dev/null +++ b/svx/source/sidebar/shapes/ShapesUtil.cxx @@ -0,0 +1,212 @@ +/* -*- 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 <ShapesUtil.hxx> +#include <map> +#include <rtl/ustring.hxx> + +namespace svx::sidebar{ +SvxShapeCommandsMap::SvxShapeCommandsMap() +{ + mpLineShapes = decltype(mpLineShapes){ + {0, ".uno:Line"}, + {1, ".uno:LineArrowEnd"}, + {2, ".uno:LineCircleArrow"}, + {3, ".uno:LineSquareArrow"}, + {4, ".uno:LineArrows"}, + {5, ".uno:LineArrowStart"}, + {6, ".uno:LineArrowCircle"}, + {7, ".uno:LineArrowSquare"}, + {8, ".uno:MeasureLine"}, + {9, ".uno:Line_Diagonal"} + }; + + mpCurveShapes = decltype(mpCurveShapes){ + {0, ".uno:Freeline_Unfilled"}, + {1, ".uno:Bezier_Unfilled"}, + {2, ".uno:Polygon_Unfilled"}, + {3, ".uno:Polygon_Diagonal_Unfilled"}, + {4, ".uno:Freeline"}, + {5, ".uno:BezierFill"}, + {6, ".uno:Polygon"}, + {7, ".uno:Polygon_Diagonal"} + }; + + mpConnectorShapes = decltype(mpConnectorShapes){ + {0, ".uno:ConnectorArrowEnd"}, + {1, ".uno:ConnectorLineArrowEnd"}, + {2, ".uno:ConnectorCurveArrowEnd"}, + {3, ".uno:ConnectorLinesArrowEnd"}, + {4, ".uno:Connector"}, + {5, ".uno:ConnectorLine"}, + {6, ".uno:ConnectorCurve"}, + {7, ".uno:ConnectorLines"}, + {8, ".uno:ConnectorArrows"}, + {9, ".uno:ConnectorLineArrows"}, + {10, ".uno:ConnectorCurveArrows"}, + {11, ".uno:ConnectorLinesArrows"} + }; + + mpBasicShapes = decltype(mpBasicShapes){ + {0, ".uno:BasicShapes.rectangle"}, + {1, ".uno:BasicShapes.round-rectangle"}, + {2, ".uno:BasicShapes.quadrat"}, + {3, ".uno:BasicShapes.round-quadrat"}, + {4, ".uno:BasicShapes.parallelogram"}, + {5, ".uno:BasicShapes.trapezoid"}, + {6, ".uno:BasicShapes.ellipse"}, + {7, ".uno:BasicShapes.circle"}, + {8, ".uno:BasicShapes.circle-pie"}, + {9, ".uno:CircleCut"}, + {10, ".uno:Arc"}, + {11, ".uno:BasicShapes.block-arc"}, + {12, ".uno:BasicShapes.isosceles-triangle"}, + {13, ".uno:BasicShapes.right-triangle"}, + {14, ".uno:BasicShapes.diamond"}, + {15, ".uno:BasicShapes.pentagon"}, + {16, ".uno:BasicShapes.hexagon"}, + {17, ".uno:BasicShapes.octagon"}, + {18, ".uno:BasicShapes.cross"}, + {19, ".uno:BasicShapes.can"}, + {20, ".uno:BasicShapes.cube"}, + {21, ".uno:BasicShapes.paper"}, + {22, ".uno:BasicShapes.frame"}, + {23, ".uno:BasicShapes.ring"} + }; + + mpSymbolShapes = decltype(mpSymbolShapes){ + {0, ".uno:SymbolShapes.smiley"}, + {1, ".uno:SymbolShapes.sun"}, + {2, ".uno:SymbolShapes.moon"}, + {3, ".uno:SymbolShapes.lightning"}, + {4, ".uno:SymbolShapes.heart"}, + {5, ".uno:SymbolShapes.flower"}, + {6, ".uno:SymbolShapes.cloud"}, + {7, ".uno:SymbolShapes.forbidden"}, + {8, ".uno:SymbolShapes.puzzle"}, + {9, ".uno:SymbolShapes.bracket-pair"}, + {10, ".uno:SymbolShapes.left-bracket"}, + {11, ".uno:SymbolShapes.right-bracket"}, + {12, ".uno:SymbolShapes.brace-pair"}, + {13, ".uno:SymbolShapes.left-brace"}, + {14, ".uno:SymbolShapes.right-brace"}, + {15, ".uno:SymbolShapes.quad-bevel"}, + {16, ".uno:SymbolShapes.octagon-bevel"}, + {17, ".uno:SymbolShapes.diamond-bevel"} + }; + + mpBlockArrowShapes = decltype(mpBlockArrowShapes){ + {0, ".uno:ArrowShapes.left-arrow"}, + {1, ".uno:ArrowShapes.right-arrow"}, + {2, ".uno:ArrowShapes.up-arrow"}, + {3, ".uno:ArrowShapes.down-arrow"}, + {4, ".uno:ArrowShapes.left-right-arrow"}, + {5, ".uno:ArrowShapes.up-down-arrow"}, + {6, ".uno:ArrowShapes.up-right-arrow"}, + {7, ".uno:ArrowShapes.up-right-down-arrow"}, + {8, ".uno:ArrowShapes.quad-arrow"}, + {9, ".uno:ArrowShapes.corner-right-arrow"}, + {10, ".uno:ArrowShapes.split-arrow"}, + {11, ".uno:ArrowShapes.striped-right-arrow"}, + {12, ".uno:ArrowShapes.notched-right-arrow"}, + {13, ".uno:ArrowShapes.pentagon-right"}, + {14, ".uno:ArrowShapes.chevron"}, + {15, ".uno:ArrowShapes.right-arrow-callout"}, + {16, ".uno:ArrowShapes.left-arrow-callout"}, + {17, ".uno:ArrowShapes.up-arrow-callout"}, + {18, ".uno:ArrowShapes.left-right-arrow-callout"}, + {19, ".uno:ArrowShapes.up-down-arrow-callout"}, + {20, ".uno:ArrowShapes.up-right-arrow-callout"}, + {21, ".uno:ArrowShapes.quad-arrow-callout"}, + {22, ".uno:ArrowShapes.circular-arrow"}, + {23, ".uno:ArrowShapes.down-arrow-callout"}, + {24, ".uno:ArrowShapes.split-round-arrow"}, + {25, ".uno:ArrowShapes.s-sharped-arrow"} + }; + + mpFlowchartShapes = decltype(mpFlowchartShapes){ + {0, ".uno:FlowChartShapes.flowchart-process"}, + {1, ".uno:FlowChartShapes.flowchart-alternate-process"}, + {2, ".uno:FlowChartShapes.flowchart-decision"}, + {3, ".uno:FlowChartShapes.flowchart-data"}, + {4, ".uno:FlowChartShapes.flowchart-predefined-process"}, + {5, ".uno:FlowChartShapes.flowchart-internal-storage"}, + {6, ".uno:FlowChartShapes.flowchart-document"}, + {7, ".uno:FlowChartShapes.flowchart-multidocument"}, + {8, ".uno:FlowChartShapes.flowchart-terminator"}, + {9, ".uno:FlowChartShapes.flowchart-preparation"}, + {10, ".uno:FlowChartShapes.flowchart-manual-input"}, + {11, ".uno:FlowChartShapes.flowchart-manual-operation"}, + {12, ".uno:FlowChartShapes.flowchart-connector"}, + {13, ".uno:FlowChartShapes.flowchart-off-page-connector"}, + {14, ".uno:FlowChartShapes.flowchart-card"}, + {15, ".uno:FlowChartShapes.flowchart-punched-tape"}, + {16, ".uno:FlowChartShapes.flowchart-summing-junction"}, + {17, ".uno:FlowChartShapes.flowchart-or"}, + {18, ".uno:FlowChartShapes.flowchart-collate"}, + {19, ".uno:FlowChartShapes.flowchart-sort"}, + {20, ".uno:FlowChartShapes.flowchart-extract"}, + {21, ".uno:FlowChartShapes.flowchart-merge"}, + {22, ".uno:FlowChartShapes.flowchart-stored-data"}, + {23, ".uno:FlowChartShapes.flowchart-delay"}, + {24, ".uno:FlowChartShapes.flowchart-sequential-access"}, + {25, ".uno:FlowChartShapes.flowchart-magnetic-disk"}, + {26, ".uno:FlowChartShapes.flowchart-direct-access-storage"}, + {27, ".uno:FlowChartShapes.flowchart-display"} + }; + + mpCalloutShapes = decltype(mpCalloutShapes){ + {0, ".uno:CalloutShapes.rectangular-callout"}, + {1, ".uno:CalloutShapes.round-rectangular-callout"}, + {2, ".uno:CalloutShapes.round-callout"}, + {3, ".uno:CalloutShapes.cloud-callout"}, + {4, ".uno:CalloutShapes.line-callout-1"}, + {5, ".uno:CalloutShapes.line-callout-2"}, + {6, ".uno:CalloutShapes.line-callout-3"} + }; + + mpStarShapes = decltype(mpStarShapes){ + {0, ".uno:StarShapes.star4"}, + {1, ".uno:StarShapes.star5"}, + {2, ".uno:StarShapes.star6"}, + {3, ".uno:StarShapes.star8"}, + {4, ".uno:StarShapes.star12"}, + {5, ".uno:StarShapes.star24"}, + {6, ".uno:StarShapes.bang"}, + {7, ".uno:StarShapes.vertical-scroll"}, + {8, ".uno:StarShapes.horizontal-scroll"}, + {9, ".uno:StarShapes.signet"}, + {10, ".uno:StarShapes.doorplate"}, + {11, ".uno:StarShapes.concave-star6"} + }; + + mp3DShapes = decltype(mp3DShapes){ + {0, ".uno:Cube"}, + {1, ".uno:Sphere"}, + {2, ".uno:Cylinder"}, + {3, ".uno:Cone"}, + {4, ".uno:Cyramid"}, + {5, ".uno:Torus"}, + {6, ".uno:Shell3D"}, + {7, ".uno:HalfSphere"} + }; +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
\ No newline at end of file diff --git a/svx/source/sidebar/styles/StylesPropertyPanel.cxx b/svx/source/sidebar/styles/StylesPropertyPanel.cxx new file mode 100644 index 000000000..4e6b2235d --- /dev/null +++ b/svx/source/sidebar/styles/StylesPropertyPanel.cxx @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/IllegalArgumentException.hpp> + +#include "StylesPropertyPanel.hxx" + +using namespace css; +using namespace css::uno; + +namespace svx::sidebar { + +std::unique_ptr<PanelLayout> StylesPropertyPanel::Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to StylesPropertyPanel::Create", nullptr, 0); + if ( ! rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to StylesPropertyPanel::Create", nullptr, 1); + + return std::make_unique<StylesPropertyPanel>(pParent, rxFrame); +} + +StylesPropertyPanel::StylesPropertyPanel(weld::Widget* pParent, const css::uno::Reference<css::frame::XFrame>& rxFrame) + : PanelLayout(pParent, "SidebarStylesPanel", "svx/ui/sidebarstylespanel.ui") + , m_xFontStyle(m_xBuilder->weld_toolbar("fontstyletoolbox")) + , m_xFontStyleDispatch(new ToolbarUnoDispatcher(*m_xFontStyle, *m_xBuilder, rxFrame)) + , m_xStyle(m_xBuilder->weld_toolbar("style")) + , m_xStyleDispatch(new ToolbarUnoDispatcher(*m_xStyle, *m_xBuilder, rxFrame)) +{ +} + +StylesPropertyPanel::~StylesPropertyPanel() +{ + m_xStyleDispatch.reset(); + m_xStyle.reset(); + m_xFontStyleDispatch.reset(); + m_xFontStyle.reset(); +} + +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/svx/source/sidebar/styles/StylesPropertyPanel.hxx b/svx/source/sidebar/styles/StylesPropertyPanel.hxx new file mode 100644 index 000000000..66f773ae9 --- /dev/null +++ b/svx/source/sidebar/styles/StylesPropertyPanel.hxx @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ +#pragma once + +#include <sfx2/sidebar/PanelLayout.hxx> +#include <sfx2/weldutils.hxx> + +namespace svx::sidebar{ + +class StylesPropertyPanel : public PanelLayout +{ +private: + std::unique_ptr<weld::Toolbar> m_xFontStyle; + std::unique_ptr<ToolbarUnoDispatcher> m_xFontStyleDispatch; + + std::unique_ptr<weld::Toolbar> m_xStyle; + std::unique_ptr<ToolbarUnoDispatcher> m_xStyleDispatch; + +public: + virtual ~StylesPropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + + StylesPropertyPanel( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame); +}; + +} //end of namespace svx::sidebar +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/svx/source/sidebar/text/TextCharacterSpacingControl.cxx b/svx/source/sidebar/text/TextCharacterSpacingControl.cxx new file mode 100644 index 000000000..ad9650477 --- /dev/null +++ b/svx/source/sidebar/text/TextCharacterSpacingControl.cxx @@ -0,0 +1,224 @@ +/* -*- 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/bindings.hxx> +#include "TextCharacterSpacingControl.hxx" +#include <unotools/viewoptions.hxx> +#include <editeng/editids.hrc> +#include <editeng/kernitem.hxx> +#include <sfx2/app.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> +#include <TextCharacterSpacingPopup.hxx> +#include <svl/itempool.hxx> +#include <helpids.h> + +#include <com/sun/star/beans/NamedValue.hpp> + +#define SPACING_VERY_TIGHT -30 +#define SPACING_TIGHT -15 +#define SPACING_NORMAL 0 +#define SPACING_LOOSE 30 +#define SPACING_VERY_LOOSE 60 + +namespace svx { + +TextCharacterSpacingControl::TextCharacterSpacingControl(TextCharacterSpacingPopup* pControl, weld::Widget* pParent) + : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/textcharacterspacingcontrol.ui", "TextCharacterSpacingControl") + , mnCustomKern(0) + , mnLastCus(SPACING_NOCUSTOM) + , mxEditKerning(m_xBuilder->weld_metric_spin_button("kerning", FieldUnit::POINT)) + , mxTight(m_xBuilder->weld_button("tight")) + , mxVeryTight(m_xBuilder->weld_button("very_tight")) + , mxNormal(m_xBuilder->weld_button("normal")) + , mxLoose(m_xBuilder->weld_button("loose")) + , mxVeryLoose(m_xBuilder->weld_button("very_loose")) + , mxLastCustom(m_xBuilder->weld_button("last_custom")) + , mxControl(pControl) +{ + mxEditKerning->connect_value_changed(LINK(this, TextCharacterSpacingControl, KerningModifyHdl)); + mxEditKerning->set_help_id(HID_SPACING_MB_KERN); + + Link<weld::Button&,void> aLink = LINK(this, TextCharacterSpacingControl, PredefinedValuesHdl); + mxNormal->connect_clicked(aLink); + mxVeryTight->connect_clicked(aLink); + mxTight->connect_clicked(aLink); + mxVeryLoose->connect_clicked(aLink); + mxLoose->connect_clicked(aLink); + mxLastCustom->connect_clicked(aLink); + + Initialize(); +} + +void TextCharacterSpacingControl::GrabFocus() +{ + tools::Long nKerning = mxEditKerning->get_value(FieldUnit::NONE); + switch (nKerning) + { + case SPACING_VERY_TIGHT: + mxVeryTight->grab_focus(); + break; + case SPACING_TIGHT: + mxTight->grab_focus(); + break; + case SPACING_NORMAL: + mxNormal->grab_focus(); + break; + case SPACING_LOOSE: + mxLoose->grab_focus(); + break; + case SPACING_VERY_LOOSE: + mxVeryLoose->grab_focus(); + break; + default: + if (nKerning == mnCustomKern) + mxLastCustom->grab_focus(); + else + mxEditKerning->grab_focus(); + } +} + +TextCharacterSpacingControl::~TextCharacterSpacingControl() +{ + if (mnLastCus == SPACING_CLOSE_BY_CUS_EDIT) + { + SvtViewOptions aWinOpt(EViewType::Window, SIDEBAR_SPACING_GLOBAL_VALUE); + css::uno::Sequence<css::beans::NamedValue> aSeq + { { "Spacing", css::uno::Any(OUString::number(mnCustomKern)) } }; + aWinOpt.SetUserData(aSeq); + } +} + +void TextCharacterSpacingControl::Initialize() +{ + const SvxKerningItem* pKerningItem(nullptr); + SfxViewFrame* pViewFrm = SfxViewFrame::Current(); + SfxItemState eState = pViewFrm ? pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_CHAR_KERNING, pKerningItem) : SfxItemState::UNKNOWN; + + tools::Long nKerning = 0; + + if(pKerningItem) + nKerning = pKerningItem->GetValue(); + + SvtViewOptions aWinOpt(EViewType::Window, SIDEBAR_SPACING_GLOBAL_VALUE); + if(aWinOpt.Exists()) + { + css::uno::Sequence<css::beans::NamedValue> aSeq = aWinOpt.GetUserData(); + OUString aTmp; + if(aSeq.hasElements()) + aSeq[0].Value >>= aTmp; + + OUString aWinData(aTmp); + mnCustomKern = aWinData.toInt32(); + mnLastCus = SPACING_CLOSE_BY_CUS_EDIT; + } + else + { + mnLastCus = SPACING_NOCUSTOM; + } + + if(eState >= SfxItemState::DEFAULT) + { + MapUnit eUnit = GetCoreMetric(); + MapUnit eOrgUnit = eUnit; + tools::Long nBig = mxEditKerning->normalize(nKerning); + nKerning = OutputDevice::LogicToLogic(nBig, eOrgUnit, MapUnit::MapPoint); + mxEditKerning->set_value(nKerning, FieldUnit::NONE); + } + else if(SfxItemState::DISABLED == eState) + { + mxEditKerning->set_text(OUString()); + mxEditKerning->set_sensitive(false); + } + else + { + mxEditKerning->set_text(OUString()); + mxEditKerning->set_sensitive(false); + } +} + +void TextCharacterSpacingControl::ExecuteCharacterSpacing(tools::Long nValue, bool bClose) +{ + MapUnit eUnit = GetCoreMetric(); + + tools::Long nSign = (nValue < 0) ? -1 : 1; + nValue = nValue * nSign; + + tools::Long nVal = OutputDevice::LogicToLogic(nValue, MapUnit::MapPoint, eUnit); + short nKern = (nValue == 0) ? 0 : static_cast<short>(mxEditKerning->denormalize(nVal)); + + SvxKerningItem aKernItem(nSign * nKern, SID_ATTR_CHAR_KERNING); + + if (SfxViewFrame* pViewFrm = SfxViewFrame::Current()) + { + pViewFrm->GetBindings().GetDispatcher()->ExecuteList(SID_ATTR_CHAR_KERNING, + SfxCallMode::RECORD, { &aKernItem }); + } + + if (bClose) + mxControl->EndPopupMode(); +} + +IMPL_LINK(TextCharacterSpacingControl, PredefinedValuesHdl, weld::Button&, rControl, void) +{ + mnLastCus = SPACING_CLOSE_BY_CLICK_ICON; + + if (&rControl == mxNormal.get()) + { + ExecuteCharacterSpacing(SPACING_NORMAL); + } + else if (&rControl == mxVeryTight.get()) + { + ExecuteCharacterSpacing(SPACING_VERY_TIGHT); + } + else if (&rControl == mxTight.get()) + { + ExecuteCharacterSpacing(SPACING_TIGHT); + } + else if (&rControl == mxVeryLoose.get()) + { + ExecuteCharacterSpacing(SPACING_VERY_LOOSE); + } + else if (&rControl == mxLoose.get()) + { + ExecuteCharacterSpacing(SPACING_LOOSE); + } + else if (&rControl == mxLastCustom.get()) + { + ExecuteCharacterSpacing(mnCustomKern); + } +} + +IMPL_LINK_NOARG(TextCharacterSpacingControl, KerningModifyHdl, weld::MetricSpinButton&, void) +{ + mnLastCus = SPACING_CLOSE_BY_CUS_EDIT; + mnCustomKern = mxEditKerning->get_value(FieldUnit::NONE); + + ExecuteCharacterSpacing(mnCustomKern, false); +} + +MapUnit TextCharacterSpacingControl::GetCoreMetric() +{ + SfxItemPool &rPool = SfxGetpApp()->GetPool(); + sal_uInt16 nWhich = rPool.GetWhich(SID_ATTR_CHAR_KERNING); + return rPool.GetMetric(nWhich); +} + +} // end of namespace svx + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/text/TextCharacterSpacingControl.hxx b/svx/source/sidebar/text/TextCharacterSpacingControl.hxx new file mode 100644 index 000000000..a8ce8b7fb --- /dev/null +++ b/svx/source/sidebar/text/TextCharacterSpacingControl.hxx @@ -0,0 +1,69 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_TEXT_TEXTCHARACTERSPACINGCONTROL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_TEXT_TEXTCHARACTERSPACINGCONTROL_HXX + +#include <svtools/toolbarmenu.hxx> + +namespace svx { +#define SPACING_NOCUSTOM 0 +#define SPACING_CLOSE_BY_CLICK_ICON -1 +#define SPACING_CLOSE_BY_CUS_EDIT 1 + +inline constexpr OUStringLiteral SIDEBAR_SPACING_GLOBAL_VALUE = u"PopupPanel_Spacing"; + +class TextCharacterSpacingPopup; + +class TextCharacterSpacingControl final : public WeldToolbarPopup +{ +public: + explicit TextCharacterSpacingControl(TextCharacterSpacingPopup* pControl, weld::Widget* pParent); + + virtual void GrabFocus() override; + + virtual ~TextCharacterSpacingControl() override; + +private: + tools::Long mnCustomKern; + short mnLastCus; + + std::unique_ptr<weld::MetricSpinButton> mxEditKerning; + std::unique_ptr<weld::Button> mxTight; + std::unique_ptr<weld::Button> mxVeryTight; + std::unique_ptr<weld::Button> mxNormal; + std::unique_ptr<weld::Button> mxLoose; + std::unique_ptr<weld::Button> mxVeryLoose; + std::unique_ptr<weld::Button> mxLastCustom; + + rtl::Reference<TextCharacterSpacingPopup> mxControl; + + void Initialize(); + void ExecuteCharacterSpacing(tools::Long nValue, bool bClose = true); + + DECL_LINK(PredefinedValuesHdl, weld::Button&, void); + DECL_LINK(KerningModifyHdl, weld::MetricSpinButton&, void); + + static MapUnit GetCoreMetric(); +}; + +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/text/TextCharacterSpacingPopup.cxx b/svx/source/sidebar/text/TextCharacterSpacingPopup.cxx new file mode 100644 index 000000000..a8eef9000 --- /dev/null +++ b/svx/source/sidebar/text/TextCharacterSpacingPopup.cxx @@ -0,0 +1,82 @@ +/* -*- 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 <TextCharacterSpacingPopup.hxx> +#include "TextCharacterSpacingControl.hxx" +#include <vcl/toolbox.hxx> + +using namespace svx; + +TextCharacterSpacingPopup::TextCharacterSpacingPopup( + const css::uno::Reference<css::uno::XComponentContext>& rContext) + : PopupWindowController(rContext, nullptr, OUString()) +{ +} + +void TextCharacterSpacingPopup::initialize(const css::uno::Sequence<css::uno::Any>& rArguments) +{ + PopupWindowController::initialize(rArguments); + + if (m_pToolbar) + { + mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar)); + m_pToolbar->set_item_popover(m_aCommandURL.toUtf8(), mxPopoverContainer->getTopLevel()); + } + + ToolBox* pToolBox = nullptr; + ToolBoxItemId nId; + if (getToolboxId(nId, &pToolBox)) + pToolBox->SetItemBits(nId, ToolBoxItemBits::DROPDOWNONLY | pToolBox->GetItemBits(nId)); +} + +TextCharacterSpacingPopup::~TextCharacterSpacingPopup() {} + +std::unique_ptr<WeldToolbarPopup> TextCharacterSpacingPopup::weldPopupWindow() +{ + return std::make_unique<TextCharacterSpacingControl>(this, m_pToolbar); +} + +VclPtr<vcl::Window> TextCharacterSpacingPopup::createVclPopupWindow(vcl::Window* pParent) +{ + mxInterimPopover = VclPtr<InterimToolbarPopup>::Create( + getFrameInterface(), pParent, + std::make_unique<TextCharacterSpacingControl>(this, pParent->GetFrameWeld())); + + mxInterimPopover->Show(); + + return mxInterimPopover; +} + +OUString TextCharacterSpacingPopup::getImplementationName() +{ + return "com.sun.star.comp.svx.CharacterSpacingToolBoxControl"; +} + +css::uno::Sequence<OUString> TextCharacterSpacingPopup::getSupportedServiceNames() +{ + return { "com.sun.star.frame.ToolbarController" }; +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +com_sun_star_comp_svx_CharacterSpacingToolBoxControl_get_implementation( + css::uno::XComponentContext* rContext, css::uno::Sequence<css::uno::Any> const&) +{ + return cppu::acquire(new TextCharacterSpacingPopup(rContext)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/text/TextPropertyPanel.cxx b/svx/source/sidebar/text/TextPropertyPanel.cxx new file mode 100644 index 000000000..1b59a79aa --- /dev/null +++ b/svx/source/sidebar/text/TextPropertyPanel.cxx @@ -0,0 +1,155 @@ +/* -*- 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 "TextPropertyPanel.hxx" + +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <comphelper/lok.hxx> +#include <sfx2/viewsh.hxx> + +using namespace css; + +namespace svx::sidebar { + +std::unique_ptr<PanelLayout> TextPropertyPanel::Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame) +{ + if (pParent == nullptr) + throw lang::IllegalArgumentException("no parent Window given to TextPropertyPanel::Create", nullptr, 0); + if ( ! rxFrame.is()) + throw lang::IllegalArgumentException("no XFrame given to TextPropertyPanel::Create", nullptr, 1); + + return std::make_unique<TextPropertyPanel>(pParent, rxFrame); +} + +TextPropertyPanel::TextPropertyPanel(weld::Widget* pParent, const css::uno::Reference<css::frame::XFrame>& rxFrame) + : PanelLayout(pParent, "SidebarTextPanel", "svx/ui/sidebartextpanel.ui") + , mxFont(m_xBuilder->weld_toolbar("font")) + , mxFontDispatch(new ToolbarUnoDispatcher(*mxFont, *m_xBuilder, rxFrame)) + , mxFontHeight(m_xBuilder->weld_toolbar("fontheight")) + , mxFontHeightDispatch(new ToolbarUnoDispatcher(*mxFontHeight, *m_xBuilder, rxFrame)) + , mxFontEffects(m_xBuilder->weld_toolbar("fonteffects")) + , mxFontEffectsDispatch(new ToolbarUnoDispatcher(*mxFontEffects, *m_xBuilder, rxFrame)) + , mxFontAdjust(m_xBuilder->weld_toolbar("fontadjust")) + , mxFontAdjustDispatch(new ToolbarUnoDispatcher(*mxFontAdjust, *m_xBuilder, rxFrame)) + , mxToolBoxFontColorSw(m_xBuilder->weld_toolbar("colorbar_writer")) + , mxToolBoxFontColorSwDispatch(new ToolbarUnoDispatcher(*mxToolBoxFontColorSw, *m_xBuilder, rxFrame)) + , mxToolBoxFontColor(m_xBuilder->weld_toolbar("colorbar_others")) + , mxToolBoxFontColorDispatch(new ToolbarUnoDispatcher(*mxToolBoxFontColor, *m_xBuilder, rxFrame)) + , mxToolBoxBackgroundColor(m_xBuilder->weld_toolbar("colorbar_background")) + , mxToolBoxBackgroundColorDispatch(new ToolbarUnoDispatcher(*mxToolBoxBackgroundColor, *m_xBuilder, rxFrame)) + , mxResetBar(m_xBuilder->weld_toolbar("resetattr")) + , mxResetBarDispatch(new ToolbarUnoDispatcher(*mxResetBar, *m_xBuilder, rxFrame)) + , mxDefaultBar(m_xBuilder->weld_toolbar("defaultattr")) + , mxDefaultBarDispatch(new ToolbarUnoDispatcher(*mxDefaultBar, *m_xBuilder, rxFrame)) + , mxPositionBar(m_xBuilder->weld_toolbar("position")) + , mxPositionBarDispatch(new ToolbarUnoDispatcher(*mxPositionBar, *m_xBuilder, rxFrame)) + , mxSpacingBar(m_xBuilder->weld_toolbar("spacingbar")) + , mxSpacingBarDispatch(new ToolbarUnoDispatcher(*mxSpacingBar, *m_xBuilder, rxFrame)) +{ + bool isMobilePhone = false; + const SfxViewShell* pViewShell = SfxViewShell::Current(); + if (comphelper::LibreOfficeKit::isActive() && + pViewShell && pViewShell->isLOKMobilePhone()) + isMobilePhone = true; + mxSpacingBar->set_visible(!isMobilePhone); +} + +TextPropertyPanel::~TextPropertyPanel() +{ + mxResetBarDispatch.reset(); + mxDefaultBarDispatch.reset(); + mxPositionBarDispatch.reset(); + mxSpacingBarDispatch.reset(); + mxToolBoxFontColorSwDispatch.reset(); + mxToolBoxFontColorDispatch.reset(); + mxToolBoxBackgroundColorDispatch.reset(); + mxFontAdjustDispatch.reset(); + mxFontEffectsDispatch.reset(); + mxFontHeightDispatch.reset(); + mxFontDispatch.reset(); + + mxResetBar.reset(); + mxDefaultBar.reset(); + mxPositionBar.reset(); + mxSpacingBar.reset(); + mxToolBoxFontColorSw.reset(); + mxToolBoxFontColor.reset(); + mxToolBoxBackgroundColor.reset(); + mxFontAdjust.reset(); + mxFontEffects.reset(); + mxFontHeight.reset(); + mxFont.reset(); +} + +void TextPropertyPanel::HandleContextChange ( + const vcl::EnumContext& rContext) +{ + if (maContext == rContext) + return; + + maContext = rContext; + + bool bWriterText = false; + bool bDrawText = false; + bool bCalcText = false; + + switch (maContext.GetCombinedContext_DI()) + { + case CombinedEnumContext(Application::Calc, Context::DrawText): + case CombinedEnumContext(Application::WriterVariants, Context::DrawText): + case CombinedEnumContext(Application::WriterVariants, Context::Annotation): + case CombinedEnumContext(Application::DrawImpress, Context::DrawText): + case CombinedEnumContext(Application::DrawImpress, Context::Text): + case CombinedEnumContext(Application::DrawImpress, Context::Table): + case CombinedEnumContext(Application::DrawImpress, Context::OutlineText): + case CombinedEnumContext(Application::DrawImpress, Context::Draw): + case CombinedEnumContext(Application::DrawImpress, Context::TextObject): + case CombinedEnumContext(Application::DrawImpress, Context::Graphic): + bDrawText = true; + break; + + case CombinedEnumContext(Application::WriterVariants, Context::Text): + case CombinedEnumContext(Application::WriterVariants, Context::Table): + bWriterText = true; + break; + + case CombinedEnumContext(Application::Calc, Context::Text): + case CombinedEnumContext(Application::Calc, Context::Table): + case CombinedEnumContext(Application::Calc, Context::Cell): + case CombinedEnumContext(Application::Calc, Context::EditCell): + case CombinedEnumContext(Application::Calc, Context::Grid): + bCalcText = true; + break; + + default: + break; + } + + mxToolBoxFontColor->set_visible(!bWriterText); + mxToolBoxFontColorSw->set_visible(bWriterText); + mxToolBoxBackgroundColor->set_visible(bDrawText); + mxResetBar->set_visible(bWriterText || bCalcText); + mxDefaultBar->set_visible(bDrawText); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/text/TextPropertyPanel.hxx b/svx/source/sidebar/text/TextPropertyPanel.hxx new file mode 100644 index 000000000..3ad44bde7 --- /dev/null +++ b/svx/source/sidebar/text/TextPropertyPanel.hxx @@ -0,0 +1,78 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_TEXT_TEXTPROPERTYPANEL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_TEXT_TEXTPROPERTYPANEL_HXX + +#include <sfx2/sidebar/IContextChangeReceiver.hxx> +#include <sfx2/weldutils.hxx> +#include <vcl/EnumContext.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> + +namespace svx::sidebar { + +class TextPropertyPanel + : public PanelLayout, + public ::sfx2::sidebar::IContextChangeReceiver +{ +public: + virtual ~TextPropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + + virtual void HandleContextChange ( + const vcl::EnumContext& rContext) override; + + TextPropertyPanel ( + weld::Widget* pParent, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + +private: + std::unique_ptr<weld::Toolbar> mxFont; + std::unique_ptr<ToolbarUnoDispatcher> mxFontDispatch; + std::unique_ptr<weld::Toolbar> mxFontHeight; + std::unique_ptr<ToolbarUnoDispatcher> mxFontHeightDispatch; + std::unique_ptr<weld::Toolbar> mxFontEffects; + std::unique_ptr<ToolbarUnoDispatcher> mxFontEffectsDispatch; + std::unique_ptr<weld::Toolbar> mxFontAdjust; + std::unique_ptr<ToolbarUnoDispatcher> mxFontAdjustDispatch; + std::unique_ptr<weld::Toolbar> mxToolBoxFontColorSw; + std::unique_ptr<ToolbarUnoDispatcher> mxToolBoxFontColorSwDispatch; + std::unique_ptr<weld::Toolbar> mxToolBoxFontColor; + std::unique_ptr<ToolbarUnoDispatcher> mxToolBoxFontColorDispatch; + std::unique_ptr<weld::Toolbar> mxToolBoxBackgroundColor; + std::unique_ptr<ToolbarUnoDispatcher> mxToolBoxBackgroundColorDispatch; + std::unique_ptr<weld::Toolbar> mxResetBar; + std::unique_ptr<ToolbarUnoDispatcher> mxResetBarDispatch; + std::unique_ptr<weld::Toolbar> mxDefaultBar; + std::unique_ptr<ToolbarUnoDispatcher> mxDefaultBarDispatch; + std::unique_ptr<weld::Toolbar> mxPositionBar; + std::unique_ptr<ToolbarUnoDispatcher> mxPositionBarDispatch; + std::unique_ptr<weld::Toolbar> mxSpacingBar; + std::unique_ptr<ToolbarUnoDispatcher> mxSpacingBarDispatch; + + vcl::EnumContext maContext; +}; + +} // end of namespace svx::sidebar + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/text/TextUnderlineControl.cxx b/svx/source/sidebar/text/TextUnderlineControl.cxx new file mode 100644 index 000000000..ac65b8271 --- /dev/null +++ b/svx/source/sidebar/text/TextUnderlineControl.cxx @@ -0,0 +1,141 @@ +/* -*- 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 "TextUnderlineControl.hxx" +#include <svx/svxids.hrc> +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> +#include <TextUnderlinePopup.hxx> +#include <editeng/editids.hrc> +#include <editeng/udlnitem.hxx> +#include <helpids.h> + +namespace svx { + +TextUnderlineControl::TextUnderlineControl(TextUnderlinePopup* pControl, weld::Widget* pParent) + : WeldToolbarPopup(pControl->getFrameInterface(), pParent, "svx/ui/textunderlinecontrol.ui", "TextUnderlineControl") + , mxNone(m_xBuilder->weld_button("none")) + , mxSingle(m_xBuilder->weld_button("single")) + , mxDouble(m_xBuilder->weld_button("double")) + , mxBold(m_xBuilder->weld_button("bold")) + , mxDot(m_xBuilder->weld_button("dot")) + , mxDotBold(m_xBuilder->weld_button("dotbold")) + , mxDash(m_xBuilder->weld_button("dash")) + , mxDashLong(m_xBuilder->weld_button("dashlong")) + , mxDashDot(m_xBuilder->weld_button("dashdot")) + , mxDashDotDot(m_xBuilder->weld_button("dashdotdot")) + , mxWave(m_xBuilder->weld_button("wave")) + , mxMoreOptions(m_xBuilder->weld_button("moreoptions")) + , mxControl(pControl) +{ + mxMoreOptions->set_help_id(HID_UNDERLINE_BTN); + + Link<weld::Button&,void> aLink = LINK(this, TextUnderlineControl, PBClickHdl); + mxNone->connect_clicked(aLink); + mxSingle->connect_clicked(aLink); + mxDouble->connect_clicked(aLink); + mxBold->connect_clicked(aLink); + mxDot->connect_clicked(aLink); + mxDotBold->connect_clicked(aLink); + mxDash->connect_clicked(aLink); + mxDashLong->connect_clicked(aLink); + mxDashDot->connect_clicked(aLink); + mxDashDotDot->connect_clicked(aLink); + mxWave->connect_clicked(aLink); + mxMoreOptions->connect_clicked(aLink); +} + +void TextUnderlineControl::GrabFocus() +{ + mxNone->grab_focus(); +} + +TextUnderlineControl::~TextUnderlineControl() +{ +} + +FontLineStyle TextUnderlineControl::getLineStyle(const weld::Button& rButton) const +{ + if (&rButton == mxSingle.get()) + return LINESTYLE_SINGLE; + else if (&rButton == mxDouble.get()) + return LINESTYLE_DOUBLE; + else if (&rButton == mxBold.get()) + return LINESTYLE_BOLD; + else if (&rButton == mxDot.get()) + return LINESTYLE_DOTTED; + else if (&rButton == mxDotBold.get()) + return LINESTYLE_BOLDDOTTED; + else if (&rButton == mxDash.get()) + return LINESTYLE_DASH; + else if (&rButton == mxDashLong.get()) + return LINESTYLE_LONGDASH; + else if (&rButton == mxDashDot.get()) + return LINESTYLE_DASHDOT; + else if (&rButton == mxDashDotDot.get()) + return LINESTYLE_DASHDOTDOT; + else if (&rButton == mxWave.get()) + return LINESTYLE_WAVE; + + return LINESTYLE_NONE; +} + +namespace { + +Color GetUnderlineColor() +{ + if (SfxViewFrame* pViewFrm = SfxViewFrame::Current()) + { + const SvxUnderlineItem* pUnderlineItem; + pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_CHAR_UNDERLINE, pUnderlineItem); + + if (pUnderlineItem) + return pUnderlineItem->GetColor(); + } + + return COL_AUTO; +} + +} + +IMPL_LINK(TextUnderlineControl, PBClickHdl, weld::Button&, rButton, void) +{ + if (SfxViewFrame* pViewFrm = SfxViewFrame::Current()) + { + if (&rButton == mxMoreOptions.get()) + { + SfxDispatcher* pDisp = pViewFrm->GetBindings().GetDispatcher(); + pDisp->Execute(SID_CHAR_DLG_EFFECT, SfxCallMode::ASYNCHRON); + } + else + { + const FontLineStyle eUnderline = getLineStyle(rButton); + + SvxUnderlineItem aLineItem(eUnderline, SID_ATTR_CHAR_UNDERLINE); + aLineItem.SetColor(GetUnderlineColor()); + + pViewFrm->GetBindings().GetDispatcher()->ExecuteList(SID_ATTR_CHAR_UNDERLINE, + SfxCallMode::RECORD, { &aLineItem }); + } + } + mxControl->EndPopupMode(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/text/TextUnderlineControl.hxx b/svx/source/sidebar/text/TextUnderlineControl.hxx new file mode 100644 index 000000000..cc1a19c67 --- /dev/null +++ b/svx/source/sidebar/text/TextUnderlineControl.hxx @@ -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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_SIDEBAR_TEXT_TEXTUNDERLINECONTROL_HXX +#define INCLUDED_SVX_SOURCE_SIDEBAR_TEXT_TEXTUNDERLINECONTROL_HXX + +#include <svtools/toolbarmenu.hxx> + +namespace svx +{ +class TextUnderlinePopup; + +class TextUnderlineControl final : public WeldToolbarPopup +{ +public: + explicit TextUnderlineControl(TextUnderlinePopup* pControl, weld::Widget* pParent); + virtual void GrabFocus() override; + virtual ~TextUnderlineControl() override; + +private: + std::unique_ptr<weld::Button> mxNone; + std::unique_ptr<weld::Button> mxSingle; + std::unique_ptr<weld::Button> mxDouble; + std::unique_ptr<weld::Button> mxBold; + std::unique_ptr<weld::Button> mxDot; + std::unique_ptr<weld::Button> mxDotBold; + std::unique_ptr<weld::Button> mxDash; + std::unique_ptr<weld::Button> mxDashLong; + std::unique_ptr<weld::Button> mxDashDot; + std::unique_ptr<weld::Button> mxDashDotDot; + std::unique_ptr<weld::Button> mxWave; + std::unique_ptr<weld::Button> mxMoreOptions; + + rtl::Reference<TextUnderlinePopup> mxControl; + + FontLineStyle getLineStyle(const weld::Button& rButton) const; + + DECL_LINK(PBClickHdl, weld::Button&, void); +}; +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/text/TextUnderlinePopup.cxx b/svx/source/sidebar/text/TextUnderlinePopup.cxx new file mode 100644 index 000000000..75529f297 --- /dev/null +++ b/svx/source/sidebar/text/TextUnderlinePopup.cxx @@ -0,0 +1,82 @@ +/* -*- 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 <TextUnderlinePopup.hxx> +#include "TextUnderlineControl.hxx" +#include <vcl/toolbox.hxx> + +using namespace svx; + +TextUnderlinePopup::TextUnderlinePopup( + const css::uno::Reference<css::uno::XComponentContext>& rContext) + : PopupWindowController(rContext, nullptr, OUString()) +{ +} + +TextUnderlinePopup::~TextUnderlinePopup() {} + +void TextUnderlinePopup::initialize(const css::uno::Sequence<css::uno::Any>& rArguments) +{ + PopupWindowController::initialize(rArguments); + + if (m_pToolbar) + { + mxPopoverContainer.reset(new ToolbarPopupContainer(m_pToolbar)); + m_pToolbar->set_item_popover(m_aCommandURL.toUtf8(), mxPopoverContainer->getTopLevel()); + } + + ToolBox* pToolBox = nullptr; + ToolBoxItemId nId; + if (getToolboxId(nId, &pToolBox) && pToolBox->GetItemCommand(nId) == m_aCommandURL) + pToolBox->SetItemBits(nId, ToolBoxItemBits::DROPDOWN | pToolBox->GetItemBits(nId)); +} + +std::unique_ptr<WeldToolbarPopup> TextUnderlinePopup::weldPopupWindow() +{ + return std::make_unique<TextUnderlineControl>(this, m_pToolbar); +} + +VclPtr<vcl::Window> TextUnderlinePopup::createVclPopupWindow(vcl::Window* pParent) +{ + mxInterimPopover = VclPtr<InterimToolbarPopup>::Create( + getFrameInterface(), pParent, + std::make_unique<TextUnderlineControl>(this, pParent->GetFrameWeld())); + + mxInterimPopover->Show(); + + return mxInterimPopover; +} + +OUString TextUnderlinePopup::getImplementationName() +{ + return "com.sun.star.comp.svx.UnderlineToolBoxControl"; +} + +css::uno::Sequence<OUString> TextUnderlinePopup::getSupportedServiceNames() +{ + return { "com.sun.star.frame.ToolbarController" }; +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +com_sun_star_comp_svx_UnderlineToolBoxControl_get_implementation( + css::uno::XComponentContext* rContext, css::uno::Sequence<css::uno::Any> const&) +{ + return cppu::acquire(new TextUnderlinePopup(rContext)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sidebar/textcolumns/TextColumnsPropertyPanel.cxx b/svx/source/sidebar/textcolumns/TextColumnsPropertyPanel.cxx new file mode 100644 index 000000000..2a06c5705 --- /dev/null +++ b/svx/source/sidebar/textcolumns/TextColumnsPropertyPanel.cxx @@ -0,0 +1,118 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 "TextColumnsPropertyPanel.hxx" + +#include <sfx2/app.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/objsh.hxx> +#include <svl/itempool.hxx> +#include <svtools/unitconv.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/svddef.hxx> +#include <svx/svxids.hrc> + +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +namespace +{ +MapUnit GetUnit(const SfxBindings* pBindings, sal_uInt16 nWhich) +{ + assert(pBindings); + + SfxObjectShell* pSh = nullptr; + if (auto pShell = pBindings->GetDispatcher()->GetShell(0)) + pSh = pShell->GetObjectShell(); + if (!pSh) + pSh = SfxObjectShell::Current(); + SfxItemPool& rPool = pSh ? pSh->GetPool() : SfxGetpApp()->GetPool(); + return rPool.GetMetric(nWhich); +} +} + +namespace svx::sidebar +{ +TextColumnsPropertyPanel::TextColumnsPropertyPanel(weld::Widget* pParent, SfxBindings* pBindings) + : PanelLayout(pParent, "TextColumnsPropertyPanel", "svx/ui/sidebartextcolumnspanel.ui") + , mpBindings(pBindings) + , m_xColumnsNumber(m_xBuilder->weld_spin_button("FLD_COL_NUMBER")) + , m_xColumnsSpacing(m_xBuilder->weld_metric_spin_button("MTR_FLD_COL_SPACING", FieldUnit::CM)) + , maColumnsNumberController(SID_ATTR_TEXTCOLUMNS_NUMBER, *pBindings, *this) + , maColumnsSpacingController(SID_ATTR_TEXTCOLUMNS_SPACING, *pBindings, *this) +{ + m_xColumnsNumber->connect_value_changed( + LINK(this, TextColumnsPropertyPanel, ModifyColumnsNumberHdl)); + m_xColumnsSpacing->connect_value_changed( + LINK(this, TextColumnsPropertyPanel, ModifyColumnsSpacingHdl)); +} + +TextColumnsPropertyPanel::~TextColumnsPropertyPanel() +{ + maColumnsSpacingController.dispose(); + maColumnsNumberController.dispose(); + + m_xColumnsSpacing.reset(); + m_xColumnsNumber.reset(); +} + +IMPL_LINK_NOARG(TextColumnsPropertyPanel, ModifyColumnsNumberHdl, weld::SpinButton&, void) +{ + SfxInt16Item aItem(SDRATTR_TEXTCOLUMNS_NUMBER, m_xColumnsNumber->get_value()); + mpBindings->GetDispatcher()->ExecuteList(SID_ATTR_TEXTCOLUMNS_NUMBER, SfxCallMode::RECORD, + { &aItem }); +} + +IMPL_LINK_NOARG(TextColumnsPropertyPanel, ModifyColumnsSpacingHdl, weld::MetricSpinButton&, void) +{ + const MapUnit aUnit = GetUnit(mpBindings, SDRATTR_TEXTCOLUMNS_SPACING); + SdrMetricItem aItem(SDRATTR_TEXTCOLUMNS_SPACING, GetCoreValue(*m_xColumnsSpacing, aUnit)); + mpBindings->GetDispatcher()->ExecuteList(SID_ATTR_TEXTCOLUMNS_SPACING, SfxCallMode::RECORD, + { &aItem }); +} + +void TextColumnsPropertyPanel::NotifyItemUpdate(sal_uInt16 nSID, SfxItemState eState, + const SfxPoolItem* pState) +{ + switch (nSID) + { + case SID_ATTR_TEXTCOLUMNS_NUMBER: + if (eState >= SfxItemState::DEFAULT) + { + if (const auto pItem = dynamic_cast<const SfxInt16Item*>(pState)) + m_xColumnsNumber->set_value(pItem->GetValue()); + } + break; + case SID_ATTR_TEXTCOLUMNS_SPACING: + if (eState >= SfxItemState::DEFAULT) + { + const MapUnit aUnit = GetUnit(mpBindings, SDRATTR_TEXTCOLUMNS_SPACING); + if (const auto pItem = dynamic_cast<const SdrMetricItem*>(pState)) + SetMetricValue(*m_xColumnsSpacing, pItem->GetValue(), aUnit); + } + break; + } +} + +std::unique_ptr<PanelLayout> TextColumnsPropertyPanel::Create(weld::Widget* pParent, + SfxBindings* pBindings) +{ + if (pParent == nullptr) + throw css::lang::IllegalArgumentException( + "no parent Window given to TextColumnsPropertyPanel::Create", nullptr, 0); + if (pBindings == nullptr) + throw css::lang::IllegalArgumentException( + "no SfxBindings given to TextColumnsPropertyPanel::Create", nullptr, 2); + + return std::make_unique<TextColumnsPropertyPanel>(pParent, pBindings); +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/svx/source/sidebar/textcolumns/TextColumnsPropertyPanel.hxx b/svx/source/sidebar/textcolumns/TextColumnsPropertyPanel.hxx new file mode 100644 index 000000000..e9c27fcc6 --- /dev/null +++ b/svx/source/sidebar/textcolumns/TextColumnsPropertyPanel.hxx @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#pragma once + +#include <sfx2/sidebar/ControllerItem.hxx> +#include <sfx2/sidebar/PanelLayout.hxx> + +class ColorListBox; + +namespace svx::sidebar +{ +class TextColumnsPropertyPanel : public PanelLayout, + public ::sfx2::sidebar::ControllerItem::ItemUpdateReceiverInterface +{ +public: + TextColumnsPropertyPanel(weld::Widget* pParent, SfxBindings* pBindings); + virtual ~TextColumnsPropertyPanel() override; + + static std::unique_ptr<PanelLayout> Create(weld::Widget* pParent, SfxBindings* pBindings); + + virtual void NotifyItemUpdate(const sal_uInt16 nSId, const SfxItemState eState, + const SfxPoolItem* pState) override; + + virtual void GetControlState(const sal_uInt16 /*nSId*/, + boost::property_tree::ptree& /*rState*/) override{}; + +private: + SfxBindings* mpBindings; + + std::unique_ptr<weld::SpinButton> m_xColumnsNumber; + std::unique_ptr<weld::MetricSpinButton> m_xColumnsSpacing; + + sfx2::sidebar::ControllerItem maColumnsNumberController; + sfx2::sidebar::ControllerItem maColumnsSpacingController; + + DECL_LINK(ModifyColumnsNumberHdl, weld::SpinButton&, void); + DECL_LINK(ModifyColumnsSpacingHdl, weld::MetricSpinButton&, void); +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/svx/source/sidebar/tools/ValueSetWithTextControl.cxx b/svx/source/sidebar/tools/ValueSetWithTextControl.cxx new file mode 100644 index 000000000..1b6ca2d42 --- /dev/null +++ b/svx/source/sidebar/tools/ValueSetWithTextControl.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/. + * + * 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 <svx/sidebar/ValueSetWithTextControl.hxx> +#include <sfx2/sidebar/Theme.hxx> + +#include <i18nlangtag/mslangid.hxx> +#include <svtools/valueset.hxx> +#include <vcl/event.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +namespace svx::sidebar { + +ValueSetWithTextControl::ValueSetWithTextControl() + : ValueSet(nullptr) +{ +} + +void ValueSetWithTextControl::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + ValueSet::SetDrawingArea(pDrawingArea); + + Size aSize(250, 300); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); + + SetColCount(); +} + +void ValueSetWithTextControl::AddItem( + const OUString& rItemText, + const OUString& rItemText2 ) +{ + ValueSetWithTextItem aItem; + aItem.maItemText = rItemText; + aItem.maItemText2 = rItemText2; + + maItems.push_back( aItem ); + + InsertItem( maItems.size() ); + SetItemText( maItems.size(), rItemText ); +} + +void ValueSetWithTextControl::UserDraw( const UserDrawEvent& rUDEvt ) +{ + const tools::Rectangle aRect = rUDEvt.GetRect(); + vcl::RenderContext* pDev = rUDEvt.GetRenderContext(); + pDev->Push(); + const sal_uInt16 nItemId = rUDEvt.GetItemId(); + + const tools::Long nRectHeight = aRect.GetHeight(); + + vcl::Font aFont(OutputDevice::GetDefaultFont(DefaultFontType::UI_SANS, MsLangId::getConfiguredSystemLanguage(), GetDefaultFontFlags::OnlyOne)); + { + Size aSize = aFont.GetFontSize(); + aSize.setHeight( (nRectHeight*4)/9 ); + aFont.SetFontSize( aSize ); + } + + { + //draw background + if ( GetSelectedItemId() == nItemId ) + { + tools::Rectangle aBackRect = aRect; + aBackRect.AdjustTop(3 ); + aBackRect.AdjustBottom( -2 ); + pDev->SetFillColor( sfx2::sidebar::Theme::GetColor( sfx2::sidebar::Theme::Color_Highlight ) ); + pDev->DrawRect(aBackRect); + } + else + { + pDev->SetFillColor( COL_TRANSPARENT ); + pDev->DrawRect(aRect); + } + + if ( GetSelectedItemId() == nItemId ) + { + aFont.SetColor( sfx2::sidebar::Theme::GetColor( sfx2::sidebar::Theme::Color_HighlightText ) ); + } + else + { + aFont.SetColor( Application::GetSettings().GetStyleSettings().GetFieldTextColor() ); + } + + tools::Rectangle aStrRect = aRect; + aStrRect.AdjustTop(nRectHeight/4 ); + aStrRect.AdjustBottom( -(nRectHeight/4) ); + + const tools::Long nRectWidth = aRect.GetWidth(); + aStrRect.AdjustLeft(8 ); + aStrRect.AdjustRight( -((nRectWidth*2)/3) ); + pDev->SetFont(aFont); + pDev->DrawText(aStrRect, maItems[nItemId-1].maItemText, DrawTextFlags::EndEllipsis); + aStrRect.AdjustLeft(nRectWidth/3 ); + aStrRect.AdjustRight((nRectWidth*2)/3 ); + pDev->DrawText(aStrRect, maItems[nItemId-1].maItemText2, DrawTextFlags::EndEllipsis); + } + + Invalidate( aRect ); + pDev->Pop(); +} + +} // end of namespace svx::sidebar + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |