diff options
Diffstat (limited to 'reportdesign/source/ui/misc')
| -rw-r--r-- | reportdesign/source/ui/misc/ColorListener.cxx | 96 | ||||
| -rw-r--r-- | reportdesign/source/ui/misc/FunctionHelper.cxx | 268 | ||||
| -rw-r--r-- | reportdesign/source/ui/misc/RptUndo.cxx | 385 | ||||
| -rw-r--r-- | reportdesign/source/ui/misc/UITools.cxx | 1064 | ||||
| -rw-r--r-- | reportdesign/source/ui/misc/statusbarcontroller.cxx | 222 |
5 files changed, 2035 insertions, 0 deletions
diff --git a/reportdesign/source/ui/misc/ColorListener.cxx b/reportdesign/source/ui/misc/ColorListener.cxx new file mode 100644 index 000000000..48fa67902 --- /dev/null +++ b/reportdesign/source/ui/misc/ColorListener.cxx @@ -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 . + */ +#include <ColorListener.hxx> +#include <svl/hint.hxx> +#include <vcl/settings.hxx> +#include <vcl/event.hxx> + +#include <strings.hxx> + + +namespace rptui +{ + +OColorListener::OColorListener(vcl::Window* _pParent ,const OUString& _sColorEntry) +: Window(_pParent) +,m_sColorEntry(_sColorEntry) +,m_nColor(COL_LIGHTBLUE) +,m_bCollapsed(false) +,m_bMarked(false) +{ + StartListening(m_aExtendedColorConfig); + m_nColor = m_aExtendedColorConfig.GetColorValue(CFG_REPORTDESIGNER,m_sColorEntry).getColor(); + m_nTextBoundaries = m_aColorConfig.GetColorValue(::svtools::DOCBOUNDARIES).nColor; +} + +OColorListener::~OColorListener() +{ + disposeOnce(); +} + +void OColorListener::dispose() +{ + EndListening(m_aExtendedColorConfig); + vcl::Window::dispose(); +} + +void OColorListener::Notify(SfxBroadcaster & /*rBc*/, SfxHint const & rHint) +{ + if (rHint.GetId() == SfxHintId::ColorsChanged) + { + m_nColor = m_aExtendedColorConfig.GetColorValue(CFG_REPORTDESIGNER,m_sColorEntry).getColor(); + m_nTextBoundaries = m_aColorConfig.GetColorValue(::svtools::DOCBOUNDARIES).nColor; + Invalidate(InvalidateFlags::NoChildren|InvalidateFlags::NoErase); + } +} + +void OColorListener::DataChanged( const DataChangedEvent& rDCEvt ) +{ + Window::DataChanged( rDCEvt ); + + if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) && + (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) ) + { + ImplInitSettings(); + Invalidate(); + } +} + +void OColorListener::setCollapsed(bool _bCollapsed) +{ + if ( m_bCollapsed != _bCollapsed ) + { + m_bCollapsed = _bCollapsed; + m_aCollapsedLink.Call(*this); + } +} + +void OColorListener::setMarked(bool _bMark) +{ + if ( m_bMarked != _bMark) + { + m_bMarked = _bMark; + Invalidate(InvalidateFlags::NoChildren|InvalidateFlags::NoErase); + } +} + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/reportdesign/source/ui/misc/FunctionHelper.cxx b/reportdesign/source/ui/misc/FunctionHelper.cxx new file mode 100644 index 000000000..547567178 --- /dev/null +++ b/reportdesign/source/ui/misc/FunctionHelper.cxx @@ -0,0 +1,268 @@ +/* -*- 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 <FunctionHelper.hxx> + +#include <o3tl/safeint.hxx> +#include <tools/diagnose_ex.h> +#include <formula/funcvarargs.h> + + +namespace rptui +{ + + using namespace ::com::sun::star; + +FunctionManager::FunctionManager(const uno::Reference< report::meta::XFunctionManager>& _xMgr) +: m_xMgr(_xMgr) +{ +} +FunctionManager::~FunctionManager() +{ +} +sal_Unicode FunctionManager::getSingleToken(const formula::IFunctionManager::EToken _eToken) const +{ + switch(_eToken) + { + case eOk: + return '('; + case eClose: + return ')'; + case eSep: + return ';'; + case eArrayOpen: + return '{'; + case eArrayClose: + return '}'; + } + return 0; +} + +sal_uInt32 FunctionManager::getCount() const +{ + return m_xMgr->getCount(); +} + +const formula::IFunctionCategory* FunctionManager::getCategory(sal_uInt32 _nPos) const +{ + if ( _nPos >= m_aCategoryIndex.size() ) + { + uno::Reference< report::meta::XFunctionCategory> xCategory = m_xMgr->getCategory(_nPos); + auto pCategory = std::make_shared<FunctionCategory>(this,_nPos + 1,xCategory); + m_aCategoryIndex.push_back( m_aCategories.emplace(xCategory->getName(),pCategory).first ); + } + return m_aCategoryIndex[_nPos]->second.get(); +} + +void FunctionManager::fillLastRecentlyUsedFunctions(::std::vector< const formula::IFunctionDescription*>& /*_rLastRUFunctions*/) const +{ +} + +std::shared_ptr< FunctionDescription > FunctionManager::get(const uno::Reference< report::meta::XFunctionDescription>& _xFunctionDescription) const +{ + std::shared_ptr< FunctionDescription > pDesc; + if ( _xFunctionDescription.is() ) + { + const OUString sFunctionName = _xFunctionDescription->getName(); + TFunctionsMap::const_iterator aFunctionFind = m_aFunctions.find(sFunctionName); + if ( aFunctionFind == m_aFunctions.end() ) + { + const uno::Reference< report::meta::XFunctionCategory> xCategory = _xFunctionDescription->getCategory(); + const OUString sCategoryName = xCategory->getName(); + TCategoriesMap::iterator aCategoryFind = m_aCategories.find(sCategoryName); + if ( aCategoryFind == m_aCategories.end() ) + { + aCategoryFind = m_aCategories.emplace(sCategoryName,std::make_shared< FunctionCategory > (this,xCategory->getNumber() + 1,xCategory)).first; + m_aCategoryIndex.push_back( aCategoryFind ); + } + aFunctionFind = m_aFunctions.emplace(sFunctionName,std::make_shared<FunctionDescription>(aCategoryFind->second.get(),_xFunctionDescription)).first; + } + pDesc = aFunctionFind->second; + } + return pDesc; +} + +FunctionCategory::FunctionCategory(const FunctionManager* _pFMgr,sal_uInt32 _nPos,const uno::Reference< report::meta::XFunctionCategory>& _xCategory) +: m_xCategory(_xCategory) +,m_nFunctionCount(_xCategory->getCount()) +, m_nNumber(_nPos) +,m_pFunctionManager(_pFMgr) +{ +} + +sal_uInt32 FunctionCategory::getCount() const +{ + return m_nFunctionCount; +} + +const formula::IFunctionDescription* FunctionCategory::getFunction(sal_uInt32 _nPos) const +{ + if ( _nPos >= m_aFunctions.size() && _nPos < m_nFunctionCount ) + { + uno::Reference< report::meta::XFunctionDescription> xFunctionDescription = m_xCategory->getFunction(_nPos); + std::shared_ptr< FunctionDescription > pFunction = m_pFunctionManager->get(xFunctionDescription); + m_aFunctions.push_back( pFunction ); + } + return m_aFunctions[_nPos].get(); +} + +sal_uInt32 FunctionCategory::getNumber() const +{ + return m_nNumber; +} + +OUString FunctionCategory::getName() const +{ + return m_xCategory->getName(); +} + +FunctionDescription::FunctionDescription(const formula::IFunctionCategory* _pFunctionCategory,const uno::Reference< report::meta::XFunctionDescription>& _xFunctionDescription) +: m_xFunctionDescription(_xFunctionDescription) +, m_pFunctionCategory(_pFunctionCategory) +{ + m_aParameter = m_xFunctionDescription->getArguments(); +} +OUString FunctionDescription::getFunctionName() const +{ + return m_xFunctionDescription->getName(); +} + +const formula::IFunctionCategory* FunctionDescription::getCategory() const +{ + return m_pFunctionCategory; +} + +OUString FunctionDescription::getDescription() const +{ + return m_xFunctionDescription->getDescription(); +} + +sal_Int32 FunctionDescription::getSuppressedArgumentCount() const +{ + return m_aParameter.getLength(); +} + +OUString FunctionDescription::getFormula(const ::std::vector< OUString >& _aArguments) const +{ + OUString sFormula; + try + { + sFormula = m_xFunctionDescription->createFormula(uno::Sequence< OUString >(_aArguments.data(), _aArguments.size())); + } + catch(const uno::Exception&) + { + TOOLS_WARN_EXCEPTION( "reportdesign", ""); + } + return sFormula; +} + +void FunctionDescription::fillVisibleArgumentMapping(::std::vector<sal_uInt16>& _rArguments) const +{ + const sal_Int32 nCount = m_aParameter.getLength(); + for(sal_Int32 i = 0;i < nCount; ++i) + { + _rArguments.push_back(i); + } +} + +void FunctionDescription::initArgumentInfo() const +{ +} + +OUString FunctionDescription::getSignature() const +{ + return m_xFunctionDescription->getSignature(); +} + +OString FunctionDescription::getHelpId() const +{ + return OString(); +} + +bool FunctionDescription::isHidden() const +{ + return false; +} + +sal_uInt32 FunctionDescription::getParameterCount() const +{ + return m_aParameter.getLength(); +} + +sal_uInt32 FunctionDescription::getVarArgsStart() const +{ + /* XXX there are no variable number of arguments, are there? Nevertheless + * consider the varargs handling of the Function Wizard and return a value + * within the bounds of parameters. */ + // Don't use defines/constants that could change in future, parameter count + // could be part of an implicit stable API. + // offapi/com/sun/star/report/meta/XFunctionDescription.idl doesn't tell. + const sal_uInt32 nVarArgs30 = 30; // ugly hard coded old VAR_ARGS of formula::ParaWin + const sal_uInt32 nPairedVarArgs60 = 60; // ugly hard coded old PAIRED_VAR_ARGS of formula::ParaWin + const sal_uInt32 nVarArgs255 = 255; // ugly hard coded new VAR_ARGS of formula::ParaWin + const sal_uInt32 nPairedVarArgs510 = 510; // ugly hard coded new PAIRED_VAR_ARGS of formula::ParaWin + sal_uInt32 nLen = m_aParameter.getLength(); + // If the value of VAR_ARGS changes then adapt *and* maintain implicit API + // stability, ie. old code using the old VAR_ARGS and PAIRED_VAR_ARGS + // values must still be handled. It is *not* sufficient to simply change + // the values here. + static_assert(nVarArgs255 == VAR_ARGS && nPairedVarArgs510 == PAIRED_VAR_ARGS, + "VAR_ARGS or PAIRED_VAR_ARGS has unexpected value"); + if (nLen >= nPairedVarArgs510) + nLen -= nPairedVarArgs510; + else if (nLen >= nVarArgs255) + nLen -= nVarArgs255; + else if (nLen >= nPairedVarArgs60) + nLen -= nPairedVarArgs60; + else if (nLen >= nVarArgs30) + nLen -= nVarArgs30; + return nLen ? nLen - 1 : 0; +} + +sal_uInt32 FunctionDescription::getVarArgsLimit() const +{ + return 0; +} + +OUString FunctionDescription::getParameterName(sal_uInt32 _nPos) const +{ + if ( _nPos < o3tl::make_unsigned(m_aParameter.getLength()) ) + return m_aParameter[_nPos].Name; + return OUString(); +} + +OUString FunctionDescription::getParameterDescription(sal_uInt32 _nPos) const +{ + if ( _nPos < o3tl::make_unsigned(m_aParameter.getLength()) ) + return m_aParameter[_nPos].Description; + return OUString(); +} + +bool FunctionDescription::isParameterOptional(sal_uInt32 _nPos) const +{ + if ( _nPos < o3tl::make_unsigned(m_aParameter.getLength()) ) + return m_aParameter[_nPos].IsOptional; + return false; +} + + +} // rptui + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/reportdesign/source/ui/misc/RptUndo.cxx b/reportdesign/source/ui/misc/RptUndo.cxx new file mode 100644 index 000000000..60d0927d6 --- /dev/null +++ b/reportdesign/source/ui/misc/RptUndo.cxx @@ -0,0 +1,385 @@ +/* -*- 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 <RptUndo.hxx> +#include <strings.hxx> +#include <rptui_slotid.hrc> +#include <UITools.hxx> +#include <UndoEnv.hxx> + +#include <dbaccess/IController.hxx> +#include <com/sun/star/report/XSection.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> + +#include <com/sun/star/awt/Point.hpp> +#include <com/sun/star/awt/Size.hpp> +#include <comphelper/propertyvalue.hxx> +#include <comphelper/types.hxx> +#include <svx/unoshape.hxx> +#include <utility> +#include <tools/diagnose_ex.h> + +#include <functional> + +namespace rptui +{ + using namespace ::com::sun::star; + using namespace uno; + using namespace lang; + using namespace beans; + using namespace awt; + using namespace util; + using namespace container; + using namespace report; + + +namespace +{ + void lcl_collectElements(const uno::Reference< report::XSection >& _xSection,::std::vector< uno::Reference< drawing::XShape> >& _rControls) + { + if ( _xSection.is() ) + { + sal_Int32 nCount = _xSection->getCount(); + _rControls.reserve(nCount); + while ( nCount ) + { + uno::Reference< drawing::XShape> xShape(_xSection->getByIndex(nCount-1),uno::UNO_QUERY); + _rControls.push_back(xShape); + _xSection->remove(xShape); + --nCount; + } + } + } + + void lcl_insertElements(const uno::Reference< report::XSection >& _xSection,const ::std::vector< uno::Reference< drawing::XShape> >& _aControls) + { + if ( !_xSection.is() ) + return; + + ::std::vector< uno::Reference< drawing::XShape> >::const_reverse_iterator aIter = _aControls.rbegin(); + ::std::vector< uno::Reference< drawing::XShape> >::const_reverse_iterator aEnd = _aControls.rend(); + for (; aIter != aEnd; ++aIter) + { + try + { + const awt::Point aPos = (*aIter)->getPosition(); + const awt::Size aSize = (*aIter)->getSize(); + _xSection->add(*aIter); + (*aIter)->setPosition( aPos ); + (*aIter)->setSize( aSize ); + } + catch(const uno::Exception&) + { + TOOLS_WARN_EXCEPTION( "reportdesign", "lcl_insertElements"); + } + } + } + + void lcl_setValues(const uno::Reference< report::XSection >& _xSection,const ::std::vector< ::std::pair< OUString ,uno::Any> >& _aValues) + { + if ( !_xSection.is() ) + return; + + for (const auto& [rPropName, rValue] : _aValues) + { + try + { + _xSection->setPropertyValue(rPropName, rValue); + } + catch(const uno::Exception&) + { + TOOLS_WARN_EXCEPTION( "reportdesign", "lcl_setValues"); + } + } + } +} + + +OSectionUndo::OSectionUndo(OReportModel& _rMod + ,sal_uInt16 _nSlot + ,Action _eAction + ,TranslateId pCommentID) +: OCommentUndoAction(_rMod,pCommentID) +,m_eAction(_eAction) +,m_nSlot(_nSlot) +,m_bInserted(false) +{ +} + +OSectionUndo::~OSectionUndo() +{ + if ( m_bInserted ) + return; + + OXUndoEnvironment& rEnv = static_cast< OReportModel& >( rMod ).GetUndoEnv(); + for (uno::Reference<drawing::XShape>& xShape : m_aControls) + { + rEnv.RemoveElement(xShape); + +#if OSL_DEBUG_LEVEL > 0 + SvxShape* pShape = comphelper::getFromUnoTunnel<SvxShape>( xShape ); + SdrObject* pObject = pShape ? pShape->GetSdrObject() : nullptr; + OSL_ENSURE( pShape && pShape->HasSdrObjectOwnership() && pObject && !pObject->IsInserted(), + "OSectionUndo::~OSectionUndo: inconsistency in the shape/object ownership!" ); +#endif + try + { + comphelper::disposeComponent(xShape); + } + catch(const uno::Exception &) + { + TOOLS_WARN_EXCEPTION( "reportdesign", ""); + } + } +} + +void OSectionUndo::collectControls(const uno::Reference< report::XSection >& _xSection) +{ + m_aControls.clear(); + try + { + // copy all properties for restoring + uno::Reference< beans::XPropertySetInfo> xInfo = _xSection->getPropertySetInfo(); + const uno::Sequence< beans::Property> aSeq = xInfo->getProperties(); + for(const beans::Property& rProp : aSeq) + { + if ( 0 == (rProp.Attributes & beans::PropertyAttribute::READONLY) ) + m_aValues.emplace_back(rProp.Name,_xSection->getPropertyValue(rProp.Name)); + } + lcl_collectElements(_xSection,m_aControls); + } + catch(uno::Exception&) + { + } +} + +void OSectionUndo::Undo() +{ + try + { + switch ( m_eAction ) + { + case Inserted: + implReRemove(); + break; + + case Removed: + implReInsert(); + break; + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "reportdesign", "OSectionUndo::Undo" ); + } +} + +void OSectionUndo::Redo() +{ + try + { + switch ( m_eAction ) + { + case Inserted: + implReInsert(); + break; + + case Removed: + implReRemove(); + break; + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "reportdesign", "OSectionUndo::Redo" ); + } +} + +OReportSectionUndo::OReportSectionUndo( + OReportModel& _rMod, sal_uInt16 _nSlot, + ::std::function<uno::Reference<report::XSection>(OReportHelper*)> _pMemberFunction, + const uno::Reference<report::XReportDefinition>& _xReport, Action _eAction) + : OSectionUndo(_rMod, _nSlot, _eAction, {}) + , m_aReportHelper(_xReport) + , m_pMemberFunction(std::move(_pMemberFunction)) +{ + if( m_eAction == Removed ) + collectControls(m_pMemberFunction(&m_aReportHelper)); +} + +OReportSectionUndo::~OReportSectionUndo() +{ +} + +void OReportSectionUndo::implReInsert( ) +{ + const uno::Sequence< beans::PropertyValue > aArgs; + m_pController->executeChecked(m_nSlot,aArgs); + uno::Reference< report::XSection > xSection = m_pMemberFunction(&m_aReportHelper); + lcl_insertElements(xSection,m_aControls); + lcl_setValues(xSection,m_aValues); + m_bInserted = true; +} + +void OReportSectionUndo::implReRemove( ) +{ + if( m_eAction == Removed ) + collectControls(m_pMemberFunction(&m_aReportHelper)); + const uno::Sequence< beans::PropertyValue > aArgs; + m_pController->executeChecked(m_nSlot,aArgs); + m_bInserted = false; +} + +OGroupSectionUndo::OGroupSectionUndo( + OReportModel& _rMod, sal_uInt16 _nSlot, + ::std::function<uno::Reference<report::XSection>(OGroupHelper*)> _pMemberFunction, + const uno::Reference<report::XGroup>& _xGroup, Action _eAction, TranslateId pCommentID) + : OSectionUndo(_rMod, _nSlot, _eAction, pCommentID) + , m_aGroupHelper(_xGroup) + , m_pMemberFunction(std::move(_pMemberFunction)) +{ + if( m_eAction == Removed ) + { + uno::Reference< report::XSection > xSection = m_pMemberFunction(&m_aGroupHelper); + if ( xSection.is() ) + m_sName = xSection->getName(); + collectControls(xSection); + } +} + +OUString OGroupSectionUndo::GetComment() const +{ + if ( m_sName.isEmpty() ) + { + try + { + uno::Reference< report::XSection > xSection = const_cast<OGroupSectionUndo*>(this)->m_pMemberFunction(&const_cast<OGroupSectionUndo*>(this)->m_aGroupHelper); + + if ( xSection.is() ) + m_sName = xSection->getName(); + } + catch (const uno::Exception&) + { + } + } + return m_strComment + m_sName; +} + +void OGroupSectionUndo::implReInsert( ) +{ + const OUString aHeaderFooterOnName(SID_GROUPHEADER_WITHOUT_UNDO == m_nSlot? OUString(PROPERTY_HEADERON) : OUString(PROPERTY_FOOTERON)); + uno::Sequence< beans::PropertyValue > aArgs{ + comphelper::makePropertyValue(aHeaderFooterOnName, true), + comphelper::makePropertyValue(PROPERTY_GROUP, m_aGroupHelper.getGroup()) + }; + m_pController->executeChecked(m_nSlot,aArgs); + + uno::Reference< report::XSection > xSection = m_pMemberFunction(&m_aGroupHelper); + lcl_insertElements(xSection,m_aControls); + lcl_setValues(xSection,m_aValues); + m_bInserted = true; +} + +void OGroupSectionUndo::implReRemove( ) +{ + if( m_eAction == Removed ) + collectControls(m_pMemberFunction(&m_aGroupHelper)); + + const OUString aHeaderFooterOnName(SID_GROUPHEADER_WITHOUT_UNDO == m_nSlot? OUString(PROPERTY_HEADERON) : OUString(PROPERTY_FOOTERON)); + uno::Sequence< beans::PropertyValue > aArgs{ + comphelper::makePropertyValue(aHeaderFooterOnName, false), + comphelper::makePropertyValue(PROPERTY_GROUP, m_aGroupHelper.getGroup()) + }; + + m_pController->executeChecked(m_nSlot,aArgs); + m_bInserted = false; +} + + +OGroupUndo::OGroupUndo(OReportModel& _rMod + ,TranslateId pCommentID + ,Action _eAction + ,const uno::Reference< report::XGroup>& _xGroup + ,const uno::Reference< report::XReportDefinition >& _xReportDefinition) +: OCommentUndoAction(_rMod,pCommentID) +,m_xGroup(_xGroup) +,m_xReportDefinition(_xReportDefinition) +,m_eAction(_eAction) +{ + m_nLastPosition = getPositionInIndexAccess(m_xReportDefinition->getGroups(),m_xGroup); +} + +void OGroupUndo::implReInsert( ) +{ + try + { + m_xReportDefinition->getGroups()->insertByIndex(m_nLastPosition,uno::Any(m_xGroup)); + } + catch(uno::Exception&) + { + TOOLS_WARN_EXCEPTION( "reportdesign", "Exception caught while undoing remove group"); + } +} + +void OGroupUndo::implReRemove( ) +{ + try + { + m_xReportDefinition->getGroups()->removeByIndex(m_nLastPosition); + } + catch(uno::Exception&) + { + TOOLS_WARN_EXCEPTION( "reportdesign", "Exception caught while redoing remove group"); + } +} + +void OGroupUndo::Undo() +{ + switch ( m_eAction ) + { + case Inserted: + implReRemove(); + break; + + case Removed: + implReInsert(); + break; + } + +} + +void OGroupUndo::Redo() +{ + switch ( m_eAction ) + { + case Inserted: + implReInsert(); + break; + + case Removed: + implReRemove(); + break; + } +} + + +} // rptui + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/reportdesign/source/ui/misc/UITools.cxx b/reportdesign/source/ui/misc/UITools.cxx new file mode 100644 index 000000000..9e00b4ad5 --- /dev/null +++ b/reportdesign/source/ui/misc/UITools.cxx @@ -0,0 +1,1064 @@ +/* -*- 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 <toolkit/helper/convert.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <SectionView.hxx> +#include <UITools.hxx> +#include <Formula.hxx> +#include <FunctionHelper.hxx> +#include <reportformula.hxx> + +#include <tools/diagnose_ex.h> + +#include <vcl/settings.hxx> +#include <vcl/syswin.hxx> +#include <vcl/svapp.hxx> +#include <vcl/unohelp.hxx> +#include <vcl/window.hxx> + +#include <com/sun/star/lang/NullPointerException.hpp> +#include <com/sun/star/beans/NamedValue.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <svx/svdpool.hxx> + +#include <editeng/charscaleitem.hxx> +#include <editeng/brushitem.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/emphasismarkitem.hxx> +#include <editeng/postitem.hxx> +#include <editeng/udlnitem.hxx> +#include <editeng/crossedoutitem.hxx> +#include <editeng/contouritem.hxx> +#include <editeng/langitem.hxx> +#include <editeng/wghtitem.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/shdditem.hxx> +#include <editeng/escapementitem.hxx> +#include <editeng/wrlmitem.hxx> +#include <editeng/cmapitem.hxx> +#include <editeng/kernitem.hxx> +#include <editeng/blinkitem.hxx> +#include <editeng/flstitem.hxx> +#include <editeng/autokernitem.hxx> +#include <editeng/colritem.hxx> +#include <editeng/justifyitem.hxx> +#include <svx/drawitem.hxx> +#include <editeng/twolinesitem.hxx> +#include <editeng/charreliefitem.hxx> +#include <editeng/charrotateitem.hxx> +#include <editeng/charhiddenitem.hxx> +#include <editeng/memberids.h> +#include <svx/xgrscit.hxx> +#include <svx/svditer.hxx> +#include <svx/xtable.hxx> +#include <svx/svdview.hxx> +#include <svx/svdpage.hxx> +#include <svx/svxdlg.hxx> +#include <svx/unoprov.hxx> +#include <svx/svxids.hrc> + +#include <unotools/charclass.hxx> +#include <svtools/ctrltool.hxx> +#include <svl/itempool.hxx> +#include <svl/itemset.hxx> +#include <svl/sharedstringpool.hxx> + +#include <comphelper/propmultiplex.hxx> +#include <comphelper/namedvaluecollection.hxx> + +#include <connectivity/dbexception.hxx> +#include <connectivity/dbtools.hxx> + +#include <com/sun/star/style/VerticalAlignment.hpp> +#include <com/sun/star/report/XShape.hpp> +#include <com/sun/star/sdb/XParametersSupplier.hpp> +#include <com/sun/star/sdb/SQLContext.hpp> +#include <i18nlangtag/languagetag.hxx> +#include <dlgpage.hxx> +#include <strings.hxx> +#include <core_resource.hxx> +#include <RptObject.hxx> +#include <RptDef.hxx> +#include <strings.hrc> +#include <ReportDefinition.hxx> +#include <RptModel.hxx> + +#include <svx/xflbckit.hxx> +#include <svx/xflbmpit.hxx> +#include <svx/xflbmsli.hxx> +#include <svx/xflbmsxy.hxx> +#include <svx/xflbmtit.hxx> +#include <svx/xflboxy.hxx> +#include <svx/xflbstit.hxx> +#include <svx/xflbtoxy.hxx> + +#include <svx/xbtmpit.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xfltrit.hxx> +#include <svx/xflclit.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xflftrit.hxx> +#include <svx/xsflclit.hxx> + +/// Note that we deliberately overlap an existing item id, so that we can have contiguous item ids for +/// the static defaults. +#define ITEMID_FIRST XATTR_FILL_LAST + +#define ITEMID_FONT TypedWhichId<SvxFontItem>(ITEMID_FIRST) +#define ITEMID_FONTHEIGHT TypedWhichId<SvxFontHeightItem>(ITEMID_FIRST + 1) +#define ITEMID_LANGUAGE TypedWhichId<SvxLanguageItem>(ITEMID_FIRST + 2) + +#define ITEMID_POSTURE TypedWhichId<SvxPostureItem>(ITEMID_FIRST + 3) +#define ITEMID_WEIGHT TypedWhichId<SvxWeightItem>(ITEMID_FIRST + 4) +#define ITEMID_SHADOWED TypedWhichId<SvxShadowedItem>(ITEMID_FIRST + 5) +#define ITEMID_WORDLINEMODE TypedWhichId<SvxWordLineModeItem>(ITEMID_FIRST + 6) +#define ITEMID_CONTOUR TypedWhichId<SvxContourItem>(ITEMID_FIRST + 7) +#define ITEMID_CROSSEDOUT TypedWhichId<SvxCrossedOutItem>(ITEMID_FIRST + 8) +#define ITEMID_UNDERLINE TypedWhichId<SvxUnderlineItem>(ITEMID_FIRST + 9) + +#define ITEMID_COLOR TypedWhichId<SvxColorItem>(ITEMID_FIRST + 10) +#define ITEMID_KERNING TypedWhichId<SvxKerningItem>(ITEMID_FIRST + 11) +#define ITEMID_CASEMAP TypedWhichId<SvxCaseMapItem>(ITEMID_FIRST + 12) + +#define ITEMID_ESCAPEMENT TypedWhichId<SvxEscapementItem>(ITEMID_FIRST + 13) +#define ITEMID_FONTLIST ITEMID_FIRST + 14 +#define ITEMID_AUTOKERN TypedWhichId<SvxAutoKernItem>(ITEMID_FIRST + 15) +#define ITEMID_COLOR_TABLE TypedWhichId<SvxColorListItem>(ITEMID_FIRST + 16) +#define ITEMID_BLINK TypedWhichId<SvxBlinkItem>(ITEMID_FIRST + 17) +#define ITEMID_EMPHASISMARK TypedWhichId<SvxEmphasisMarkItem>(ITEMID_FIRST + 18) +#define ITEMID_TWOLINES TypedWhichId<SvxTwoLinesItem>(ITEMID_FIRST + 19) +#define ITEMID_CHARROTATE TypedWhichId<SvxCharRotateItem>(ITEMID_FIRST + 20) +#define ITEMID_CHARSCALE_W TypedWhichId<SvxCharScaleWidthItem>(ITEMID_FIRST + 21) +#define ITEMID_CHARRELIEF TypedWhichId<SvxCharReliefItem>(ITEMID_FIRST + 22) +#define ITEMID_CHARHIDDEN TypedWhichId<SvxCharHiddenItem>(ITEMID_FIRST + 23) +#define ITEMID_BRUSH TypedWhichId<SvxBrushItem>(ITEMID_FIRST + 24) +#define ITEMID_HORJUSTIFY TypedWhichId<SvxHorJustifyItem>(ITEMID_FIRST + 25) +#define ITEMID_VERJUSTIFY TypedWhichId<SvxVerJustifyItem>(ITEMID_FIRST + 26) +#define ITEMID_FONT_ASIAN TypedWhichId<SvxFontItem>(ITEMID_FIRST + 27) +#define ITEMID_FONTHEIGHT_ASIAN TypedWhichId<SvxFontHeightItem>(ITEMID_FIRST + 28) +#define ITEMID_LANGUAGE_ASIAN TypedWhichId<SvxLanguageItem>(ITEMID_FIRST + 29) +#define ITEMID_POSTURE_ASIAN TypedWhichId<SvxPostureItem>(ITEMID_FIRST + 30) +#define ITEMID_WEIGHT_ASIAN TypedWhichId<SvxWeightItem>(ITEMID_FIRST + 31) +#define ITEMID_FONT_COMPLEX TypedWhichId<SvxFontItem>(ITEMID_FIRST + 32) +#define ITEMID_FONTHEIGHT_COMPLEX TypedWhichId<SvxFontHeightItem>(ITEMID_FIRST + 33) +#define ITEMID_LANGUAGE_COMPLEX TypedWhichId<SvxLanguageItem>(ITEMID_FIRST + 34) +#define ITEMID_POSTURE_COMPLEX TypedWhichId<SvxPostureItem>(ITEMID_FIRST + 35) +#define ITEMID_WEIGHT_COMPLEX TypedWhichId<SvxWeightItem>(ITEMID_FIRST + 36) + +#define WESTERN 0 +#define ASIAN 1 +#define COMPLEX 2 + +namespace rptui +{ +using namespace ::com::sun::star; +using namespace formula; + +void adjustSectionName(const uno::Reference< report::XGroup >& _xGroup,sal_Int32 _nPos) +{ + OSL_ENSURE(_xGroup.is(),"Group is NULL -> GPF"); + if ( _xGroup->getHeaderOn() && _xGroup->getHeader()->getName().isEmpty() ) + { + OUString sName = RptResId(RID_STR_GROUPHEADER) + OUString::number(_nPos); + _xGroup->getHeader()->setName(sName); + } + + if ( _xGroup->getFooterOn() && _xGroup->getFooter()->getName().isEmpty() ) + { + OUString sName = RptResId(RID_STR_GROUPFOOTER) + OUString::number(_nPos); + _xGroup->getFooter()->setName(sName); + } +} + +::rtl::Reference< comphelper::OPropertyChangeMultiplexer> addStyleListener(const uno::Reference< report::XReportDefinition >& _xReportDefinition,::comphelper::OPropertyChangeListener* _pListener) +{ + ::rtl::Reference< comphelper::OPropertyChangeMultiplexer> pRet; + if ( _xReportDefinition.is() ) + { + uno::Reference<beans::XPropertySet> xPageStyle(getUsedStyle(_xReportDefinition),uno::UNO_QUERY); + if ( xPageStyle.is() ) + { + pRet = new comphelper::OPropertyChangeMultiplexer(_pListener,xPageStyle); + pRet->addProperty(PROPERTY_LEFTMARGIN); + pRet->addProperty(PROPERTY_RIGHTMARGIN); + pRet->addProperty(PROPERTY_PAPERSIZE); + pRet->addProperty(PROPERTY_BACKCOLOR); + } + } + return pRet; +} + + +namespace +{ + + vcl::Font lcl_getReportControlFont( const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat, awt::FontDescriptor& _out_rControlFont ,sal_uInt16 _nWichFont) + { + if ( !_rxReportControlFormat.is() ) + throw uno::RuntimeException(); + + switch(_nWichFont) + { + case WESTERN: + _out_rControlFont = _rxReportControlFormat->getFontDescriptor(); + break; + case ASIAN: + _out_rControlFont = _rxReportControlFormat->getFontDescriptorAsian(); + break; + case COMPLEX: + _out_rControlFont = _rxReportControlFormat->getFontDescriptorComplex(); + break; + + } + + vcl::Font aDefaultFont = Application::GetDefaultDevice()->GetSettings().GetStyleSettings().GetAppFont(); + return VCLUnoHelper::CreateFont( _out_rControlFont, aDefaultFont ); + } + + + vcl::Font lcl_getReportControlFont( const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat,sal_uInt16 _nWhich ) + { + awt::FontDescriptor aAwtFont; + return lcl_getReportControlFont( _rxReportControlFormat, aAwtFont, _nWhich ); + } + + vcl::Font lcl_setFont(const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat, + SfxItemSet& _rItemSet,sal_uInt16 _nWhich,sal_uInt16 _nFont, sal_uInt16 _nFontHeight,sal_uInt16 _nLanguage,sal_uInt16 _nPosture, sal_uInt16 _nWeight) + { + // fill it + awt::FontDescriptor aControlFont; + const vcl::Font aFont( lcl_getReportControlFont( _rxReportControlFormat, aControlFont,_nWhich ) ); + + SvxFontItem aFontItem(_nFont); + aFontItem.PutValue( uno::Any( aControlFont ), 0 ); + _rItemSet.Put(aFontItem); + + _rItemSet.Put(SvxFontHeightItem(o3tl::convert(aFont.GetFontHeight(), o3tl::Length::pt, o3tl::Length::twip), 100, _nFontHeight)); + lang::Locale aLocale; + switch(_nWhich) + { + default: + aLocale = _rxReportControlFormat->getCharLocale(); + break; + case ASIAN: + aLocale = _rxReportControlFormat->getCharLocaleAsian(); + break; + case COMPLEX: + aLocale = _rxReportControlFormat->getCharLocaleComplex(); + break; + } + + _rItemSet.Put(SvxLanguageItem(LanguageTag(aLocale).makeFallback().getLanguageType(),_nLanguage)); + + _rItemSet.Put(SvxPostureItem(aFont.GetItalic(),_nPosture)); + _rItemSet.Put(SvxWeightItem(aFont.GetWeight(),_nWeight)); + return aFont; + } + + void lcl_fillShapeToItems( const uno::Reference<report::XShape >& _xShape,SfxItemSet& _rItemSet ) + { + uno::Reference< beans::XPropertySetInfo> xInfo = _xShape->getPropertySetInfo(); + SvxUnoPropertyMapProvider aMap; + const SfxItemPropertyMap& rPropertyMap = aMap.GetPropertySet(SVXMAP_CUSTOMSHAPE, SdrObject::GetGlobalDrawObjectItemPool())->getPropertyMap(); + for (const auto pProp : rPropertyMap.getPropertyEntries()) + { + if ( xInfo->hasPropertyByName(pProp->aName) ) + { + const SfxPoolItem* pItem = _rItemSet.GetItem(pProp->nWID); + if ( pItem ) + { + ::std::unique_ptr<SfxPoolItem> pClone(pItem->CloneSetWhich(pProp->nWID)); + pClone->PutValue(_xShape->getPropertyValue(pProp->aName), pProp->nMemberId); + _rItemSet.Put(std::move(pClone)); + } + } + } + } + + void lcl_fillItemsToShape( const uno::Reference<report::XShape >& _xShape,const SfxItemSet& _rItemSet ) + { + const uno::Reference< beans::XPropertySetInfo> xInfo = _xShape->getPropertySetInfo(); + SvxUnoPropertyMapProvider aMap; + const SfxItemPropertyMap& rPropertyMap = aMap.GetPropertySet(SVXMAP_CUSTOMSHAPE, SdrObject::GetGlobalDrawObjectItemPool())->getPropertyMap(); + for (const auto pProp : rPropertyMap.getPropertyEntries()) + { + if ( SfxItemState::SET == _rItemSet.GetItemState(pProp->nWID) && xInfo->hasPropertyByName(pProp->aName) ) + { + if ( ( pProp->nFlags & beans::PropertyAttribute::READONLY ) != beans::PropertyAttribute::READONLY ) + { + const SfxPoolItem* pItem = _rItemSet.GetItem(pProp->nWID); + if ( pItem ) + { + uno::Any aValue; + pItem->QueryValue(aValue, pProp->nMemberId); + try + { + _xShape->setPropertyValue(pProp->aName, aValue); + } + catch(uno::Exception&) + { // shapes have a bug so we ignore this one. + } + } + } + } + } + } + + void lcl_CharPropertiesToItems( const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat, + SfxItemSet& _rItemSet ) + { + if ( !_rxReportControlFormat.is() ) + throw lang::NullPointerException(); + + uno::Reference< beans::XPropertySet > xSet(_rxReportControlFormat,uno::UNO_QUERY_THROW); + + // fill it + const vcl::Font aFont( lcl_setFont(_rxReportControlFormat, _rItemSet,WESTERN,ITEMID_FONT,ITEMID_FONTHEIGHT,ITEMID_LANGUAGE,ITEMID_POSTURE,ITEMID_WEIGHT ) ); + + _rItemSet.Put(SvxShadowedItem(_rxReportControlFormat->getCharShadowed(),ITEMID_SHADOWED)); + _rItemSet.Put(SvxWordLineModeItem(aFont.IsWordLineMode(),ITEMID_WORDLINEMODE)); + _rItemSet.Put(SvxContourItem(_rxReportControlFormat->getCharContoured(),ITEMID_CONTOUR)); + _rItemSet.Put(SvxAutoKernItem(_rxReportControlFormat->getCharAutoKerning(),ITEMID_AUTOKERN)); + _rItemSet.Put(SvxCrossedOutItem(aFont.GetStrikeout(),ITEMID_CROSSEDOUT)); + _rItemSet.Put(SvxCaseMapItem(static_cast<SvxCaseMap>(_rxReportControlFormat->getCharCaseMap()),ITEMID_CASEMAP)); + + _rItemSet.Put(SvxEscapementItem(_rxReportControlFormat->getCharEscapement(),_rxReportControlFormat->getCharEscapementHeight(),ITEMID_ESCAPEMENT)); + _rItemSet.Put(SvxBlinkItem(_rxReportControlFormat->getCharFlash(),ITEMID_BLINK)); + _rItemSet.Put(SvxCharHiddenItem(_rxReportControlFormat->getCharHidden(),ITEMID_CHARHIDDEN)); + _rItemSet.Put(SvxTwoLinesItem(_rxReportControlFormat->getCharCombineIsOn(),_rxReportControlFormat->getCharCombinePrefix().toChar(),_rxReportControlFormat->getCharCombineSuffix().toChar(),ITEMID_TWOLINES)); + SvxUnderlineItem aUnderLineItem(aFont.GetUnderline(),ITEMID_UNDERLINE); + aUnderLineItem.SetColor(Color(ColorTransparency, _rxReportControlFormat->getCharUnderlineColor())); + _rItemSet.Put(aUnderLineItem); + _rItemSet.Put(SvxKerningItem(_rxReportControlFormat->getCharKerning(),ITEMID_KERNING)); + _rItemSet.Put(SvxEmphasisMarkItem(static_cast<FontEmphasisMark>(_rxReportControlFormat->getCharEmphasis()),ITEMID_EMPHASISMARK)); + _rItemSet.Put(SvxCharReliefItem(static_cast<FontRelief>(_rxReportControlFormat->getCharRelief()),ITEMID_CHARRELIEF)); + _rItemSet.Put(SvxColorItem(::Color(ColorTransparency, _rxReportControlFormat->getCharColor()),ITEMID_COLOR)); + _rItemSet.Put(SvxCharRotateItem(Degree10(_rxReportControlFormat->getCharRotation()),false,ITEMID_CHARROTATE)); + _rItemSet.Put(SvxCharScaleWidthItem(_rxReportControlFormat->getCharScaleWidth(),ITEMID_CHARSCALE_W)); + + SvxHorJustifyItem aHorJustifyItem(ITEMID_HORJUSTIFY); + aHorJustifyItem.PutValue(xSet->getPropertyValue(PROPERTY_PARAADJUST),MID_HORJUST_ADJUST); + _rItemSet.Put(aHorJustifyItem); + SvxVerJustifyItem aVerJustifyItem(ITEMID_VERJUSTIFY); + aVerJustifyItem.PutValue(xSet->getPropertyValue(PROPERTY_VERTICALALIGN),MID_HORJUST_ADJUST); + _rItemSet.Put(aVerJustifyItem); + + uno::Reference< report::XShape> xShape(_rxReportControlFormat,uno::UNO_QUERY); + if ( !xShape.is() ) + _rItemSet.Put(SvxBrushItem(::Color(ColorTransparency, _rxReportControlFormat->getControlBackground()),ITEMID_BRUSH)); + + lcl_setFont(_rxReportControlFormat, _rItemSet,ASIAN,ITEMID_FONT_ASIAN,ITEMID_FONTHEIGHT_ASIAN,ITEMID_LANGUAGE_ASIAN,ITEMID_POSTURE_ASIAN,ITEMID_WEIGHT_ASIAN ); + lcl_setFont(_rxReportControlFormat, _rItemSet,COMPLEX,ITEMID_FONT_COMPLEX,ITEMID_FONTHEIGHT_COMPLEX,ITEMID_LANGUAGE_COMPLEX,ITEMID_POSTURE_COMPLEX,ITEMID_WEIGHT_COMPLEX ); + } + + + void lcl_pushBack( uno::Sequence< beans::NamedValue >& _out_rProperties, const OUString& _sName, const uno::Any& _rValue ) + { + sal_Int32 nLen( _out_rProperties.getLength() ); + _out_rProperties.realloc( nLen + 1 ); + _out_rProperties.getArray()[ nLen ] = beans::NamedValue( _sName, _rValue ); + } + + + void lcl_initAwtFont( const vcl::Font& _rOriginalFont, const SfxItemSet& _rItemSet, awt::FontDescriptor& _out_rAwtFont, + TypedWhichId<SvxFontItem> _nFont, TypedWhichId<SvxFontHeightItem> _nFontHeight, + TypedWhichId<SvxPostureItem> _nPosture, TypedWhichId<SvxWeightItem> _nWeight) + { + vcl::Font aNewFont( _rOriginalFont ); + if ( const SvxFontItem* pFontItem = _rItemSet.GetItemIfSet( _nFont) ) + { + aNewFont.SetFamilyName(pFontItem->GetFamilyName()); + aNewFont.SetStyleName(pFontItem->GetStyleName()); + aNewFont.SetFamily(pFontItem->GetFamily()); + aNewFont.SetPitch(pFontItem->GetPitch()); + aNewFont.SetCharSet(pFontItem->GetCharSet()); + } + if ( const SvxFontHeightItem* pFontItem = _rItemSet.GetItemIfSet( _nFontHeight ) ) + { + aNewFont.SetFontHeight(o3tl::convert(pFontItem->GetHeight(), o3tl::Length::twip, o3tl::Length::pt)); + } + if ( const SvxPostureItem* pPostureItem = _rItemSet.GetItemIfSet( _nPosture) ) + { + aNewFont.SetItalic(pPostureItem->GetPosture()); + } + if ( const SvxWeightItem* pWeightItem = _rItemSet.GetItemIfSet( _nWeight ) ) + { + aNewFont.SetWeight(pWeightItem->GetWeight()); + } + if ( const SvxWordLineModeItem* pWordLineItem = _rItemSet.GetItemIfSet( ITEMID_WORDLINEMODE ) ) + { + aNewFont.SetWordLineMode(pWordLineItem->GetValue()); + } + if ( const SvxCrossedOutItem* pCrossedOutItem = _rItemSet.GetItemIfSet( ITEMID_CROSSEDOUT ) ) + { + aNewFont.SetStrikeout(pCrossedOutItem->GetStrikeout()); + } + if ( const SvxCharRotateItem* pRotateItem = _rItemSet.GetItemIfSet( ITEMID_CHARROTATE ) ) + { + aNewFont.SetOrientation(pRotateItem->GetValue()); + } + if ( const SvxCharScaleWidthItem* pCharItem = _rItemSet.GetItemIfSet( ITEMID_CHARSCALE_W ) ) + { + aNewFont.SetWidthType(vcl::unohelper::ConvertFontWidth(pCharItem->GetValue())); + } + if ( const SvxUnderlineItem* pUnderlineItem = _rItemSet.GetItemIfSet( ITEMID_UNDERLINE ) ) + { + aNewFont.SetUnderline(pUnderlineItem->GetLineStyle()); + } + if ( const SvxColorItem* pColorItem = _rItemSet.GetItemIfSet( ITEMID_COLOR ) ) + { + aNewFont.SetColor(pColorItem->GetValue()); + } + + _out_rAwtFont = VCLUnoHelper::CreateFontDescriptor( aNewFont ); + } + + + void lcl_itemsToCharProperties( const vcl::Font& _rOriginalControlFont,const vcl::Font& _rOriginalControlFontAsian,const vcl::Font& _rOriginalControlFontComplex, const SfxItemSet& _rItemSet, uno::Sequence< beans::NamedValue >& _out_rProperties ) + { + // create an AWT font + awt::FontDescriptor aAwtFont; + lcl_initAwtFont( _rOriginalControlFont, _rItemSet, aAwtFont,ITEMID_FONT,ITEMID_FONTHEIGHT,ITEMID_POSTURE, ITEMID_WEIGHT); + lcl_pushBack( _out_rProperties, "Font", uno::Any( aAwtFont ) ); + lcl_initAwtFont( _rOriginalControlFontAsian, _rItemSet, aAwtFont,ITEMID_FONT_ASIAN,ITEMID_FONTHEIGHT_ASIAN,ITEMID_POSTURE_ASIAN, ITEMID_WEIGHT_ASIAN); + lcl_pushBack( _out_rProperties, "FontAsian", uno::Any( aAwtFont ) ); + lcl_initAwtFont( _rOriginalControlFontComplex, _rItemSet, aAwtFont,ITEMID_FONT_COMPLEX,ITEMID_FONTHEIGHT_COMPLEX,ITEMID_POSTURE_COMPLEX, ITEMID_WEIGHT_COMPLEX); + lcl_pushBack( _out_rProperties, "FontComplex", uno::Any( aAwtFont ) ); + + // properties which cannot be represented in an AWT font need to be preserved directly + if ( const SvxShadowedItem* pShadowedItem = _rItemSet.GetItemIfSet( ITEMID_SHADOWED) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARSHADOWED, uno::Any( pShadowedItem->GetValue() ) ); + if ( const SvxContourItem* pContourItem = _rItemSet.GetItemIfSet( ITEMID_CONTOUR ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARCONTOURED, uno::Any( pContourItem->GetValue() ) ); + if ( const SvxUnderlineItem* pUnderlineItem = _rItemSet.GetItemIfSet( ITEMID_UNDERLINE ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARUNDERLINECOLOR, uno::Any( pUnderlineItem->GetColor() ) ); + if ( const SvxHorJustifyItem* pJustifyItem = _rItemSet.GetItemIfSet( ITEMID_HORJUSTIFY ) ) + { + uno::Any aValue; + pJustifyItem->QueryValue(aValue,MID_HORJUST_ADJUST); + lcl_pushBack( _out_rProperties, PROPERTY_PARAADJUST, aValue ); + } + if ( const SvxVerJustifyItem* pJustifyItem = _rItemSet.GetItemIfSet( ITEMID_VERJUSTIFY ) ) + { + uno::Any aValue; + pJustifyItem->QueryValue(aValue,MID_HORJUST_ADJUST); + lcl_pushBack( _out_rProperties, PROPERTY_VERTICALALIGN, aValue ); + } + if ( const SvxCharReliefItem* pReliefItem = _rItemSet.GetItemIfSet( ITEMID_CHARRELIEF ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARRELIEF, uno::Any( static_cast< sal_Int16 >( pReliefItem->GetEnumValue() ) ) ); + if ( const SvxCharHiddenItem* pHiddenItem = _rItemSet.GetItemIfSet( ITEMID_CHARHIDDEN ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARHIDDEN, uno::Any( pHiddenItem->GetValue() ) ); + if ( const SvxAutoKernItem* pKernItem = _rItemSet.GetItemIfSet( ITEMID_AUTOKERN ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARAUTOKERNING, uno::Any( pKernItem->GetValue() ) ); + if ( const SvxBrushItem* pBrushItem = _rItemSet.GetItemIfSet( ITEMID_BRUSH ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CONTROLBACKGROUND, uno::Any( pBrushItem->GetColor() ) ); + if ( const SvxBlinkItem* pBlinkItem = _rItemSet.GetItemIfSet( ITEMID_BLINK ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARFLASH, uno::Any( pBlinkItem->GetValue() ) ); + if ( const SvxEmphasisMarkItem* pMarkItem = _rItemSet.GetItemIfSet( ITEMID_EMPHASISMARK ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHAREMPHASIS, uno::Any( static_cast< sal_Int16 >( pMarkItem->GetEmphasisMark() ) ) ); + if ( const SvxTwoLinesItem* pLinesItem = _rItemSet.GetItemIfSet( ITEMID_TWOLINES ) ) + { + lcl_pushBack( _out_rProperties, PROPERTY_CHARCOMBINEISON, uno::Any( pLinesItem->GetValue() ) ); + lcl_pushBack( _out_rProperties, PROPERTY_CHARCOMBINEPREFIX, uno::Any( OUString( pLinesItem->GetStartBracket() ) ) ); + lcl_pushBack( _out_rProperties, PROPERTY_CHARCOMBINESUFFIX, uno::Any( OUString( pLinesItem->GetEndBracket() ) ) ); + } + if ( const SvxColorItem* pColorItem = _rItemSet.GetItemIfSet( ITEMID_COLOR ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARCOLOR, uno::Any( pColorItem->GetValue() ) ); + if ( const SvxKerningItem* pKernItem = _rItemSet.GetItemIfSet( ITEMID_KERNING ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARKERNING, uno::Any( pKernItem->GetValue() ) ); + if ( const SvxCaseMapItem* pCaseMapItem = _rItemSet.GetItemIfSet( ITEMID_CASEMAP ) ) + lcl_pushBack( _out_rProperties, PROPERTY_CHARCASEMAP, uno::Any( pCaseMapItem->GetEnumValue() ) ); + struct Items { + TypedWhichId<SvxLanguageItem> nWhich; + OUString sPropertyName; + }; + const Items pItems[] = { {ITEMID_LANGUAGE,OUString(PROPERTY_CHARLOCALE)} + ,{ITEMID_LANGUAGE_ASIAN,OUString(PROPERTY_CHARLOCALEASIAN)} + ,{ITEMID_LANGUAGE_COMPLEX,OUString(PROPERTY_CHARLOCALECOMPLEX)} + }; + for(const auto & k : pItems) + { + if ( const SvxLanguageItem* pLanguageItem = _rItemSet.GetItemIfSet( k.nWhich ) ) + { + lang::Locale aCharLocale( LanguageTag( pLanguageItem->GetLanguage()).getLocale()); + lcl_pushBack( _out_rProperties, k.sPropertyName, uno::Any( aCharLocale ) ); + } + } + if ( const SvxEscapementItem* pEscapementItem = _rItemSet.GetItemIfSet( ITEMID_ESCAPEMENT ) ) + { + lcl_pushBack( _out_rProperties, PROPERTY_CHARESCAPEMENT, uno::Any( pEscapementItem->GetEsc() ) ); + lcl_pushBack( _out_rProperties, PROPERTY_CHARESCAPEMENTHEIGHT, uno::Any(static_cast<sal_Int8>(pEscapementItem->GetProportionalHeight())) ); + } + } + + + template< class ATTRIBUTE_TYPE > + void lcl_applyFontAttribute( const ::comphelper::NamedValueCollection& _rAttrValues, const OUString& _pAttributeName, + const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat, + void (SAL_CALL report::XReportControlFormat::*pSetter)( ATTRIBUTE_TYPE ) ) + { + ATTRIBUTE_TYPE aAttributeValue = ATTRIBUTE_TYPE(); + if ( _rAttrValues.get_ensureType( _pAttributeName, aAttributeValue ) ) + (_rxReportControlFormat.get()->*pSetter)( aAttributeValue ); + } + + + void lcl_applyFontAttribute( const ::comphelper::NamedValueCollection& _rAttrValues, const OUString& _pAttributeName, + const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat, + void (SAL_CALL report::XReportControlFormat::*pSetter)( const OUString& ) ) + { + OUString aAttributeValue; + if ( _rAttrValues.get_ensureType( _pAttributeName, aAttributeValue ) ) + (_rxReportControlFormat.get()->*pSetter)( aAttributeValue ); + } + + + void lcl_applyFontAttribute( const ::comphelper::NamedValueCollection& _rAttrValues, const OUString& _pAttributeName, + const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat, + void (SAL_CALL report::XReportControlFormat::*pSetter)( const lang::Locale& ) ) + { + lang::Locale aAttributeValue; + if ( _rAttrValues.get_ensureType( _pAttributeName, aAttributeValue ) ) + (_rxReportControlFormat.get()->*pSetter)( aAttributeValue ); + } +} + + +bool openCharDialog( const uno::Reference<report::XReportControlFormat >& _rxReportControlFormat, + const uno::Reference< awt::XWindow>& _rxParentWindow, uno::Sequence< beans::NamedValue >& _out_rNewValues ) +{ + OSL_PRECOND( _rxReportControlFormat.is() && _rxParentWindow.is(), "openCharDialog: invalid parameters!" ); + if ( !_rxReportControlFormat.is() || !_rxParentWindow.is() ) + return false; + + _out_rNewValues = uno::Sequence< beans::NamedValue >(); + + + // UNO->ItemSet + static SfxItemInfo aItemInfos[] = + { + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + { 0, true }, + + { SID_ATTR_CHAR_FONT, true }, + { SID_ATTR_CHAR_FONTHEIGHT, true }, + { SID_ATTR_CHAR_LANGUAGE, true }, + { SID_ATTR_CHAR_POSTURE, true }, + { SID_ATTR_CHAR_WEIGHT, true }, + { SID_ATTR_CHAR_SHADOWED, true }, + { SID_ATTR_CHAR_WORDLINEMODE, true }, + { SID_ATTR_CHAR_CONTOUR, true }, + { SID_ATTR_CHAR_STRIKEOUT, true }, + { SID_ATTR_CHAR_UNDERLINE, true }, + { SID_ATTR_CHAR_COLOR, true }, + { SID_ATTR_CHAR_KERNING, true }, + { SID_ATTR_CHAR_CASEMAP, true }, + { SID_ATTR_CHAR_ESCAPEMENT, true }, + { SID_ATTR_CHAR_FONTLIST, true }, + { SID_ATTR_CHAR_AUTOKERN, true }, + { SID_COLOR_TABLE, true }, + { SID_ATTR_FLASH, true }, + { SID_ATTR_CHAR_EMPHASISMARK, true }, + { SID_ATTR_CHAR_TWO_LINES, true }, + { SID_ATTR_CHAR_ROTATED, true }, + { SID_ATTR_CHAR_SCALEWIDTH, true }, + { SID_ATTR_CHAR_RELIEF, true }, + { SID_ATTR_CHAR_HIDDEN, true }, + { SID_ATTR_BRUSH, true }, + { SID_ATTR_ALIGN_HOR_JUSTIFY, true }, + { SID_ATTR_ALIGN_VER_JUSTIFY, true }, + + // Asian + { SID_ATTR_CHAR_CJK_FONT, true }, + { SID_ATTR_CHAR_CJK_FONTHEIGHT, true }, + { SID_ATTR_CHAR_CJK_LANGUAGE, true }, + { SID_ATTR_CHAR_CJK_POSTURE, true }, + { SID_ATTR_CHAR_CJK_WEIGHT, true }, + // Complex + { SID_ATTR_CHAR_CTL_FONT, true }, + { SID_ATTR_CHAR_CTL_FONTHEIGHT, true }, + { SID_ATTR_CHAR_CTL_LANGUAGE, true }, + { SID_ATTR_CHAR_CTL_POSTURE, true }, + { SID_ATTR_CHAR_CTL_WEIGHT, true } + }; + FontList aFontList(Application::GetDefaultDevice()); + XColorListRef pColorList( XColorList::CreateStdColorList() ); + const Graphic aNullGraphic; + const ::Color aNullLineCol(COL_DEFAULT_SHAPE_STROKE); // #i121448# Use defined default color + const ::Color aNullFillCol(COL_DEFAULT_SHAPE_FILLING); // #i121448# Use defined default color + const XGradient aNullGrad(COL_BLACK, COL_WHITE); + const XHatch aNullHatch(aNullLineCol); + std::vector<SfxPoolItem*> pDefaults + { + new XFillStyleItem, + new XFillColorItem("", aNullFillCol), + new XFillGradientItem(aNullGrad), + new XFillHatchItem(aNullHatch), + new XFillBitmapItem(aNullGraphic), + new XFillTransparenceItem, + new XGradientStepCountItem, + new XFillBmpTileItem, + new XFillBmpPosItem, + new XFillBmpSizeXItem, + new XFillBmpSizeYItem, + new XFillFloatTransparenceItem(aNullGrad, false), + new XSecondaryFillColorItem("", aNullFillCol), + new XFillBmpSizeLogItem, + new XFillBmpTileOffsetXItem, + new XFillBmpTileOffsetYItem, + new XFillBmpStretchItem, + new XFillBmpPosOffsetXItem, + new XFillBmpPosOffsetYItem, + new XFillBackgroundItem, + + new SvxFontItem(ITEMID_FONT), + new SvxFontHeightItem(240,100,ITEMID_FONTHEIGHT), + new SvxLanguageItem(LANGUAGE_GERMAN,ITEMID_LANGUAGE), + new SvxPostureItem(ITALIC_NONE,ITEMID_POSTURE), + new SvxWeightItem(WEIGHT_NORMAL,ITEMID_WEIGHT), + + new SvxShadowedItem(false,ITEMID_SHADOWED), + new SvxWordLineModeItem(false,ITEMID_WORDLINEMODE), + new SvxContourItem(false,ITEMID_CONTOUR), + new SvxCrossedOutItem(STRIKEOUT_NONE,ITEMID_CROSSEDOUT), + new SvxUnderlineItem(LINESTYLE_NONE,ITEMID_UNDERLINE), + + new SvxColorItem(ITEMID_COLOR), + new SvxKerningItem(0,ITEMID_KERNING), + new SvxCaseMapItem(SvxCaseMap::NotMapped,ITEMID_CASEMAP), + new SvxEscapementItem(ITEMID_ESCAPEMENT), + new SvxFontListItem(&aFontList,ITEMID_FONTLIST), + new SvxAutoKernItem(false,ITEMID_AUTOKERN), + new SvxColorListItem(pColorList,ITEMID_COLOR_TABLE), + new SvxBlinkItem(false,ITEMID_BLINK), + new SvxEmphasisMarkItem(FontEmphasisMark::NONE,ITEMID_EMPHASISMARK), + new SvxTwoLinesItem(true,0,0,ITEMID_TWOLINES), + new SvxCharRotateItem(0_deg10,false,ITEMID_CHARROTATE), + new SvxCharScaleWidthItem(100,ITEMID_CHARSCALE_W), + new SvxCharReliefItem(FontRelief::NONE,ITEMID_CHARRELIEF), + new SvxCharHiddenItem(false,ITEMID_CHARHIDDEN), + new SvxBrushItem(ITEMID_BRUSH), + new SvxHorJustifyItem(ITEMID_HORJUSTIFY), + new SvxVerJustifyItem(ITEMID_VERJUSTIFY), +// Asian + new SvxFontItem(ITEMID_FONT_ASIAN), + new SvxFontHeightItem(240,100,ITEMID_FONTHEIGHT_ASIAN), + new SvxLanguageItem(LANGUAGE_GERMAN,ITEMID_LANGUAGE_ASIAN), + new SvxPostureItem(ITALIC_NONE,ITEMID_POSTURE_ASIAN), + new SvxWeightItem(WEIGHT_NORMAL,ITEMID_WEIGHT_ASIAN), +// Complex + new SvxFontItem(ITEMID_FONT_COMPLEX), + new SvxFontHeightItem(240,100,ITEMID_FONTHEIGHT_COMPLEX), + new SvxLanguageItem(LANGUAGE_GERMAN,ITEMID_LANGUAGE_COMPLEX), + new SvxPostureItem(ITALIC_NONE,ITEMID_POSTURE_COMPLEX), + new SvxWeightItem(WEIGHT_NORMAL,ITEMID_WEIGHT_COMPLEX) + + }; + + OSL_ASSERT( pDefaults.size() == SAL_N_ELEMENTS(aItemInfos) ); + + static const WhichRangesContainer pRanges(svl::Items< + XATTR_FILLSTYLE, XATTR_FILLBACKGROUND, + ITEMID_FONT, ITEMID_WEIGHT_COMPLEX + >); + + rtl::Reference<SfxItemPool> pPool(new SfxItemPool("ReportCharProperties", XATTR_FILL_FIRST,ITEMID_WEIGHT_COMPLEX, aItemInfos, &pDefaults)); + // not needed for font height pPool->SetDefaultMetric( MapUnit::Map100thMM ); // ripped, don't understand why + pPool->FreezeIdRanges(); // the same + bool bSuccess = false; + try + { + SfxItemSet aDescriptor( *pPool, pRanges ); + lcl_CharPropertiesToItems( _rxReportControlFormat, aDescriptor ); + + { // want the dialog to be destroyed before our set + ORptPageDialog aDlg(Application::GetFrameWeld(_rxParentWindow), &aDescriptor, "CharDialog"); + uno::Reference< report::XShape > xShape( _rxReportControlFormat, uno::UNO_QUERY ); + if ( xShape.is() ) + aDlg.RemoveTabPage("background"); + bSuccess = aDlg.run() == RET_OK; + if ( bSuccess ) + { + lcl_itemsToCharProperties( lcl_getReportControlFont( _rxReportControlFormat,WESTERN ), + lcl_getReportControlFont( _rxReportControlFormat,ASIAN ), + lcl_getReportControlFont( _rxReportControlFormat,COMPLEX ), *aDlg.GetOutputItemSet(), _out_rNewValues ); + } + } + } + catch(uno::Exception&) + { + DBG_UNHANDLED_EXCEPTION("reportdesign"); + } + + pPool.clear(); + for (SfxPoolItem* pDefault : pDefaults) + delete pDefault; + + return bSuccess; +} + +bool openAreaDialog( const uno::Reference<report::XShape >& _xShape,const uno::Reference< awt::XWindow>& _rxParentWindow ) +{ + OSL_PRECOND( _xShape.is() && _rxParentWindow.is(), "openAreaDialog: invalid parameters!" ); + if ( !_xShape.is() || !_rxParentWindow.is() ) + return false; + + std::shared_ptr<rptui::OReportModel> pModel = ::reportdesign::OReportDefinition::getSdrModel(_xShape->getSection()->getReportDefinition()); + + weld::Window* pParent = Application::GetFrameWeld(_rxParentWindow); + + bool bSuccess = false; + try + { + SfxItemPool& rItemPool = pModel->GetItemPool(); + SfxItemSet aDescriptor( rItemPool, rItemPool.GetFirstWhich(), rItemPool.GetLastWhich() ); + lcl_fillShapeToItems(_xShape, aDescriptor); + + { // want the dialog to be destroyed before our set + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxAreaTabDialog> pDialog( + pFact->CreateSvxAreaTabDialog(pParent, &aDescriptor, pModel.get(), true, false)); + if ( RET_OK == pDialog->Execute() ) + { + bSuccess = true; + lcl_fillItemsToShape(_xShape,*pDialog->GetOutputItemSet()); + } + } + } + catch(uno::Exception&) + { + DBG_UNHANDLED_EXCEPTION("reportdesign"); + } + + return bSuccess; +} + + +void applyCharacterSettings( const uno::Reference< report::XReportControlFormat >& _rxReportControlFormat, const uno::Sequence< beans::NamedValue >& _rSettings ) +{ + ::comphelper::NamedValueCollection aSettings( _rSettings ); + + try + { + awt::FontDescriptor aAwtFont; + if ( aSettings.get( "Font" ) >>= aAwtFont ) + { + OUString sTemp = aAwtFont.Name; + aAwtFont.Name.clear(); // hack to + _rxReportControlFormat->setFontDescriptor( aAwtFont ); + _rxReportControlFormat->setCharFontName( sTemp ); + } + if ( aSettings.get( "FontAsian" ) >>= aAwtFont ) + { + OUString sTemp = aAwtFont.Name; + aAwtFont.Name.clear(); // hack to + _rxReportControlFormat->setFontDescriptorAsian( aAwtFont ); + _rxReportControlFormat->setCharFontNameAsian( sTemp ); + } + if ( aSettings.get( "FontComplex" ) >>= aAwtFont ) + { + OUString sTemp = aAwtFont.Name; + aAwtFont.Name.clear(); // hack to + _rxReportControlFormat->setFontDescriptorComplex( aAwtFont ); + _rxReportControlFormat->setCharFontNameComplex( sTemp ); + } + + lcl_applyFontAttribute( aSettings, PROPERTY_CHARSHADOWED, _rxReportControlFormat, &report::XReportControlFormat::setCharShadowed ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARCONTOURED, _rxReportControlFormat, &report::XReportControlFormat::setCharContoured ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARUNDERLINECOLOR, _rxReportControlFormat, &report::XReportControlFormat::setCharUnderlineColor ); + lcl_applyFontAttribute( aSettings, PROPERTY_PARAADJUST, _rxReportControlFormat, &report::XReportControlFormat::setParaAdjust ); + lcl_applyFontAttribute( aSettings, PROPERTY_VERTICALALIGN, _rxReportControlFormat, &report::XReportControlFormat::setVerticalAlign ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARRELIEF, _rxReportControlFormat, &report::XReportControlFormat::setCharRelief ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARHIDDEN, _rxReportControlFormat, &report::XReportControlFormat::setCharHidden ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARAUTOKERNING, _rxReportControlFormat, &report::XReportControlFormat::setCharAutoKerning ); + lcl_applyFontAttribute( aSettings, PROPERTY_CONTROLBACKGROUND, _rxReportControlFormat, &report::XReportControlFormat::setControlBackground ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARFLASH, _rxReportControlFormat, &report::XReportControlFormat::setCharFlash ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHAREMPHASIS, _rxReportControlFormat, &report::XReportControlFormat::setCharEmphasis ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARCOMBINEISON, _rxReportControlFormat, &report::XReportControlFormat::setCharCombineIsOn ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARCOMBINEPREFIX, _rxReportControlFormat, &report::XReportControlFormat::setCharCombinePrefix ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARCOMBINESUFFIX, _rxReportControlFormat, &report::XReportControlFormat::setCharCombineSuffix ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARCOLOR, _rxReportControlFormat, &report::XReportControlFormat::setCharColor ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARKERNING, _rxReportControlFormat, &report::XReportControlFormat::setCharKerning ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARCASEMAP, _rxReportControlFormat, &report::XReportControlFormat::setCharCaseMap ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARLOCALE, _rxReportControlFormat, &report::XReportControlFormat::setCharLocale ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARESCAPEMENT, _rxReportControlFormat, &report::XReportControlFormat::setCharEscapement ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARESCAPEMENTHEIGHT, _rxReportControlFormat, &report::XReportControlFormat::setCharEscapementHeight ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARLOCALEASIAN, _rxReportControlFormat, &report::XReportControlFormat::setCharLocaleAsian ); + lcl_applyFontAttribute( aSettings, PROPERTY_CHARLOCALECOMPLEX, _rxReportControlFormat, &report::XReportControlFormat::setCharLocaleComplex ); + } + catch( const uno::Exception& ) + { + DBG_UNHANDLED_EXCEPTION("reportdesign"); + } +} + +void notifySystemWindow(vcl::Window const * _pWindow, vcl::Window* _pToRegister, const ::comphelper::mem_fun1_t<TaskPaneList,vcl::Window*>& rMemFunc) +{ + OSL_ENSURE(_pWindow,"Window can not be null!"); + SystemWindow* pSystemWindow = _pWindow ? _pWindow->GetSystemWindow() : nullptr; + if ( pSystemWindow ) + { + rMemFunc( pSystemWindow->GetTaskPaneList(), _pToRegister ); + } +} + +SdrObject* isOver(const tools::Rectangle& _rRect, SdrPage const & _rPage, SdrView const & _rView, bool _bAllObjects, SdrObject const * _pIgnore, sal_Int16 _nIgnoreType) +{ + SdrObject* pOverlappedObj = nullptr; + SdrObjListIter aIter(&_rPage,SdrIterMode::DeepNoGroups); + + while( !pOverlappedObj ) + { + SdrObject* pObjIter = aIter.Next(); + if( !pObjIter ) + break; + if ( _pIgnore != pObjIter + && (_bAllObjects || !_rView.IsObjMarked(pObjIter)) + && (dynamic_cast<OUnoObject*>(pObjIter) != nullptr || dynamic_cast<OOle2Obj*>(pObjIter) != nullptr)) + { + if (_nIgnoreType == ISOVER_IGNORE_CUSTOMSHAPES && pObjIter->GetObjIdentifier() == SdrObjKind::CustomShape) + { + continue; + } + + if (dynamic_cast<OUnoObject*>(pObjIter) != nullptr || dynamic_cast<OOle2Obj*>(pObjIter) != nullptr) + { + tools::Rectangle aRect = _rRect.GetIntersection(pObjIter->GetLastBoundRect()); + if ( !aRect.IsEmpty() && (aRect.Left() != aRect.Right() && aRect.Top() != aRect.Bottom() ) ) + pOverlappedObj = pObjIter; + } + } + } + return pOverlappedObj; +} + +static bool checkArrayForOccurrence(SdrObject const * _pObjToCheck, std::unique_ptr<SdrUnoObj, SdrObjectFreeOp> _pIgnore[], int _nListLength) +{ + for(int i=0;i<_nListLength;i++) + { + SdrObject *pIgnore = _pIgnore[i].get(); + if (pIgnore == _pObjToCheck) + { + return true; + } + } + return false; +} + +SdrObject* isOver(const tools::Rectangle& _rRect,SdrPage const & _rPage,SdrView const & _rView,bool _bAllObjects, std::unique_ptr<SdrUnoObj, SdrObjectFreeOp> _pIgnoreList[], int _nIgnoreListLength) +{ + SdrObject* pOverlappedObj = nullptr; + SdrObjListIter aIter(&_rPage,SdrIterMode::DeepNoGroups); + + while( !pOverlappedObj ) + { + SdrObject* pObjIter = aIter.Next(); + if( !pObjIter ) + break; + if (checkArrayForOccurrence(pObjIter, _pIgnoreList, _nIgnoreListLength)) + { + continue; + } + + if ( (_bAllObjects || !_rView.IsObjMarked(pObjIter)) + && (dynamic_cast<OUnoObject*>(pObjIter) != nullptr || dynamic_cast<OOle2Obj*>(pObjIter) != nullptr) ) + { + tools::Rectangle aRect = _rRect.GetIntersection(pObjIter->GetLastBoundRect()); + if ( !aRect.IsEmpty() && (aRect.Left() != aRect.Right() && aRect.Top() != aRect.Bottom() ) ) + pOverlappedObj = pObjIter; + } + } + return pOverlappedObj; +} + + +SdrObject* isOver(SdrObject const * _pObj,SdrPage const & _rPage,SdrView const & _rView) +{ + SdrObject* pOverlappedObj = nullptr; + if (dynamic_cast<OUnoObject const *>(_pObj) != nullptr || dynamic_cast<OOle2Obj const *>(_pObj) != nullptr) // this doesn't need to be done for shapes + { + tools::Rectangle aRect = _pObj->GetCurrentBoundRect(); + pOverlappedObj = isOver(aRect,_rPage,_rView,false/*_bUnMarkedObjects*/,_pObj); + } + return pOverlappedObj; +} + + +uno::Sequence< OUString > getParameterNames( const uno::Reference< sdbc::XRowSet >& _rxRowSet ) +{ + uno::Sequence< OUString > aNames; + + try + { + uno::Reference< sdb::XParametersSupplier > xSuppParams( _rxRowSet, uno::UNO_QUERY_THROW ); + uno::Reference< container::XIndexAccess > xParams( xSuppParams->getParameters() ); + if ( xParams.is() ) + { + sal_Int32 count( xParams->getCount() ); + aNames.realloc( count ); + auto pNames = aNames.getArray(); + + uno::Reference< beans::XPropertySet > xParam; + OUString sParamName; + for ( sal_Int32 i=0; i<count; ++i ) + { + xParam.set( xParams->getByIndex(i), uno::UNO_QUERY_THROW ); + OSL_VERIFY( xParam->getPropertyValue( PROPERTY_NAME ) >>= sParamName ); + pNames[i] = sParamName; + } + } + } + catch( const uno::Exception& ) + { + DBG_UNHANDLED_EXCEPTION("reportdesign"); + } + + return aNames; +} + +tools::Rectangle getRectangleFromControl(SdrObject* _pControl) +{ + if (_pControl) + { + uno::Reference< report::XReportComponent > xComponent( _pControl->getUnoShape(), uno::UNO_QUERY); + if (xComponent.is()) + { + tools::Rectangle aRect(VCLPoint(xComponent->getPosition()),VCLSize(xComponent->getSize())); + aRect.setHeight(aRect.getHeight() + 1); + aRect.setWidth(aRect.getWidth() + 1); + return aRect; + } + } + return tools::Rectangle(); +} + +// check overlapping +void correctOverlapping(SdrObject* _pControl,OReportSection const & _aReportSection,bool _bInsert) +{ + OSectionView& rSectionView = _aReportSection.getSectionView(); + uno::Reference< report::XReportComponent> xComponent(_pControl->getUnoShape(),uno::UNO_QUERY); + tools::Rectangle aRect = getRectangleFromControl(_pControl); + + bool bOverlapping = true; + while ( bOverlapping ) + { + SdrObject* pOverlappedObj = isOver(aRect,*_aReportSection.getPage(),rSectionView,true, _pControl); + bOverlapping = pOverlappedObj != nullptr; + if ( bOverlapping ) + { + const tools::Rectangle& aLogicRect = pOverlappedObj->GetLogicRect(); + aRect.Move(0,aLogicRect.Top() + aLogicRect.getHeight() - aRect.Top()); + xComponent->setPositionY(aRect.Top()); + } + } + if (_bInsert) // now insert objects + rSectionView.InsertObjectAtView(_pControl,*rSectionView.GetSdrPageView(), SdrInsertFlags::ADDMARK); +} + +void setZoomFactor(const Fraction& _aZoom, vcl::Window& _rWindow) +{ + MapMode aMapMode( _rWindow.GetMapMode() ); + aMapMode.SetScaleX(_aZoom); + aMapMode.SetScaleY(_aZoom); + _rWindow.SetMapMode(aMapMode); +} + +bool openDialogFormula_nothrow( OUString& _in_out_rFormula + , const css::uno::Reference< css::uno::XComponentContext >& _xContext + , const uno::Reference< awt::XWindow>& _xInspectorWindow + , const css::uno::Reference < css::beans::XPropertySet >& _xRowSet + ) +{ + OSL_PRECOND( _xInspectorWindow.is(), "openDialogFormula_nothrow: invalid parameters!" ); + if ( !_xInspectorWindow.is() ) + return false; + bool bSuccess = false; + ::dbtools::SQLExceptionInfo aErrorInfo; + uno::Reference< awt::XWindow > xInspectorWindow; + uno::Reference< lang::XMultiComponentFactory > xFactory; + uno::Reference<lang::XMultiServiceFactory> xServiceFactory; + try + { + xFactory = _xContext->getServiceManager(); + xServiceFactory.set(xFactory,uno::UNO_QUERY); + + uno::Reference< report::meta::XFunctionManager> xMgr(xFactory->createInstanceWithContext("org.libreoffice.report.pentaho.SOFunctionManager",_xContext),uno::UNO_QUERY); + if ( xMgr.is() ) + { + auto pFormulaManager = std::make_shared<FunctionManager>(xMgr); + ReportFormula aFormula( _in_out_rFormula ); + + CharClass aCC(_xContext, LanguageTag(LANGUAGE_SYSTEM)); + svl::SharedStringPool aStringPool(aCC); + + FormulaDialog aDlg( + Application::GetFrameWeld(_xInspectorWindow), xServiceFactory, pFormulaManager, + aFormula.getUndecoratedContent(), _xRowSet, aStringPool); + + bSuccess = aDlg.run() == RET_OK; + if ( bSuccess ) + { + OUString sFormula = aDlg.getCurrentFormula(); + if ( sFormula[0] == '=' ) + _in_out_rFormula = OUString::Concat("rpt:") + sFormula.subView(1); + else + _in_out_rFormula = "rpt:" + sFormula; + } + } + } + catch (const sdb::SQLContext& e) { aErrorInfo = e; } + catch (const sdbc::SQLWarning& e) { aErrorInfo = e; } + catch (const sdbc::SQLException& e) { aErrorInfo = e; } + catch( const uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "reportdesign", "GeometryHandler::impl_dialogFilter_nothrow" ); + } + + if ( aErrorInfo.isValid() ) + ::dbtools::showError( aErrorInfo, xInspectorWindow, _xContext ); + + return bSuccess; +} + +} // namespace rptui + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/reportdesign/source/ui/misc/statusbarcontroller.cxx b/reportdesign/source/ui/misc/statusbarcontroller.cxx new file mode 100644 index 000000000..22f2d7714 --- /dev/null +++ b/reportdesign/source/ui/misc/statusbarcontroller.cxx @@ -0,0 +1,222 @@ +/* -*- 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 <statusbarcontroller.hxx> + +#include <cppuhelper/supportsservice.hxx> +#include <comphelper/types.hxx> +#include <svx/zoomsliderctrl.hxx> +#include <svx/zoomctrl.hxx> +#include <svx/svxids.hrc> +#include <sfx2/zoomitem.hxx> +#include <svx/zoomslideritem.hxx> + +#include <vcl/svapp.hxx> +#include <vcl/status.hxx> +#include <osl/mutex.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> + +namespace rptui +{ + using namespace svt; + using namespace com::sun::star::uno; + using namespace com::sun::star::beans; + using namespace com::sun::star::lang; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::util; + +OUString SAL_CALL OStatusbarController::getImplementationName() +{ + return "com.sun.star.report.comp.StatusbarController"; +} + +sal_Bool SAL_CALL OStatusbarController::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService(this, ServiceName); +} + +Sequence< OUString> SAL_CALL OStatusbarController::getSupportedServiceNames() +{ + return { "com.sun.star.frame.StatusbarController" }; +} + +IMPLEMENT_FORWARD_XINTERFACE2(OStatusbarController, ::svt::StatusbarController,OStatusbarController_BASE) + +OStatusbarController::OStatusbarController(const Reference< XComponentContext >& rxContext) +: ::svt::StatusbarController(rxContext, Reference< XFrame >(), OUString(), 0) +,m_nSlotId(0) +,m_nId(1) +{ +} + +void SAL_CALL OStatusbarController::initialize( const Sequence< Any >& _rArguments ) +{ + StatusbarController::initialize(_rArguments); + SolarMutexGuard aSolarMutexGuard; + ::osl::MutexGuard aGuard(m_aMutex); + + VclPtr< StatusBar > pStatusBar = static_cast<StatusBar*>(VCLUnoHelper::GetWindow(m_xParentWindow)); + if ( !pStatusBar ) + return; + + const sal_uInt16 nCount = pStatusBar->GetItemCount(); + for (sal_uInt16 nPos = 0; nPos < nCount; ++nPos) + { + const sal_uInt16 nItemId = pStatusBar->GetItemId(nPos); + if ( pStatusBar->GetItemCommand(nItemId) == m_aCommandURL ) + { + m_nId = nItemId; + break; + } + } + + rtl::Reference<SfxStatusBarControl> pController; + if ( m_aCommandURL == ".uno:ZoomSlider" ) + { + m_nSlotId = SID_ATTR_ZOOMSLIDER; + pController = new SvxZoomSliderControl(m_nSlotId,m_nId,*pStatusBar); + } + else if ( m_aCommandURL == ".uno:Zoom" ) + { + m_nSlotId = SID_ATTR_ZOOM; + pController = new SvxZoomStatusBarControl(m_nSlotId,m_nId,*pStatusBar); + } + + if ( pController ) + { + m_rController.set( pController ); + if ( m_rController.is() ) + { + m_rController->initialize(_rArguments); + m_rController->update(); + } + } + + addStatusListener(m_aCommandURL); + update(); +} +// XStatusListener +void SAL_CALL OStatusbarController::statusChanged( const FeatureStateEvent& _aEvent) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard(m_aMutex); + + if ( !m_rController.is() ) + return; + + if ( m_aCommandURL == ".uno:ZoomSlider" ) + { + Sequence< PropertyValue > aSeq; + if ( (_aEvent.State >>= aSeq) && aSeq.getLength() == 2 ) + { + SvxZoomSliderItem aZoomSlider(100,20,400); + aZoomSlider.PutValue(_aEvent.State, 0); + static_cast<SvxZoomSliderControl*>(m_rController.get())->StateChangedAtStatusBarControl(m_nSlotId,SfxItemState::DEFAULT,&aZoomSlider); + } + } + else if ( m_aCommandURL == ".uno:Zoom" ) + { + Sequence< PropertyValue > aSeq; + if ( (_aEvent.State >>= aSeq) && aSeq.getLength() == 3 ) + { + SvxZoomItem aZoom; + aZoom.PutValue(_aEvent.State, 0 ); + static_cast<SvxZoomStatusBarControl*>(m_rController.get())->StateChangedAtStatusBarControl(m_nSlotId,SfxItemState::DEFAULT,&aZoom); + } + } +} + +// XStatusbarController +sal_Bool SAL_CALL OStatusbarController::mouseButtonDown(const css::awt::MouseEvent& _aEvent) +{ + return m_rController.is() && m_rController->mouseButtonDown(_aEvent); +} + +sal_Bool SAL_CALL OStatusbarController::mouseMove( const css::awt::MouseEvent& _aEvent) +{ + return m_rController.is() && m_rController->mouseMove(_aEvent); +} + +sal_Bool SAL_CALL OStatusbarController::mouseButtonUp( const css::awt::MouseEvent& _aEvent) +{ + return m_rController.is() && m_rController->mouseButtonUp(_aEvent); +} + +void SAL_CALL OStatusbarController::command( + const css::awt::Point& aPos, + ::sal_Int32 nCommand, + sal_Bool bMouseEvent, + const css::uno::Any& aData ) +{ + if ( m_rController.is() ) + m_rController->command( aPos, nCommand, bMouseEvent, aData ); +} + +void SAL_CALL OStatusbarController::paint( + const css::uno::Reference< css::awt::XGraphics >& xGraphics, + const css::awt::Rectangle& rOutputRectangle, + ::sal_Int32 nStyle ) +{ + if ( m_rController.is() ) + m_rController->paint( xGraphics, rOutputRectangle, nStyle ); +} + +void SAL_CALL OStatusbarController::click( + const css::awt::Point& aPos ) +{ + if ( m_rController.is() ) + m_rController->click( aPos ); +} + +void SAL_CALL OStatusbarController::doubleClick( + const css::awt::Point& aPos ) +{ + if ( m_rController.is() ) + m_rController->doubleClick( aPos ); +} + +void SAL_CALL OStatusbarController::update() +{ + ::svt::StatusbarController::update(); + if ( m_rController.is() ) + m_rController->update(); +} + +// XComponent +void SAL_CALL OStatusbarController::dispose() +{ + if ( m_rController.is() ) + ::comphelper::disposeComponent( m_rController ); + + svt::StatusbarController::dispose(); +} + +} // rptui + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +reportdesign_OStatusbarController_get_implementation( + css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&) +{ + return cppu::acquire(new rptui::OStatusbarController(context)); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |