diff options
Diffstat (limited to 'svx/source/form')
50 files changed, 33739 insertions, 0 deletions
diff --git a/svx/source/form/ParseContext.cxx b/svx/source/form/ParseContext.cxx new file mode 100644 index 000000000..636341791 --- /dev/null +++ b/svx/source/form/ParseContext.cxx @@ -0,0 +1,198 @@ +/* -*- 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/macros.h> +#include <svx/ParseContext.hxx> +#include <svx/strings.hrc> + +#include <svx/dialmgr.hxx> + +#include <i18nlangtag/languagetag.hxx> +#include <unotools/syslocale.hxx> +#include <vcl/svapp.hxx> +#include <osl/diagnose.h> +#include <fmstring.hrc> +#include <mutex> + +using namespace svxform; +using namespace ::connectivity; + +OSystemParseContext::OSystemParseContext() + : IParseContext() +{ + for (size_t i = 0; i < SAL_N_ELEMENTS(RID_RSC_SQL_INTERNATIONAL); ++i) + m_aLocalizedKeywords.push_back(SvxResId(RID_RSC_SQL_INTERNATIONAL[i])); +} + +OSystemParseContext::~OSystemParseContext() +{ +} + +css::lang::Locale OSystemParseContext::getPreferredLocale( ) const +{ + return SvtSysLocale().GetLanguageTag().getLocale(); +} + +OUString OSystemParseContext::getErrorMessage(ErrorCode _eCode) const +{ + OUString aMsg; + SolarMutexGuard aGuard; + switch (_eCode) + { + case ErrorCode::General: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_ERROR); break; + case ErrorCode::ValueNoLike: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_VALUE_NO_LIKE); break; + case ErrorCode::FieldNoLike: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_FIELD_NO_LIKE); break; + case ErrorCode::InvalidCompare: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_CRIT_NO_COMPARE); break; + case ErrorCode::InvalidIntCompare: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_INT_NO_VALID); break; + case ErrorCode::InvalidDateCompare: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_ACCESS_DAT_NO_VALID); break; + case ErrorCode::InvalidRealCompare: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_REAL_NO_VALID); break; + case ErrorCode::InvalidTableNosuch: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_TABLE); break; + case ErrorCode::InvalidTableOrQuery: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_TABLE_OR_QUERY); break; + case ErrorCode::InvalidColumn: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_COLUMN); break; + case ErrorCode::InvalidTableExist: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_TABLE_EXISTS); break; + case ErrorCode::InvalidQueryExist: aMsg = SvxResId(RID_STR_SVT_SQL_SYNTAX_QUERY_EXISTS); break; + default: break; + } + return aMsg; +} + +OString OSystemParseContext::getIntlKeywordAscii(InternationalKeyCode _eKey) const +{ + size_t nIndex = 0; + switch ( _eKey ) + { + case InternationalKeyCode::Like: nIndex = 0; break; + case InternationalKeyCode::Not: nIndex = 1; break; + case InternationalKeyCode::Null: nIndex = 2; break; + case InternationalKeyCode::True: nIndex = 3; break; + case InternationalKeyCode::False: nIndex = 4; break; + case InternationalKeyCode::Is: nIndex = 5; break; + case InternationalKeyCode::Between: nIndex = 6; break; + case InternationalKeyCode::Or: nIndex = 7; break; + case InternationalKeyCode::And: nIndex = 8; break; + case InternationalKeyCode::Avg: nIndex = 9; break; + case InternationalKeyCode::Count: nIndex = 10; break; + case InternationalKeyCode::Max: nIndex = 11; break; + case InternationalKeyCode::Min: nIndex = 12; break; + case InternationalKeyCode::Sum: nIndex = 13; break; + case InternationalKeyCode::Every: nIndex = 14; break; + case InternationalKeyCode::Any: nIndex = 15; break; + case InternationalKeyCode::Some: nIndex = 16; break; + case InternationalKeyCode::StdDevPop: nIndex = 17; break; + case InternationalKeyCode::StdDevSamp: nIndex = 18; break; + case InternationalKeyCode::VarSamp: nIndex = 19; break; + case InternationalKeyCode::VarPop: nIndex = 20; break; + case InternationalKeyCode::Collect: nIndex = 21; break; + case InternationalKeyCode::Fusion: nIndex = 22; break; + case InternationalKeyCode::Intersection: nIndex = 23; break; + case InternationalKeyCode::None: + OSL_FAIL( "OSystemParseContext::getIntlKeywordAscii: illegal argument!" ); + break; + } + + OSL_ENSURE( nIndex < m_aLocalizedKeywords.size(), "OSystemParseContext::getIntlKeywordAscii: invalid index!" ); + + OString sKeyword; + if ( nIndex < m_aLocalizedKeywords.size() ) + sKeyword = OUStringToOString(m_aLocalizedKeywords[nIndex], RTL_TEXTENCODING_UTF8); + return sKeyword; +} + + +IParseContext::InternationalKeyCode OSystemParseContext::getIntlKeyCode(const OString& rToken) const +{ + static const IParseContext::InternationalKeyCode Intl_TokenID[] = + { + InternationalKeyCode::Like, InternationalKeyCode::Not, InternationalKeyCode::Null, InternationalKeyCode::True, + InternationalKeyCode::False, InternationalKeyCode::Is, InternationalKeyCode::Between, InternationalKeyCode::Or, + InternationalKeyCode::And, InternationalKeyCode::Avg, InternationalKeyCode::Count, InternationalKeyCode::Max, + InternationalKeyCode::Min, InternationalKeyCode::Sum, InternationalKeyCode::Every, + InternationalKeyCode::Any, InternationalKeyCode::Some, InternationalKeyCode::StdDevPop, + InternationalKeyCode::StdDevSamp, InternationalKeyCode::VarSamp, InternationalKeyCode::VarPop, + InternationalKeyCode::Collect, InternationalKeyCode::Fusion, InternationalKeyCode::Intersection + }; + + sal_uInt32 const nCount = SAL_N_ELEMENTS(Intl_TokenID); + for (sal_uInt32 i = 0; i < nCount; i++) + { + OString aKey = getIntlKeywordAscii(Intl_TokenID[i]); + if (rToken.equalsIgnoreAsciiCase(aKey)) + return Intl_TokenID[i]; + } + + return InternationalKeyCode::None; +} + + +namespace +{ + + std::mutex& getSafetyMutex() + { + static ::std::mutex s_aSafety; + return s_aSafety; + } + + int s_nCounter; + + OSystemParseContext* getSharedContext(OSystemParseContext* _pContext, bool _bSet) + { + static OSystemParseContext* s_pSharedContext = nullptr; + if ( _pContext && !s_pSharedContext ) + { + s_pSharedContext = _pContext; + return s_pSharedContext; + } + if ( _bSet ) + { + OSystemParseContext* pReturn = _pContext ? _pContext : s_pSharedContext; + s_pSharedContext = _pContext; + return pReturn; + } + return s_pSharedContext; + } + +} + +OParseContextClient::OParseContextClient() +{ + std::scoped_lock aGuard( getSafetyMutex() ); + ++s_nCounter; + if ( 1 == s_nCounter ) + { // first instance + getSharedContext( new OSystemParseContext, false ); + } +} + + +OParseContextClient::~OParseContextClient() +{ + std::scoped_lock aGuard( getSafetyMutex() ); + --s_nCounter; + if ( 0 == s_nCounter ) + delete getSharedContext(nullptr,true); +} + +const OSystemParseContext* OParseContextClient::getParseContext() const +{ + return getSharedContext(nullptr, false); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/dataaccessdescriptor.cxx b/svx/source/form/dataaccessdescriptor.cxx new file mode 100644 index 000000000..78538fbeb --- /dev/null +++ b/svx/source/form/dataaccessdescriptor.cxx @@ -0,0 +1,356 @@ +/* -*- 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/dataaccessdescriptor.hxx> +#include <osl/diagnose.h> +#include <com/sun/star/ucb/XContent.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <tools/urlobj.hxx> +#include <map> + +namespace svx +{ + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::ucb; + + typedef std::pair<OUString const, DataAccessDescriptorProperty> PropertyMapEntry; + + class ODADescriptorImpl + { + protected: + bool m_bSetOutOfDate : 1; + bool m_bSequenceOutOfDate : 1; + + public: + typedef ::std::map< DataAccessDescriptorProperty, Any > DescriptorValues; + DescriptorValues m_aValues; + Sequence< PropertyValue > m_aAsSequence; + + typedef ::std::map< OUString, DataAccessDescriptorProperty > MapString2PropertyEntry; + + public: + ODADescriptorImpl(); + ODADescriptorImpl(const ODADescriptorImpl& _rSource); + + void invalidateExternRepresentations(); + + void updateSequence(); + + /** builds the descriptor from a property value sequence + @return <TRUE/> + if and only if the sequence contained valid properties only + */ + bool buildFrom( const Sequence< PropertyValue >& _rValues ); + + /** builds the descriptor from a property set + @return <TRUE/> + if and only if the set contained valid properties only + */ + bool buildFrom( const Reference< XPropertySet >& _rValues ); + + protected: + static PropertyValue buildPropertyValue( const DescriptorValues::const_iterator& _rPos ); + static const MapString2PropertyEntry& getPropertyMap( ); + static PropertyMapEntry const * getPropertyMapEntry( const DescriptorValues::const_iterator& _rPos ); + }; + + ODADescriptorImpl::ODADescriptorImpl() + :m_bSetOutOfDate(true) + ,m_bSequenceOutOfDate(true) + { + } + + ODADescriptorImpl::ODADescriptorImpl(const ODADescriptorImpl& _rSource) + :m_bSetOutOfDate( _rSource.m_bSetOutOfDate ) + ,m_bSequenceOutOfDate( _rSource.m_bSequenceOutOfDate ) + ,m_aValues( _rSource.m_aValues ) + { + if (!m_bSequenceOutOfDate) + m_aAsSequence = _rSource.m_aAsSequence; + } + + bool ODADescriptorImpl::buildFrom( const Sequence< PropertyValue >& _rValues ) + { + const MapString2PropertyEntry& rProperties = getPropertyMap(); + + bool bValidPropsOnly = true; + + // loop through the sequence, and fill our m_aValues + for (const PropertyValue& rValue : _rValues) + { + MapString2PropertyEntry::const_iterator aPropPos = rProperties.find( rValue.Name ); + if ( aPropPos != rProperties.end() ) + { + DataAccessDescriptorProperty eProperty = aPropPos->second; + m_aValues[eProperty] = rValue.Value; + } + else + // unknown property + bValidPropsOnly = false; + } + + if (bValidPropsOnly) + { + m_aAsSequence = _rValues; + m_bSequenceOutOfDate = false; + } + else + m_bSequenceOutOfDate = true; + + return bValidPropsOnly; + } + + bool ODADescriptorImpl::buildFrom( const Reference< XPropertySet >& _rxValues ) + { + Reference< XPropertySetInfo > xPropInfo; + if (_rxValues.is()) + xPropInfo = _rxValues->getPropertySetInfo(); + if (!xPropInfo.is()) + { + OSL_FAIL("ODADescriptorImpl::buildFrom: invalid property set!"); + return false; + } + + // build a PropertyValue sequence with the current values + const Sequence< Property > aProperties = xPropInfo->getProperties(); + + Sequence< PropertyValue > aValues(aProperties.getLength()); + PropertyValue* pValues = aValues.getArray(); + + for (const Property& rProperty : aProperties) + { + pValues->Name = rProperty.Name; + pValues->Value = _rxValues->getPropertyValue(rProperty.Name); + ++pValues; + } + + bool bValidPropsOnly = buildFrom(aValues); + m_bSetOutOfDate = !bValidPropsOnly; + + return bValidPropsOnly; + } + + void ODADescriptorImpl::invalidateExternRepresentations() + { + m_bSetOutOfDate = true; + m_bSequenceOutOfDate = true; + } + + const ODADescriptorImpl::MapString2PropertyEntry& ODADescriptorImpl::getPropertyMap( ) + { + // the properties we know + static MapString2PropertyEntry s_aProperties + { + { OUString("ActiveConnection"), DataAccessDescriptorProperty::Connection, }, + { OUString("BookmarkSelection"), DataAccessDescriptorProperty::BookmarkSelection, }, + { OUString("Column"), DataAccessDescriptorProperty::ColumnObject, }, + { OUString("ColumnName"), DataAccessDescriptorProperty::ColumnName, }, + { OUString("Command"), DataAccessDescriptorProperty::Command, }, + { OUString("CommandType"), DataAccessDescriptorProperty::CommandType, }, + { OUString("Component"), DataAccessDescriptorProperty::Component, }, + { OUString("ConnectionResource"), DataAccessDescriptorProperty::ConnectionResource, }, + { OUString("Cursor"), DataAccessDescriptorProperty::Cursor, }, + { OUString("DataSourceName"), DataAccessDescriptorProperty::DataSource, }, + { OUString("DatabaseLocation"), DataAccessDescriptorProperty::DatabaseLocation, }, + { OUString("EscapeProcessing"), DataAccessDescriptorProperty::EscapeProcessing, }, + { OUString("Filter"), DataAccessDescriptorProperty::Filter, }, + { OUString("Selection"), DataAccessDescriptorProperty::Selection, } + }; + + return s_aProperties; + } + + PropertyMapEntry const * ODADescriptorImpl::getPropertyMapEntry( const DescriptorValues::const_iterator& _rPos ) + { + const MapString2PropertyEntry& rProperties = getPropertyMap(); + + DataAccessDescriptorProperty nNeededHandle = _rPos->first; + + auto loop = std::find_if(rProperties.begin(), rProperties.end(), + [&nNeededHandle](const MapString2PropertyEntry::value_type& rProp) { return nNeededHandle == rProp.second; }); + if (loop != rProperties.end()) + return &*loop; + throw RuntimeException(); + } + + PropertyValue ODADescriptorImpl::buildPropertyValue( const DescriptorValues::const_iterator& _rPos ) + { + // the map entry + PropertyMapEntry const * pProperty = getPropertyMapEntry( _rPos ); + + // build the property value + PropertyValue aReturn; + aReturn.Name = pProperty->first; + aReturn.Handle = static_cast<sal_Int32>(pProperty->second); + aReturn.Value = _rPos->second; + aReturn.State = PropertyState_DIRECT_VALUE; + + // outta here + return aReturn; + } + + void ODADescriptorImpl::updateSequence() + { + if (!m_bSequenceOutOfDate) + return; + + m_aAsSequence.realloc(m_aValues.size()); + PropertyValue* pValue = m_aAsSequence.getArray(); + + // loop through all our values + for ( DescriptorValues::const_iterator aLoop = m_aValues.begin(); + aLoop != m_aValues.end(); + ++aLoop, ++pValue + ) + { + *pValue = buildPropertyValue(aLoop); + } + + // don't need to rebuild next time + m_bSequenceOutOfDate = false; + } + + ODataAccessDescriptor::ODataAccessDescriptor() + :m_pImpl(new ODADescriptorImpl) + { + } + + ODataAccessDescriptor::ODataAccessDescriptor( const ODataAccessDescriptor& _rSource ) + :m_pImpl(new ODADescriptorImpl(*_rSource.m_pImpl)) + { + } + + ODataAccessDescriptor::ODataAccessDescriptor(ODataAccessDescriptor&& _rSource) noexcept + :m_pImpl(std::move(_rSource.m_pImpl)) + { + } + + ODataAccessDescriptor& ODataAccessDescriptor::operator=(const ODataAccessDescriptor& _rSource) + { + if (this != &_rSource) + m_pImpl.reset(new ODADescriptorImpl(*_rSource.m_pImpl)); + return *this; + } + + ODataAccessDescriptor& ODataAccessDescriptor::operator=(ODataAccessDescriptor&& _rSource) noexcept + { + m_pImpl = std::move(_rSource.m_pImpl); + return *this; + } + + ODataAccessDescriptor::ODataAccessDescriptor( const Reference< XPropertySet >& _rValues ) + :m_pImpl(new ODADescriptorImpl) + { + m_pImpl->buildFrom(_rValues); + } + + ODataAccessDescriptor::ODataAccessDescriptor( const Any& _rValues ) + :m_pImpl(new ODADescriptorImpl) + { + // check if we know the format in the Any + Sequence< PropertyValue > aValues; + Reference< XPropertySet > xValues; + if ( _rValues >>= aValues ) + m_pImpl->buildFrom( aValues ); + else if ( _rValues >>= xValues ) + m_pImpl->buildFrom( xValues ); + } + + ODataAccessDescriptor::ODataAccessDescriptor( const Sequence< PropertyValue >& _rValues ) + :m_pImpl(new ODADescriptorImpl) + { + m_pImpl->buildFrom(_rValues); + } + + ODataAccessDescriptor::~ODataAccessDescriptor() + { + } + + void ODataAccessDescriptor::clear() + { + m_pImpl->m_aValues.clear(); + } + + void ODataAccessDescriptor::erase(DataAccessDescriptorProperty _eWhich) + { + OSL_ENSURE(has(_eWhich), "ODataAccessDescriptor::erase: invalid call!"); + if (has(_eWhich)) + m_pImpl->m_aValues.erase(_eWhich); + } + + bool ODataAccessDescriptor::has(DataAccessDescriptorProperty _eWhich) const + { + return m_pImpl->m_aValues.find(_eWhich) != m_pImpl->m_aValues.end(); + } + + const Any& ODataAccessDescriptor::operator [] ( DataAccessDescriptorProperty _eWhich ) const + { + if (!has(_eWhich)) + { + OSL_FAIL("ODataAccessDescriptor::operator[]: invalid accessor!"); + static const Any aDummy; + return aDummy; + } + + return m_pImpl->m_aValues[_eWhich]; + } + + Any& ODataAccessDescriptor::operator[] ( DataAccessDescriptorProperty _eWhich ) + { + m_pImpl->invalidateExternRepresentations(); + return m_pImpl->m_aValues[_eWhich]; + } + + void ODataAccessDescriptor::initializeFrom(const Sequence< PropertyValue >& _rValues) + { + clear(); + m_pImpl->buildFrom(_rValues); + } + + Sequence< PropertyValue > const & ODataAccessDescriptor::createPropertyValueSequence() + { + m_pImpl->updateSequence(); + return m_pImpl->m_aAsSequence; + } + + OUString ODataAccessDescriptor::getDataSource() const + { + OUString sDataSourceName; + if ( has(DataAccessDescriptorProperty::DataSource) ) + (*this)[DataAccessDescriptorProperty::DataSource] >>= sDataSourceName; + else if ( has(DataAccessDescriptorProperty::DatabaseLocation) ) + (*this)[DataAccessDescriptorProperty::DatabaseLocation] >>= sDataSourceName; + return sDataSourceName; + } + + void ODataAccessDescriptor::setDataSource(const OUString& _sDataSourceNameOrLocation) + { + if ( !_sDataSourceNameOrLocation.isEmpty() ) + { + INetURLObject aURL(_sDataSourceNameOrLocation); + (*this)[ (( aURL.GetProtocol() == INetProtocol::File ) ? DataAccessDescriptorProperty::DatabaseLocation : DataAccessDescriptorProperty::DataSource)] <<= _sDataSourceNameOrLocation; + } + else + (*this)[ DataAccessDescriptorProperty::DataSource ] <<= OUString(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/databaselocationinput.cxx b/svx/source/form/databaselocationinput.cxx new file mode 100644 index 000000000..018fd3f5e --- /dev/null +++ b/svx/source/form/databaselocationinput.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 <svx/databaselocationinput.hxx> +#include <svx/dialmgr.hxx> + +#include <svx/strings.hrc> + +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> + +#include <comphelper/namedvaluecollection.hxx> +#include <rtl/ustrbuf.hxx> +#include <sfx2/filedlghelper.hxx> +#include <svl/filenotation.hxx> +#include <svtools/inettbc.hxx> +#include <tools/diagnose_ex.h> +#include <unotools/confignode.hxx> +#include <unotools/ucbhelper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> + +namespace svx +{ + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::XComponentContext; + using ::com::sun::star::container::XNameAccess; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::uno::Exception; + + namespace TemplateDescription = ::com::sun::star::ui::dialogs::TemplateDescription; + + class DatabaseLocationInputController_Impl + { + public: + DatabaseLocationInputController_Impl( + const Reference<XComponentContext>& _rContext, + SvtURLBox& _rLocationInput, + weld::Button& _rBrowseButton, + weld::Window& _rDialog + ); + + bool prepareCommit(); + void setURL( const OUString& _rURL ); + OUString getURL() const; + + private: + void impl_initFilterProperties_nothrow(); + void impl_onBrowseButtonClicked(); + OUString impl_getCurrentURL() const; + + DECL_LINK( OnButtonAction, weld::Button&, void ); + + private: + const Reference<XComponentContext> m_xContext; + SvtURLBox& m_rLocationInput; + weld::Window& m_rDialog; + Sequence< OUString > m_aFilterExtensions; + OUString m_sFilterUIName; + bool m_bNeedExistenceCheck; + }; + + DatabaseLocationInputController_Impl::DatabaseLocationInputController_Impl(const Reference<XComponentContext>& _rContext, + SvtURLBox& _rLocationInput, weld::Button& _rBrowseButton, weld::Window& _rDialog) + :m_xContext( _rContext ) + ,m_rLocationInput( _rLocationInput ) + ,m_rDialog( _rDialog ) + ,m_bNeedExistenceCheck( true ) + { + impl_initFilterProperties_nothrow(); + + // forward the allowed extensions to the input control + OUStringBuffer aExtensionList; + for ( auto const & extension : std::as_const(m_aFilterExtensions) ) + { + aExtensionList.append( extension ); + aExtensionList.append( ';' ); + } + m_rLocationInput.SetFilter( aExtensionList.makeStringAndClear() ); + _rBrowseButton.connect_clicked(LINK(this, DatabaseLocationInputController_Impl, OnButtonAction)); + } + + bool DatabaseLocationInputController_Impl::prepareCommit() + { + OUString sURL( impl_getCurrentURL() ); + if ( sURL.isEmpty() ) + return false; + + // check if the name exists + if ( m_bNeedExistenceCheck ) + { + if ( ::utl::UCBContentHelper::Exists( sURL ) ) + { + std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(m_rLocationInput.getWidget(), + VclMessageType::Question, VclButtonsType::YesNo, + SvxResId(RID_STR_ALREADYEXISTOVERWRITE))); + if (xQueryBox->run() != RET_YES) + return false; + } + } + + return true; + } + + void DatabaseLocationInputController_Impl::setURL( const OUString& _rURL ) + { + ::svt::OFileNotation aTransformer( _rURL ); + m_rLocationInput.set_entry_text( aTransformer.get( ::svt::OFileNotation::N_SYSTEM ) ); + } + + OUString DatabaseLocationInputController_Impl::getURL() const + { + return impl_getCurrentURL(); + } + + void DatabaseLocationInputController_Impl::impl_initFilterProperties_nothrow() + { + try + { + // get the name of the default filter for database documents + ::utl::OConfigurationTreeRoot aConfig( + ::utl::OConfigurationTreeRoot::createWithComponentContext( + m_xContext, + "/org.openoffice.Setup/Office/Factories/com.sun.star.sdb.OfficeDatabaseDocument" + ) ); + OUString sDatabaseFilter; + OSL_VERIFY( aConfig.getNodeValue( "ooSetupFactoryActualFilter" ) >>= sDatabaseFilter ); + + // get the type this filter is responsible for + Reference< XNameAccess > xFilterFactory( + m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.FilterFactory", m_xContext), + UNO_QUERY_THROW ); + ::comphelper::NamedValueCollection aFilterProperties( xFilterFactory->getByName( sDatabaseFilter ) ); + OUString sDocumentType = aFilterProperties.getOrDefault( "Type", OUString() ); + + // get the extension(s) for this type + Reference< XNameAccess > xTypeDetection( + m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.TypeDetection", m_xContext), + UNO_QUERY_THROW ); + + ::comphelper::NamedValueCollection aTypeProperties( xTypeDetection->getByName( sDocumentType ) ); + m_aFilterExtensions = aTypeProperties.getOrDefault( "Extensions", m_aFilterExtensions ); + m_sFilterUIName = aTypeProperties.getOrDefault( "UIName", m_sFilterUIName ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + // ensure we have at least one extension + OSL_ENSURE( m_aFilterExtensions.hasElements(), + "DatabaseLocationInputController_Impl::impl_initFilterProperties_nothrow: unable to determine the file extension(s)!" ); + if ( !m_aFilterExtensions.hasElements() ) + { + m_aFilterExtensions = { "*.odb" }; + } + } + + IMPL_LINK_NOARG(DatabaseLocationInputController_Impl, OnButtonAction, weld::Button&, void) + { + impl_onBrowseButtonClicked(); + } + + OUString DatabaseLocationInputController_Impl::impl_getCurrentURL() const + { + OUString sCurrentFile( m_rLocationInput.get_active_text() ); + if ( !sCurrentFile.isEmpty() ) + { + ::svt::OFileNotation aCurrentFile( sCurrentFile ); + sCurrentFile = aCurrentFile.get( ::svt::OFileNotation::N_URL ); + } + return sCurrentFile; + } + + void DatabaseLocationInputController_Impl::impl_onBrowseButtonClicked() + { + ::sfx2::FileDialogHelper aFileDlg( + TemplateDescription::FILESAVE_AUTOEXTENSION, + FileDialogFlags::NONE, + &m_rDialog + ); + aFileDlg.SetDisplayDirectory( impl_getCurrentURL() ); + + aFileDlg.AddFilter( m_sFilterUIName, "*." + m_aFilterExtensions[0] ); + aFileDlg.SetCurrentFilter( m_sFilterUIName ); + + if ( aFileDlg.Execute() == ERRCODE_NONE ) + { + INetURLObject aURL( aFileDlg.GetPath() ); + if( aURL.GetProtocol() != INetProtocol::NotValid ) + { + ::svt::OFileNotation aFileNotation( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + m_rLocationInput.set_entry_text(aFileNotation.get(::svt::OFileNotation::N_SYSTEM)); + m_rLocationInput.trigger_changed(); + // the dialog already checked for the file's existence, so we don't need to, again + m_bNeedExistenceCheck = false; + } + } + } + + DatabaseLocationInputController::DatabaseLocationInputController( const Reference<XComponentContext>& _rContext, + SvtURLBox& _rLocationInput, weld::Button& _rBrowseButton, weld::Window& _rDialog ) + :m_pImpl( new DatabaseLocationInputController_Impl( _rContext, _rLocationInput, _rBrowseButton, _rDialog ) ) + { + } + + DatabaseLocationInputController::~DatabaseLocationInputController() + { + } + + bool DatabaseLocationInputController::prepareCommit() + { + return m_pImpl->prepareCommit(); + } + + void DatabaseLocationInputController::setURL( const OUString& _rURL ) + { + m_pImpl->setURL( _rURL ); + } + + OUString DatabaseLocationInputController::getURL() const + { + return m_pImpl->getURL(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/datalistener.cxx b/svx/source/form/datalistener.cxx new file mode 100644 index 000000000..fda74a92c --- /dev/null +++ b/svx/source/form/datalistener.cxx @@ -0,0 +1,91 @@ +/* -*- 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 <datalistener.hxx> +#include <datanavi.hxx> + +#include <sal/log.hxx> + +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::xml::dom::events; + + +namespace svxform +{ + + + DataListener::DataListener( DataNavigatorWindow* pNaviWin ) : + + m_pNaviWin( pNaviWin ) + + { + DBG_ASSERT( m_pNaviWin, "DataListener::Ctor(): no navigator win" ); + } + + DataListener::~DataListener() + { + } + + // XContainerListener + void SAL_CALL DataListener::elementInserted( const ContainerEvent& /*Event*/ ) + { + m_pNaviWin->NotifyChanges(); + } + + void SAL_CALL DataListener::elementRemoved( const ContainerEvent& /*Event*/ ) + { + m_pNaviWin->NotifyChanges(); + } + + void SAL_CALL DataListener::elementReplaced( const ContainerEvent& /*Event*/ ) + { + m_pNaviWin->NotifyChanges(); + } + + // XFrameActionListener + void SAL_CALL DataListener::frameAction( const FrameActionEvent& rActionEvt ) + { + if ( FrameAction_COMPONENT_ATTACHED == rActionEvt.Action || + FrameAction_COMPONENT_REATTACHED == rActionEvt.Action ) + { + m_pNaviWin->NotifyChanges( FrameAction_COMPONENT_REATTACHED == rActionEvt.Action ); + } + } + + // xml::dom::events::XEventListener + void SAL_CALL DataListener::handleEvent( const Reference< XEvent >& /*evt*/ ) + { + m_pNaviWin->NotifyChanges(); + } + + // lang::XEventListener + void SAL_CALL DataListener::disposing( const EventObject& /*Source*/ ) + { + SAL_WARN( "svx.form", "disposing" ); + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/datanavi.cxx b/svx/source/form/datanavi.cxx new file mode 100644 index 000000000..80b4dab1b --- /dev/null +++ b/svx/source/form/datanavi.cxx @@ -0,0 +1,3090 @@ +/* -*- 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 <memory> + +#include <sal/log.hxx> +#include <datanavi.hxx> +#include <fmservs.hxx> + +#include <bitmaps.hlst> +#include <fpicker/strings.hrc> +#include <o3tl/safeint.hxx> +#include <o3tl/string_view.hxx> +#include <svx/svxids.hrc> +#include <tools/diagnose_ex.h> +#include <unotools/resmgr.hxx> +#include <svx/xmlexchg.hxx> +#include <unotools/viewoptions.hxx> +#include <sfx2/filedlghelper.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <vcl/commandevent.hxx> +#include <vcl/event.hxx> +#include <vcl/weld.hxx> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/container/XSet.hpp> +#include <com/sun/star/frame/XController.hpp> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +#include <com/sun/star/xforms/XFormsSupplier.hpp> +#include <com/sun/star/xml/dom/XDocument.hpp> +#include <comphelper/string.hxx> + +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::datatransfer; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::xml::dom::events; +using namespace ::svx; + +constexpr OUStringLiteral CFGNAME_DATANAVIGATOR = u"DataNavigator"; +constexpr OUStringLiteral CFGNAME_SHOWDETAILS = u"ShowDetails"; +constexpr OUStringLiteral MSG_VARIABLE = u"%1"; +constexpr OUStringLiteral MODELNAME = u"$MODELNAME"; +constexpr OUStringLiteral INSTANCENAME = u"$INSTANCENAME"; +constexpr OUStringLiteral ELEMENTNAME = u"$ELEMENTNAME"; +constexpr OUStringLiteral ATTRIBUTENAME = u"$ATTRIBUTENAME"; +constexpr OUStringLiteral SUBMISSIONNAME = u"$SUBMISSIONNAME"; +constexpr OUStringLiteral BINDINGNAME = u"$BINDINGNAME"; + + +namespace svxform +{ + + // properties of instance + constexpr OUStringLiteral PN_INSTANCE_MODEL = u"Instance"; + constexpr OUStringLiteral PN_INSTANCE_ID = u"ID"; + constexpr OUStringLiteral PN_INSTANCE_URL = u"URL"; + + // properties of binding + constexpr OUStringLiteral PN_BINDING_ID = u"BindingID"; + constexpr OUStringLiteral PN_BINDING_EXPR = u"BindingExpression"; + constexpr OUStringLiteral PN_BINDING_MODEL = u"Model"; + constexpr OUStringLiteral PN_BINDING_NAMESPACES = u"ModelNamespaces"; + constexpr OUStringLiteral PN_READONLY_EXPR = u"ReadonlyExpression"; + constexpr OUStringLiteral PN_RELEVANT_EXPR = u"RelevantExpression"; + constexpr OUStringLiteral PN_REQUIRED_EXPR = u"RequiredExpression"; + constexpr OUStringLiteral PN_CONSTRAINT_EXPR = u"ConstraintExpression"; + constexpr OUStringLiteral PN_CALCULATE_EXPR = u"CalculateExpression"; + constexpr OUStringLiteral PN_BINDING_TYPE = u"Type"; + + // properties of submission + constexpr OUStringLiteral PN_SUBMISSION_ID = u"ID"; + constexpr OUStringLiteral PN_SUBMISSION_BIND = u"Bind"; + constexpr OUStringLiteral PN_SUBMISSION_REF = u"Ref"; + constexpr OUStringLiteral PN_SUBMISSION_ACTION = u"Action"; + constexpr OUStringLiteral PN_SUBMISSION_METHOD = u"Method"; + constexpr OUStringLiteral PN_SUBMISSION_REPLACE = u"Replace"; + + // other const strings + constexpr OUStringLiteral TRUE_VALUE = u"true()"; + constexpr OUStringLiteral NEW_ELEMENT = u"newElement"; + constexpr OUStringLiteral NEW_ATTRIBUTE = u"newAttribute"; + constexpr OUStringLiteral EVENTTYPE_CHARDATA = u"DOMCharacterDataModified"; + constexpr OUStringLiteral EVENTTYPE_ATTR = u"DOMAttrModified"; + + #define MIN_PAGE_COUNT 3 // at least one instance, one submission and one binding page + + struct ItemNode + { + Reference< css::xml::dom::XNode > m_xNode; + Reference< XPropertySet > m_xPropSet; + + explicit ItemNode( const Reference< css::xml::dom::XNode >& _rxNode ) : + m_xNode( _rxNode ) {} + explicit ItemNode( const Reference< XPropertySet >& _rxSet ) : + m_xPropSet( _rxSet ) {} + }; + + DataTreeDropTarget::DataTreeDropTarget(weld::TreeView& rWidget) + : DropTargetHelper(rWidget.get_drop_target()) + { + } + + sal_Int8 DataTreeDropTarget::AcceptDrop( const AcceptDropEvent& /*rEvt*/ ) + { + return DND_ACTION_NONE; + } + + sal_Int8 DataTreeDropTarget::ExecuteDrop( const ExecuteDropEvent& /*rEvt*/ ) + { + return DND_ACTION_NONE; + } + + IMPL_LINK(XFormsPage, PopupMenuHdl, const CommandEvent&, rCEvt, bool) + { + if (rCEvt.GetCommand() != CommandEventId::ContextMenu) + return false; + + Point aPos(rCEvt.GetMousePosPixel()); + + if (m_xItemList->get_dest_row_at_pos(aPos, m_xScratchIter.get(), false) && !m_xItemList->is_selected(*m_xScratchIter)) + { + m_xItemList->select(*m_xScratchIter); + ItemSelectHdl(*m_xItemList); + } + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xItemList.get(), "svx/ui/formdatamenu.ui")); + std::unique_ptr<weld::Menu> xMenu(xBuilder->weld_menu("menu")); + + if (DGTInstance == m_eGroup) + xMenu->set_visible("additem", false); + else + { + xMenu->set_visible("addelement", false); + xMenu->set_visible("addattribute", false); + + if (DGTSubmission == m_eGroup) + { + xMenu->set_label("additem", SvxResId(RID_STR_DATANAV_ADD_SUBMISSION)); + xMenu->set_label("edit", SvxResId(RID_STR_DATANAV_EDIT_SUBMISSION)); + xMenu->set_label("delete", SvxResId(RID_STR_DATANAV_REMOVE_SUBMISSION)); + } + else + { + xMenu->set_label("additem", SvxResId(RID_STR_DATANAV_ADD_BINDING)); + xMenu->set_label("edit", SvxResId(RID_STR_DATANAV_EDIT_BINDING)); + xMenu->set_label("delete", SvxResId(RID_STR_DATANAV_REMOVE_BINDING)); + } + } + EnableMenuItems(xMenu.get()); + OString sCommand = xMenu->popup_at_rect(m_xItemList.get(), tools::Rectangle(aPos, Size(1,1))); + if (!sCommand.isEmpty()) + DoMenuAction(sCommand); + return true; + } + + void XFormsPage::DeleteAndClearTree() + { + m_xItemList->all_foreach([this](weld::TreeIter& rEntry) { + delete weld::fromId<ItemNode*>(m_xItemList->get_id(rEntry)); + return false; + }); + m_xItemList->clear(); + } + + XFormsPage::XFormsPage(weld::Container* pPage, DataNavigatorWindow* _pNaviWin, DataGroupType _eGroup) + : BuilderPage(pPage, nullptr, "svx/ui/xformspage.ui", "XFormsPage") + , m_pParent(pPage) + , m_xToolBox(m_xBuilder->weld_toolbar("toolbar")) + , m_xItemList(m_xBuilder->weld_tree_view("items")) + , m_xScratchIter(m_xItemList->make_iterator()) + , m_aDropHelper(*m_xItemList) + , m_pNaviWin(_pNaviWin) + , m_bHasModel(false) + , m_eGroup(_eGroup) + , m_bLinkOnce(false) + { + m_xItemList->set_show_expanders(DGTInstance == m_eGroup || DGTSubmission == m_eGroup); + + if ( DGTInstance == m_eGroup ) + m_xToolBox->set_item_visible("additem", false); + else + { + m_xToolBox->set_item_visible("addelement", false); + m_xToolBox->set_item_visible("addattribute", false); + + if ( DGTSubmission == m_eGroup ) + { + m_xToolBox->set_item_label("additem", SvxResId(RID_STR_DATANAV_ADD_SUBMISSION)); + m_xToolBox->set_item_label("edit", SvxResId(RID_STR_DATANAV_EDIT_SUBMISSION)); + m_xToolBox->set_item_label("delete", SvxResId(RID_STR_DATANAV_REMOVE_SUBMISSION)); + } + else + { + m_xToolBox->set_item_label("additem", SvxResId(RID_STR_DATANAV_ADD_BINDING)); + m_xToolBox->set_item_label("edit", SvxResId(RID_STR_DATANAV_EDIT_BINDING)); + m_xToolBox->set_item_label("delete", SvxResId(RID_STR_DATANAV_REMOVE_BINDING)); + } + } + + m_xToolBox->connect_clicked(LINK(this, XFormsPage, TbxSelectHdl)); + + m_xItemList->connect_changed(LINK(this, XFormsPage, ItemSelectHdl)); + m_xItemList->connect_key_press(LINK(this, XFormsPage, KeyInputHdl)); + m_xItemList->connect_popup_menu(LINK(this, XFormsPage, PopupMenuHdl)); + ItemSelectHdl(*m_xItemList); + } + + XFormsPage::~XFormsPage() + { + DeleteAndClearTree(); + m_pNaviWin = nullptr; + m_pParent->move(m_xContainer.get(), nullptr); + } + + IMPL_LINK(XFormsPage, TbxSelectHdl, const OString&, rIdent, void) + { + DoToolBoxAction(rIdent); + } + + IMPL_LINK_NOARG(XFormsPage, ItemSelectHdl, weld::TreeView&, void) + { + EnableMenuItems(nullptr); + PrepDnD(); + } + + void XFormsPage::PrepDnD() + { + rtl::Reference<TransferDataContainer> xTransferable(new TransferDataContainer); + m_xItemList->enable_drag_source(xTransferable, DND_ACTION_NONE); + + if (!m_xItemList->get_selected(m_xScratchIter.get())) + { + // no drag without an entry + return; + } + + if ( m_eGroup == DGTBinding ) + { + // for the moment, bindings cannot be dragged. + // #i59395# / 2005-12-15 / frank.schoenheit@sun.com + return; + } + + // GetServiceNameForNode() requires a datatype repository which + // will be automatically build if requested??? + Reference< css::xforms::XModel > xModel( GetXFormsHelper(), UNO_QUERY ); + Reference< css::xforms::XDataTypeRepository > xDataTypes = + xModel->getDataTypeRepository(); + if(!xDataTypes.is()) + return; + + ItemNode *pItemNode = weld::fromId<ItemNode*>(m_xItemList->get_id(*m_xScratchIter)); + if (!pItemNode) + { + // the only known (and allowed?) case where this happens are sub-entries of a submission + // entry + DBG_ASSERT( DGTSubmission == m_eGroup, "DataTreeListBox::StartDrag: how this?" ); + bool bSelected = m_xItemList->iter_parent(*m_xScratchIter); + DBG_ASSERT(bSelected && !m_xItemList->get_iter_depth(*m_xScratchIter), "DataTreeListBox::StartDrag: what kind of entry *is* this?"); + // on the submission page, we have only top-level entries (the submission themself) + // plus direct children of those (facets of a submission) + pItemNode = bSelected ? weld::fromId<ItemNode*>(m_xItemList->get_id(*m_xScratchIter)) : nullptr; + if (!pItemNode) + return; + } + + OXFormsDescriptor desc; + desc.szName = m_xItemList->get_text(*m_xScratchIter); + if(pItemNode->m_xNode.is()) { + // a valid node interface tells us that we need to create a control from a binding + desc.szServiceName = GetServiceNameForNode(pItemNode->m_xNode); + desc.xPropSet = GetBindingForNode(pItemNode->m_xNode); + DBG_ASSERT( desc.xPropSet.is(), "DataTreeListBox::StartDrag(): invalid node binding" ); + } + else { + desc.szServiceName = FM_COMPONENT_COMMANDBUTTON; + desc.xPropSet = pItemNode->m_xPropSet; + } + xTransferable = rtl::Reference<TransferDataContainer>(new OXFormsTransferable(desc)); + m_xItemList->enable_drag_source(xTransferable, DND_ACTION_COPY); + } + + void XFormsPage::AddChildren(const weld::TreeIter* _pParent, + const Reference< css::xml::dom::XNode >& _xNode) + { + DBG_ASSERT( m_xUIHelper.is(), "XFormsPage::AddChildren(): invalid UIHelper" ); + + try + { + Reference< css::xml::dom::XNodeList > xNodeList = _xNode->getChildNodes(); + if ( xNodeList.is() ) + { + bool bShowDetails = m_pNaviWin->IsShowDetails(); + sal_Int32 i, nNodeCount = xNodeList->getLength(); + for ( i = 0; i < nNodeCount; ++i ) + { + Reference< css::xml::dom::XNode > xChild = xNodeList->item(i); + css::xml::dom::NodeType eChildType = xChild->getNodeType(); + OUString aExpImg; + switch ( eChildType ) + { + case css::xml::dom::NodeType_ATTRIBUTE_NODE: + aExpImg = RID_SVXBMP_ATTRIBUTE; + break; + case css::xml::dom::NodeType_ELEMENT_NODE: + aExpImg = RID_SVXBMP_ELEMENT; + break; + case css::xml::dom::NodeType_TEXT_NODE: + aExpImg = RID_SVXBMP_TEXT; + break; + default: + aExpImg = RID_SVXBMP_OTHER; + } + + OUString sName = m_xUIHelper->getNodeDisplayName( xChild, bShowDetails ); + if ( !sName.isEmpty() ) + { + ItemNode* pNode = new ItemNode( xChild ); + OUString sId(weld::toId(pNode)); + std::unique_ptr<weld::TreeIter> xEntry = m_xItemList->make_iterator(); + m_xItemList->insert(_pParent, -1, &sName, &sId, nullptr, nullptr, false, xEntry.get()); + m_xItemList->set_image(*xEntry, aExpImg); + + if ( xChild->hasAttributes() ) + { + Reference< css::xml::dom::XNamedNodeMap > xMap = xChild->getAttributes(); + if ( xMap.is() ) + { + aExpImg = RID_SVXBMP_ATTRIBUTE; + sal_Int32 j, nMapLen = xMap->getLength(); + for ( j = 0; j < nMapLen; ++j ) + { + Reference< css::xml::dom::XNode > xAttr = xMap->item(j); + pNode = new ItemNode( xAttr ); + OUString sSubId(weld::toId(pNode)); + OUString sAttrName = m_xUIHelper->getNodeDisplayName( xAttr, bShowDetails ); + m_xItemList->insert(xEntry.get(), -1, &sAttrName, &sSubId, nullptr, nullptr, false, m_xScratchIter.get()); + m_xItemList->set_image(*m_xScratchIter, aExpImg); + } + } + } + if ( xChild->hasChildNodes() ) + AddChildren(xEntry.get(), xChild); + } + } + } + } + catch( Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + bool XFormsPage::DoToolBoxAction(std::string_view rToolBoxID) + { + bool bHandled = false; + bool bIsDocModified = false; + m_pNaviWin->DisableNotify( true ); + + if (rToolBoxID == "additem" || rToolBoxID == "addelement" || rToolBoxID == "addattribute") + { + bHandled = true; + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + DBG_ASSERT( xModel.is(), "XFormsPage::DoToolBoxAction(): Action without model" ); + if ( DGTSubmission == m_eGroup ) + { + AddSubmissionDialog aDlg(m_pNaviWin->GetFrameWeld(), nullptr, m_xUIHelper); + if ( aDlg.run() == RET_OK && aDlg.GetNewSubmission().is() ) + { + try + { + Reference< css::xforms::XSubmission > xNewSubmission = aDlg.GetNewSubmission(); + Reference< XSet > xSubmissions = xModel->getSubmissions(); + xSubmissions->insert( Any( xNewSubmission ) ); + AddEntry(xNewSubmission, m_xScratchIter.get()); + m_xItemList->select(*m_xScratchIter); + bIsDocModified = true; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction()" ); + } + } + } + else + { + DataItemType eType = DITElement; + + std::unique_ptr<weld::TreeIter> xEntry(m_xItemList->make_iterator()); + bool bEntry = m_xItemList->get_selected(xEntry.get()); + + std::unique_ptr<ItemNode> pNode; + Reference< css::xml::dom::XNode > xParentNode; + Reference< XPropertySet > xNewBinding; + TranslateId pResId; + bool bIsElement = true; + if ( DGTInstance == m_eGroup ) + { + if ( !m_sInstanceURL.isEmpty() ) + { + LinkedInstanceWarningBox aMsgBox(m_pNaviWin->GetFrameWeld()); + if (aMsgBox.run() != RET_OK) + return bHandled; + } + + DBG_ASSERT( bEntry, "XFormsPage::DoToolBoxAction(): no entry" ); + ItemNode* pParentNode = weld::fromId<ItemNode*>(m_xItemList->get_id(*xEntry)); + DBG_ASSERT( pParentNode, "XFormsPage::DoToolBoxAction(): no parent node" ); + xParentNode = pParentNode->m_xNode; + Reference< css::xml::dom::XNode > xNewNode; + if (rToolBoxID == "addelement") + { + try + { + pResId = RID_STR_DATANAV_ADD_ELEMENT; + xNewNode = m_xUIHelper->createElement( xParentNode, NEW_ELEMENT ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while create element" ); + } + } + else + { + pResId = RID_STR_DATANAV_ADD_ATTRIBUTE; + bIsElement = false; + eType = DITAttribute; + try + { + xNewNode = m_xUIHelper->createAttribute( xParentNode, NEW_ATTRIBUTE ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while create attribute" ); + } + } + + try + { + xNewNode = xParentNode->appendChild( xNewNode ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while append child" ); + } + + try + { + Reference< css::xml::dom::XNode > xPNode; + if ( xNewNode.is() ) + xPNode = xNewNode->getParentNode(); + // attributes don't have parents in the DOM model + DBG_ASSERT( rToolBoxID == "addattribute" + || xPNode.is(), "XFormsPage::DoToolboxAction(): node not added" ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" ); + } + + try + { + m_xUIHelper->getBindingForNode( xNewNode, true ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while get binding for node" ); + } + pNode.reset(new ItemNode( xNewNode )); + } + else + { + try + { + pResId = RID_STR_DATANAV_ADD_BINDING; + xNewBinding = xModel->createBinding(); + Reference< XSet > xBindings = xModel->getBindings(); + xBindings->insert( Any( xNewBinding ) ); + pNode.reset(new ItemNode( xNewBinding )); + eType = DITBinding; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while adding binding" ); + } + } + + AddDataItemDialog aDlg(m_pNaviWin->GetFrameWeld(), pNode.get(), m_xUIHelper); + aDlg.set_title(SvxResId(pResId)); + aDlg.InitText( eType ); + short nReturn = aDlg.run(); + if ( DGTInstance == m_eGroup ) + { + if ( RET_OK == nReturn ) + { + AddEntry( std::move(pNode), bIsElement, m_xScratchIter.get()); + m_xItemList->scroll_to_row(*m_xScratchIter); + m_xItemList->select(*m_xScratchIter); + bIsDocModified = true; + } + else + { + try + { + Reference< css::xml::dom::XNode > xPNode; + Reference< css::xml::dom::XNode > xNode = + xParentNode->removeChild( pNode->m_xNode ); + if ( xNode.is() ) + xPNode = xNode->getParentNode(); + DBG_ASSERT( !xPNode.is(), "XFormsPage::RemoveEntry(): node not removed" ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" ); + } + } + } + else + { + if ( RET_OK == nReturn ) + { + AddEntry(xNewBinding, m_xScratchIter.get()); + m_xItemList->select(*m_xScratchIter); + bIsDocModified = true; + } + else + { + try + { + Reference< XSet > xBindings = xModel->getBindings(); + xBindings->remove( Any( xNewBinding ) ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" ); + } + } + } + } + } + else if (rToolBoxID == "edit") + { + bHandled = true; + + std::unique_ptr<weld::TreeIter> xEntry(m_xItemList->make_iterator()); + bool bEntry = m_xItemList->get_selected(xEntry.get()); + if ( bEntry ) + { + if ( DGTSubmission == m_eGroup && m_xItemList->get_iter_depth(*xEntry) ) + { + m_xItemList->iter_parent(*xEntry); + } + ItemNode* pNode = weld::fromId<ItemNode*>(m_xItemList->get_id(*xEntry)); + if ( DGTInstance == m_eGroup || DGTBinding == m_eGroup ) + { + if ( DGTInstance == m_eGroup && !m_sInstanceURL.isEmpty() ) + { + LinkedInstanceWarningBox aMsgBox(m_pNaviWin->GetFrameWeld()); + if (aMsgBox.run() != RET_OK) + return bHandled; + } + + AddDataItemDialog aDlg(m_pNaviWin->GetFrameWeld(), pNode, m_xUIHelper); + DataItemType eType = DITElement; + TranslateId pResId = RID_STR_DATANAV_EDIT_ELEMENT; + if ( pNode && pNode->m_xNode.is() ) + { + try + { + css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType(); + if ( eChildType == css::xml::dom::NodeType_ATTRIBUTE_NODE ) + { + pResId = RID_STR_DATANAV_EDIT_ATTRIBUTE; + eType = DITAttribute; + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" ); + } + } + else if ( DGTBinding == m_eGroup ) + { + pResId = RID_STR_DATANAV_EDIT_BINDING; + eType = DITBinding; + } + aDlg.set_title(SvxResId(pResId)); + aDlg.InitText( eType ); + if (aDlg.run() == RET_OK) + { + // Set the new name + OUString sNewName; + if ( DGTInstance == m_eGroup ) + { + try + { + sNewName = m_xUIHelper->getNodeDisplayName( + pNode->m_xNode, m_pNaviWin->IsShowDetails() ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" ); + } + } + else if (pNode) + { + try + { + OUString sTemp; + pNode->m_xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp; + sNewName += sTemp + ": "; + pNode->m_xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp; + sNewName += sTemp; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" ); + } + } + + m_xItemList->set_text(*xEntry, sNewName); + bIsDocModified = true; + } + } + else + { + AddSubmissionDialog aDlg(m_pNaviWin->GetFrameWeld(), pNode, m_xUIHelper); + aDlg.set_title(SvxResId(RID_STR_DATANAV_EDIT_SUBMISSION)); + if (aDlg.run() == RET_OK) + { + EditEntry( pNode->m_xPropSet ); + bIsDocModified = true; + } + } + } + } + else if (rToolBoxID == "delete") + { + bHandled = true; + if ( DGTInstance == m_eGroup && !m_sInstanceURL.isEmpty() ) + { + LinkedInstanceWarningBox aMsgBox(m_pNaviWin->GetFrameWeld()); + if (aMsgBox.run() != RET_OK) + return bHandled; + } + bIsDocModified = RemoveEntry(); + } + else + { + OSL_FAIL( "XFormsPage::DoToolboxAction: unknown ID!" ); + } + + m_pNaviWin->DisableNotify( false ); + EnableMenuItems( nullptr ); + if ( bIsDocModified ) + svxform::DataNavigatorWindow::SetDocModified(); + return bHandled; + } + + void XFormsPage::AddEntry(std::unique_ptr<ItemNode> _pNewNode, bool _bIsElement, weld::TreeIter* pRet) + { + if (!pRet) + pRet = m_xScratchIter.get(); + + std::unique_ptr<weld::TreeIter> xParent(m_xItemList->make_iterator()); + if (!m_xItemList->get_selected(xParent.get())) + xParent.reset(); + OUString aImage(_bIsElement ? OUString(RID_SVXBMP_ELEMENT) : OUString(RID_SVXBMP_ATTRIBUTE)); + OUString sName; + try + { + sName = m_xUIHelper->getNodeDisplayName( + _pNewNode->m_xNode, m_pNaviWin->IsShowDetails() ); + } + catch ( Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + OUString sId(weld::toId(_pNewNode.release())); + m_xItemList->insert(xParent.get(), -1, &sName, &sId, nullptr, nullptr, false, pRet); + m_xItemList->set_image(*pRet, aImage); + if (xParent && !m_xItemList->get_row_expanded(*xParent) && m_xItemList->iter_has_child(*xParent)) + m_xItemList->expand_row(*xParent); + } + + void XFormsPage::AddEntry(const Reference< XPropertySet >& _rEntry, weld::TreeIter* pRet) + { + if (!pRet) + pRet = m_xScratchIter.get(); + + OUString aImage(RID_SVXBMP_ELEMENT); + + ItemNode* pNode = new ItemNode( _rEntry ); + OUString sTemp; + + if ( DGTSubmission == m_eGroup ) + { + try + { + // ID + _rEntry->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp; + OUString sId(weld::toId(pNode)); + m_xItemList->insert(nullptr, -1, &sTemp, &sId, nullptr, nullptr, false, pRet); + m_xItemList->set_image(*pRet, aImage); + std::unique_ptr<weld::TreeIter> xRes(m_xItemList->make_iterator()); + // Action + _rEntry->getPropertyValue( PN_SUBMISSION_ACTION ) >>= sTemp; + OUString sEntry = SvxResId( RID_STR_DATANAV_SUBM_ACTION ) + sTemp; + m_xItemList->insert(pRet, -1, &sEntry, nullptr, nullptr, nullptr, false, xRes.get()); + m_xItemList->set_image(*xRes, aImage); + // Method + _rEntry->getPropertyValue( PN_SUBMISSION_METHOD ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_METHOD ) + + m_aMethodString.toUI( sTemp ); + m_xItemList->insert(pRet, -1, &sEntry, nullptr, nullptr, nullptr, false, xRes.get()); + m_xItemList->set_image(*xRes, aImage); + // Ref + _rEntry->getPropertyValue( PN_SUBMISSION_REF ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_REF ) + sTemp; + m_xItemList->insert(pRet, -1, &sEntry, nullptr, nullptr, nullptr, false, xRes.get()); + m_xItemList->set_image(*xRes, aImage); + // Bind + _rEntry->getPropertyValue( PN_SUBMISSION_BIND ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_BIND ) + sTemp; + m_xItemList->insert(pRet, -1, &sEntry, nullptr, nullptr, nullptr, false, xRes.get()); + m_xItemList->set_image(*xRes, aImage); + // Replace + _rEntry->getPropertyValue( PN_SUBMISSION_REPLACE ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_REPLACE ) + + m_aReplaceString.toUI( sTemp ); + m_xItemList->insert(pRet, -1, &sEntry, nullptr, nullptr, nullptr, false, xRes.get()); + m_xItemList->set_image(*xRes, aImage); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::AddEntry(Ref)" ); + } + } + else // then Binding Page + { + try + { + OUString sName; + _rEntry->getPropertyValue( PN_BINDING_ID ) >>= sTemp; + sName += sTemp + ": "; + _rEntry->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp; + sName += sTemp; + + OUString sId(weld::toId(pNode)); + m_xItemList->insert(nullptr, -1, &sName, &sId, nullptr, nullptr, false, pRet); + m_xItemList->set_image(*pRet, aImage); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::AddEntry(Ref)" ); + } + } + } + + void XFormsPage::EditEntry( const Reference< XPropertySet >& _rEntry ) + { + if ( DGTSubmission != m_eGroup ) + return; + + try + { + std::unique_ptr<weld::TreeIter> xEntry(m_xItemList->make_iterator()); + if (!m_xItemList->get_selected(xEntry.get())) + { + SAL_WARN( "svx.form", "corrupt tree" ); + return; + } + + // #i36262# may be called for submission entry *or* for + // submission children. If we don't have any children, we + // assume the latter case and use the parent + if (!m_xItemList->iter_has_child(*xEntry)) + m_xItemList->iter_parent(*xEntry); + + OUString sTemp; + _rEntry->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp; + m_xItemList->set_text(*xEntry, sTemp); + + _rEntry->getPropertyValue( PN_SUBMISSION_BIND ) >>= sTemp; + OUString sEntry = SvxResId( RID_STR_DATANAV_SUBM_BIND ) + sTemp; + if (!m_xItemList->iter_children(*xEntry)) + { + SAL_WARN( "svx.form", "corrupt tree" ); + return; + } + m_xItemList->set_text(*xEntry, sEntry); + _rEntry->getPropertyValue( PN_SUBMISSION_REF ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_REF ) + sTemp; + if (!m_xItemList->iter_next_sibling(*xEntry)) + { + SAL_WARN( "svx.form", "corrupt tree" ); + return; + } + m_xItemList->set_text(*xEntry, sEntry); + _rEntry->getPropertyValue( PN_SUBMISSION_ACTION ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_ACTION ) + sTemp; + if (!m_xItemList->iter_next_sibling(*xEntry)) + { + SAL_WARN( "svx.form", "corrupt tree" ); + return; + } + _rEntry->getPropertyValue( PN_SUBMISSION_METHOD ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_METHOD ) + + m_aMethodString.toUI( sTemp ); + if (!m_xItemList->iter_next_sibling(*xEntry)) + { + SAL_WARN( "svx.form", "corrupt tree" ); + return; + } + m_xItemList->set_text(*xEntry, sEntry); + _rEntry->getPropertyValue( PN_SUBMISSION_REPLACE ) >>= sTemp; + sEntry = SvxResId( RID_STR_DATANAV_SUBM_REPLACE ) + + m_aReplaceString.toUI( sTemp ); + if (!m_xItemList->iter_next_sibling(*xEntry)) + { + SAL_WARN( "svx.form", "corrupt tree" ); + return; + } + m_xItemList->set_text(*xEntry, sEntry); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::EditEntry()" ); + } + } + + bool XFormsPage::RemoveEntry() + { + bool bRet = false; + + std::unique_ptr<weld::TreeIter> xEntry(m_xItemList->make_iterator()); + bool bEntry = m_xItemList->get_selected(xEntry.get()); + if ( bEntry && + ( DGTInstance != m_eGroup || m_xItemList->get_iter_depth(*xEntry) ) ) + { + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + DBG_ASSERT( xModel.is(), "XFormsPage::RemoveEntry(): no model" ); + ItemNode* pNode = weld::fromId<ItemNode*>(m_xItemList->get_id(*xEntry)); + DBG_ASSERT( pNode, "XFormsPage::RemoveEntry(): no node" ); + + if ( DGTInstance == m_eGroup ) + { + try + { + DBG_ASSERT( pNode->m_xNode.is(), "XFormsPage::RemoveEntry(): no XNode" ); + css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType(); + bool bIsElement = ( eChildType == css::xml::dom::NodeType_ELEMENT_NODE ); + TranslateId pResId = bIsElement ? RID_STR_QRY_REMOVE_ELEMENT : RID_STR_QRY_REMOVE_ATTRIBUTE; + OUString sVar = bIsElement ? OUString(ELEMENTNAME) : OUString(ATTRIBUTENAME); + std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(m_pNaviWin->GetFrameWeld(), + VclMessageType::Question, VclButtonsType::YesNo, + SvxResId(pResId))); + OUString sMessText = xQBox->get_primary_text(); + sMessText = sMessText.replaceFirst( + sVar, m_xUIHelper->getNodeDisplayName( pNode->m_xNode, false ) ); + xQBox->set_primary_text(sMessText); + if (xQBox->run() == RET_YES) + { + std::unique_ptr<weld::TreeIter> xParent(m_xItemList->make_iterator(xEntry.get())); + bool bParent = m_xItemList->iter_parent(*xParent); (void)bParent; + assert(bParent && "XFormsPage::RemoveEntry(): no parent entry"); + ItemNode* pParentNode = weld::fromId<ItemNode*>(m_xItemList->get_id(*xParent)); + DBG_ASSERT( pParentNode && pParentNode->m_xNode.is(), "XFormsPage::RemoveEntry(): no parent XNode" ); + + Reference< css::xml::dom::XNode > xPNode; + Reference< css::xml::dom::XNode > xNode = + pParentNode->m_xNode->removeChild( pNode->m_xNode ); + if ( xNode.is() ) + xPNode = xNode->getParentNode(); + DBG_ASSERT( !xPNode.is(), "XFormsPage::RemoveEntry(): node not removed" ); + bRet = true; + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::RemoveEntry()" ); + } + } + else + { + DBG_ASSERT( pNode->m_xPropSet.is(), "XFormsPage::RemoveEntry(): no propset" ); + bool bSubmission = ( DGTSubmission == m_eGroup ); + TranslateId pResId = bSubmission ? RID_STR_QRY_REMOVE_SUBMISSION : RID_STR_QRY_REMOVE_BINDING; + OUString sProperty = bSubmission ? OUString(PN_SUBMISSION_ID) : OUString(PN_BINDING_ID); + OUString sSearch = bSubmission ? OUString(SUBMISSIONNAME) : OUString(BINDINGNAME); + OUString sName; + try + { + pNode->m_xPropSet->getPropertyValue( sProperty ) >>= sName; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::RemoveEntry()" ); + } + std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(m_pNaviWin->GetFrameWeld(), + VclMessageType::Question, VclButtonsType::YesNo, + SvxResId(pResId))); + OUString sMessText = xQBox->get_primary_text(); + sMessText = sMessText.replaceFirst( sSearch, sName); + xQBox->set_primary_text(sMessText); + if (xQBox->run() == RET_YES) + { + try + { + if ( bSubmission ) + xModel->getSubmissions()->remove( Any( pNode->m_xPropSet ) ); + else // then Binding Page + xModel->getBindings()->remove( Any( pNode->m_xPropSet ) ); + bRet = true; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::RemoveEntry()" ); + } + } + } + + if (bRet) + { + m_xItemList->remove(*xEntry); + delete pNode; + } + } + + return bRet; + } + + IMPL_LINK(XFormsPage, KeyInputHdl, const KeyEvent&, rKEvt, bool) + { + bool bHandled = false; + + sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode(); + if (nCode == KEY_DELETE) + bHandled = DoMenuAction("delete"); + + return bHandled; + } + + OUString XFormsPage::SetModel( const Reference< css::xforms::XModel >& _xModel, int _nPagePos ) + { + DBG_ASSERT( _xModel.is(), "XFormsPage::SetModel(): invalid model" ); + + m_xUIHelper.set( _xModel, UNO_QUERY ); + OUString sRet; + m_bHasModel = true; + + switch ( m_eGroup ) + { + case DGTInstance : + { + DBG_ASSERT( _nPagePos != -1, "XFormsPage::SetModel(): invalid page position" ); + try + { + Reference< XContainer > xContainer( _xModel->getInstances(), UNO_QUERY ); + if ( xContainer.is() ) + m_pNaviWin->AddContainerBroadcaster( xContainer ); + + Reference< XEnumerationAccess > xNumAccess = _xModel->getInstances(); + if ( xNumAccess.is() ) + { + Reference < XEnumeration > xNum = xNumAccess->createEnumeration(); + if ( xNum.is() && xNum->hasMoreElements() ) + { + int nIter = 0; + while ( xNum->hasMoreElements() ) + { + if ( nIter == _nPagePos ) + { + Sequence< PropertyValue > xPropSeq; + Any aAny = xNum->nextElement(); + if ( aAny >>= xPropSeq ) + sRet = LoadInstance(xPropSeq); + else + { + SAL_WARN( "svx.form", "XFormsPage::SetModel(): invalid instance" ); + } + break; + } + else + { + xNum->nextElement(); + ++nIter; + } + } + } + } + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::SetModel()" ); + } + break; + } + + case DGTSubmission : + { + DBG_ASSERT( _nPagePos == -1, "XFormsPage::SetModel(): invalid page position" ); + try + { + Reference< XContainer > xContainer( _xModel->getSubmissions(), UNO_QUERY ); + if ( xContainer.is() ) + m_pNaviWin->AddContainerBroadcaster( xContainer ); + + Reference< XEnumerationAccess > xNumAccess = _xModel->getSubmissions(); + if ( xNumAccess.is() ) + { + Reference < XEnumeration > xNum = xNumAccess->createEnumeration(); + if ( xNum.is() && xNum->hasMoreElements() ) + { + while ( xNum->hasMoreElements() ) + { + Reference< XPropertySet > xPropSet; + Any aAny = xNum->nextElement(); + if ( aAny >>= xPropSet ) + AddEntry( xPropSet ); + } + } + } + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::SetModel()" ); + } + break; + } + + case DGTBinding : + { + DBG_ASSERT( _nPagePos == -1, "XFormsPage::SetModel(): invalid page position" ); + try + { + Reference< XContainer > xContainer( _xModel->getBindings(), UNO_QUERY ); + if ( xContainer.is() ) + m_pNaviWin->AddContainerBroadcaster( xContainer ); + + Reference< XEnumerationAccess > xNumAccess = _xModel->getBindings(); + if ( xNumAccess.is() ) + { + Reference < XEnumeration > xNum = xNumAccess->createEnumeration(); + if ( xNum.is() && xNum->hasMoreElements() ) + { + OUString aImage(RID_SVXBMP_ELEMENT); + std::unique_ptr<weld::TreeIter> xRes(m_xItemList->make_iterator()); + while ( xNum->hasMoreElements() ) + { + Reference< XPropertySet > xPropSet; + Any aAny = xNum->nextElement(); + if ( aAny >>= xPropSet ) + { + OUString sEntry; + OUString sTemp; + xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp; + sEntry += sTemp + ": "; + xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp; + sEntry += sTemp; + + ItemNode* pNode = new ItemNode( xPropSet ); + + OUString sId(weld::toId(pNode)); + m_xItemList->insert(nullptr, -1, &sEntry, &sId, nullptr, nullptr, false, xRes.get()); + m_xItemList->set_image(*xRes, aImage); + } + } + } + } + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::SetModel()" ); + } + break; + } + default: + OSL_FAIL( "XFormsPage::SetModel: unknown group!" ); + break; + } + + EnableMenuItems( nullptr ); + + return sRet; + } + + void XFormsPage::ClearModel() + { + m_bHasModel = false; + DeleteAndClearTree(); + } + + OUString XFormsPage::LoadInstance(const Sequence< PropertyValue >& _xPropSeq) + { + OUString sRet; + OUString sTemp; + OUString sInstModel = PN_INSTANCE_MODEL; + OUString sInstName = PN_INSTANCE_ID; + OUString sInstURL = PN_INSTANCE_URL; + for ( const PropertyValue& rProp : _xPropSeq ) + { + if ( sInstModel == rProp.Name ) + { + Reference< css::xml::dom::XNode > xRoot; + if ( rProp.Value >>= xRoot ) + { + try + { + Reference< XEventTarget > xTarget( xRoot, UNO_QUERY ); + if ( xTarget.is() ) + m_pNaviWin->AddEventBroadcaster( xTarget ); + + OUString sNodeName = + m_xUIHelper->getNodeDisplayName( xRoot, m_pNaviWin->IsShowDetails() ); + if ( sNodeName.isEmpty() ) + sNodeName = xRoot->getNodeName(); + if ( xRoot->hasChildNodes() ) + AddChildren(nullptr, xRoot); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::LoadInstance()" ); + } + } + } + else if ( sInstName == rProp.Name && ( rProp.Value >>= sTemp ) ) + m_sInstanceName = sRet = sTemp; + else if ( sInstURL == rProp.Name && ( rProp.Value >>= sTemp ) ) + m_sInstanceURL = sTemp; + } + + return sRet; + } + + bool XFormsPage::DoMenuAction(std::string_view rMenuID) + { + return DoToolBoxAction(rMenuID); + } + + void XFormsPage::EnableMenuItems(weld::Menu* pMenu) + { + bool bEnableAdd = false; + bool bEnableEdit = false; + bool bEnableRemove = false; + + std::unique_ptr<weld::TreeIter> xEntry(m_xItemList->make_iterator()); + bool bEntry = m_xItemList->get_selected(xEntry.get()); + if (bEntry) + { + bEnableAdd = true; + bool bSubmitChild = false; + if (DGTSubmission == m_eGroup && m_xItemList->get_iter_depth(*xEntry)) + { + m_xItemList->iter_parent(*xEntry); + bSubmitChild = true; + } + ItemNode* pNode = weld::fromId<ItemNode*>(m_xItemList->get_id(*xEntry)); + if ( pNode && ( pNode->m_xNode.is() || pNode->m_xPropSet.is() ) ) + { + bEnableEdit = true; + bEnableRemove = !bSubmitChild; + if ( DGTInstance == m_eGroup && !m_xItemList->get_iter_depth(*xEntry) ) + bEnableRemove = false; + if ( pNode->m_xNode.is() ) + { + try + { + css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType(); + if ( eChildType != css::xml::dom::NodeType_ELEMENT_NODE + && eChildType != css::xml::dom::NodeType_DOCUMENT_NODE ) + { + bEnableAdd = false; + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::EnableMenuItems()" ); + } + } + } + } + else if ( m_eGroup != DGTInstance ) + bEnableAdd = true; + + m_xToolBox->set_item_sensitive("additem", bEnableAdd); + m_xToolBox->set_item_sensitive("addelement", bEnableAdd); + m_xToolBox->set_item_sensitive("addattribute", bEnableAdd); + m_xToolBox->set_item_sensitive("edit", bEnableEdit); + m_xToolBox->set_item_sensitive("delete", bEnableRemove); + + if (pMenu) + { + pMenu->set_sensitive("additem", bEnableAdd); + pMenu->set_sensitive("addelement", bEnableAdd); + pMenu->set_sensitive("addattribute", bEnableAdd); + pMenu->set_sensitive("edit", bEnableEdit); + pMenu->set_sensitive("delete", bEnableRemove); + } + if ( DGTInstance != m_eGroup ) + return; + + TranslateId pResId1 = RID_STR_DATANAV_EDIT_ELEMENT; + TranslateId pResId2 = RID_STR_DATANAV_REMOVE_ELEMENT; + if (bEntry) + { + ItemNode* pNode = weld::fromId<ItemNode*>(m_xItemList->get_id(*xEntry)); + if ( pNode && pNode->m_xNode.is() ) + { + try + { + css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType(); + if ( eChildType == css::xml::dom::NodeType_ATTRIBUTE_NODE ) + { + pResId1 = RID_STR_DATANAV_EDIT_ATTRIBUTE; + pResId2 = RID_STR_DATANAV_REMOVE_ATTRIBUTE; + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::EnableMenuItems()" ); + } + } + } + m_xToolBox->set_item_label("edit", SvxResId(pResId1)); + m_xToolBox->set_item_label("delete", SvxResId(pResId2)); + if (pMenu) + { + pMenu->set_label("edit", SvxResId( pResId1 ) ); + pMenu->set_label("delete", SvxResId( pResId2 ) ); + } + } + + DataNavigatorWindow::DataNavigatorWindow(vcl::Window* pParent, weld::Builder& rBuilder, SfxBindings const * pBindings) + : m_xParent(pParent) + , m_xModelsBox(rBuilder.weld_combo_box("modelslist")) + , m_xModelBtn(rBuilder.weld_menu_button("modelsbutton")) + , m_xTabCtrl(rBuilder.weld_notebook("tabcontrol")) + , m_xInstanceBtn(rBuilder.weld_menu_button("instances")) + , m_nLastSelectedPos(-1) + , m_bShowDetails(false) + , m_bIsNotifyDisabled(false) + , m_aUpdateTimer("svx DataNavigatorWindow m_aUpdateTimer") + , m_xDataListener(new DataListener(this)) + { + // handler + m_xModelsBox->connect_changed( LINK( this, DataNavigatorWindow, ModelSelectListBoxHdl ) ); + Link<const OString&, void> aLink1 = LINK( this, DataNavigatorWindow, MenuSelectHdl ); + m_xModelBtn->connect_selected(aLink1); + m_xInstanceBtn->connect_selected(aLink1); + Link<weld::Toggleable&,void> aLink2 = LINK( this, DataNavigatorWindow, MenuActivateHdl ); + m_xModelBtn->connect_toggled( aLink2 ); + m_xInstanceBtn->connect_toggled( aLink2 ); + m_xTabCtrl->connect_enter_page( LINK( this, DataNavigatorWindow, ActivatePageHdl ) ); + m_aUpdateTimer.SetTimeout( 2000 ); + m_aUpdateTimer.SetInvokeHandler( LINK( this, DataNavigatorWindow, UpdateHdl ) ); + + // init tabcontrol + OString sPageId("instance"); + SvtViewOptions aViewOpt( EViewType::TabDialog, CFGNAME_DATANAVIGATOR ); + if ( aViewOpt.Exists() ) + { + OString sNewPageId = aViewOpt.GetPageID(); + if (m_xTabCtrl->get_page_index(sNewPageId) != -1) + sPageId = sNewPageId; + aViewOpt.GetUserItem(CFGNAME_SHOWDETAILS) >>= m_bShowDetails; + } + + m_xInstanceBtn->set_item_active("instancesdetails", m_bShowDetails); + + m_xTabCtrl->set_current_page(sPageId); + ActivatePageHdl(sPageId); + + // get our frame + DBG_ASSERT( pBindings != nullptr, + "DataNavigatorWindow::LoadModels(): no SfxBindings; can't get frame" ); + m_xFrame = pBindings->GetDispatcher()->GetFrame()->GetFrame().GetFrameInterface(); + DBG_ASSERT( m_xFrame.is(), "DataNavigatorWindow::LoadModels(): no frame" ); + // add frameaction listener + Reference< XFrameActionListener > xListener = m_xDataListener; + m_xFrame->addFrameActionListener( xListener ); + + // load xforms models of the current document + LoadModels(); + } + + DataNavigatorWindow::~DataNavigatorWindow() + { + Reference< XFrameActionListener > xListener = m_xDataListener; + m_xFrame->removeFrameActionListener( xListener ); + + SvtViewOptions aViewOpt( EViewType::TabDialog, CFGNAME_DATANAVIGATOR ); + aViewOpt.SetPageID(m_xTabCtrl->get_current_page_ident()); + aViewOpt.SetUserItem(CFGNAME_SHOWDETAILS, Any(m_bShowDetails)); + + m_xInstPage.reset(); + m_xSubmissionPage.reset(); + m_xBindingPage.reset(); + + sal_Int32 i, nCount = m_aPageList.size(); + for ( i = 0; i < nCount; ++i ) + m_aPageList[i].reset(); + m_aPageList.clear(); + + RemoveBroadcaster(); + m_xDataListener.clear(); + } + + IMPL_LINK( DataNavigatorWindow, ModelSelectListBoxHdl, weld::ComboBox&, rBox, void ) + { + ModelSelectHdl(&rBox); + } + + void DataNavigatorWindow::ModelSelectHdl(const weld::ComboBox* pBox) + { + sal_Int32 nPos = m_xModelsBox->get_active(); + // pBox == NULL, if you want to force a new fill. + if ( nPos != m_nLastSelectedPos || !pBox ) + { + m_nLastSelectedPos = nPos; + ClearAllPageModels( pBox != nullptr ); + InitPages(); + SetPageModel(GetCurrentPage()); + } + } + + IMPL_LINK(DataNavigatorWindow, MenuSelectHdl, const OString&, rIdent, void) + { + bool bIsDocModified = false; + Reference< css::xforms::XFormsUIHelper1 > xUIHelper; + sal_Int32 nSelectedPos = m_xModelsBox->get_active(); + OUString sSelectedModel(m_xModelsBox->get_text(nSelectedPos)); + Reference< css::xforms::XModel > xModel; + try + { + Any aAny = m_xDataContainer->getByName( sSelectedModel ); + if ( aAny >>= xModel ) + xUIHelper.set( xModel, UNO_QUERY ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" ); + } + DBG_ASSERT( xUIHelper.is(), "DataNavigatorWindow::MenuSelectHdl(): no UIHelper" ); + + m_bIsNotifyDisabled = true; + + if (rIdent == "modelsadd") + { + AddModelDialog aDlg(GetFrameWeld(), false); + bool bShowDialog = true; + while ( bShowDialog ) + { + bShowDialog = false; + if (aDlg.run() == RET_OK) + { + OUString sNewName = aDlg.GetName(); + bool bDocumentData = aDlg.GetModifyDoc(); + + if (m_xModelsBox->find_text(sNewName) != -1) + { + // error: model name already exists + std::unique_ptr<weld::MessageDialog> xErrBox(Application::CreateMessageDialog(GetFrameWeld(), + VclMessageType::Warning, VclButtonsType::Ok, + SvxResId(RID_STR_DOUBLE_MODELNAME))); + xErrBox->set_primary_text(xErrBox->get_primary_text().replaceFirst(MSG_VARIABLE, sNewName)); + xErrBox->run(); + bShowDialog = true; + } + else + { + try + { + // add new model to frame model + Reference< css::xforms::XModel > xNewModel( + xUIHelper->newModel( m_xFrameModel, sNewName ), UNO_SET_THROW ); + + Reference< XPropertySet > xModelProps( xNewModel, UNO_QUERY_THROW ); + xModelProps->setPropertyValue("ExternalData", Any( !bDocumentData ) ); + + m_xModelsBox->append_text(sNewName); + m_xModelsBox->set_active(m_xModelsBox->get_count() - 1); + ModelSelectHdl(m_xModelsBox.get()); + bIsDocModified = true; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" ); + } + } + } + } + } + else if (rIdent == "modelsedit") + { + AddModelDialog aDlg(GetFrameWeld(), true); + aDlg.SetName( sSelectedModel ); + + bool bDocumentData( false ); + try + { + Reference< css::xforms::XFormsSupplier > xFormsSupp( m_xFrameModel, UNO_QUERY_THROW ); + Reference< XNameContainer > xXForms( xFormsSupp->getXForms(), UNO_SET_THROW ); + Reference< XPropertySet > xModelProps( xXForms->getByName( sSelectedModel ), UNO_QUERY_THROW ); + bool bExternalData = false; + OSL_VERIFY( xModelProps->getPropertyValue( "ExternalData" ) >>= bExternalData ); + bDocumentData = !bExternalData; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + aDlg.SetModifyDoc( bDocumentData ); + + if (aDlg.run() == RET_OK) + { + if ( aDlg.GetModifyDoc() != bDocumentData ) + { + bDocumentData = aDlg.GetModifyDoc(); + try + { + Reference< css::xforms::XFormsSupplier > xFormsSupp( m_xFrameModel, UNO_QUERY_THROW ); + Reference< XNameContainer > xXForms( xFormsSupp->getXForms(), UNO_SET_THROW ); + Reference< XPropertySet > xModelProps( xXForms->getByName( sSelectedModel ), UNO_QUERY_THROW ); + xModelProps->setPropertyValue( "ExternalData", Any( !bDocumentData ) ); + bIsDocModified = true; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + OUString sNewName = aDlg.GetName(); + if ( !sNewName.isEmpty() && ( sNewName != sSelectedModel ) ) + { + try + { + xUIHelper->renameModel( m_xFrameModel, sSelectedModel, sNewName ); + + m_xModelsBox->remove(nSelectedPos); + m_xModelsBox->append_text(sNewName); + m_xModelsBox->set_active(m_xModelsBox->get_count() - 1); + bIsDocModified = true; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" ); + } + } + } + } + else if (rIdent == "modelsremove") + { + std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(GetFrameWeld(), + VclMessageType::Question, VclButtonsType::YesNo, + SvxResId( RID_STR_QRY_REMOVE_MODEL))); + OUString sText = xQBox->get_primary_text(); + sText = sText.replaceFirst( MODELNAME, sSelectedModel ); + xQBox->set_primary_text(sText); + if (xQBox->run() == RET_YES) + { + try + { + xUIHelper->removeModel( m_xFrameModel, sSelectedModel ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" ); + } + m_xModelsBox->remove(nSelectedPos); + if (m_xModelsBox->get_count() <= nSelectedPos) + nSelectedPos = m_xModelsBox->get_count() - 1; + m_xModelsBox->set_active(nSelectedPos); + ModelSelectHdl(m_xModelsBox.get()); + bIsDocModified = true; + } + } + else if (rIdent == "instancesadd") + { + AddInstanceDialog aDlg(GetFrameWeld(), false); + if (aDlg.run() == RET_OK) + { + OString sPageId = GetNewPageId(); // ModelSelectHdl will cause a page of this id to be created + + OUString sName = aDlg.GetName(); + if (sName.isEmpty()) + { + SAL_WARN( "svx.form", "DataNavigatorWindow::CreateInstancePage(): instance without name" ); + sName = "untitled"; + } + + OUString sURL = aDlg.GetURL(); + bool bLinkOnce = aDlg.IsLinkInstance(); + try + { + xUIHelper->newInstance( sName, sURL, !bLinkOnce ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" ); + } + ModelSelectHdl( nullptr ); + + XFormsPage* pPage = GetPage(sPageId); + pPage->SetInstanceName(sName); + pPage->SetInstanceURL(sURL); + pPage->SetLinkOnce(bLinkOnce); + ActivatePageHdl(sPageId); + + bIsDocModified = true; + } + } + else if (rIdent == "instancesedit") + { + OString sIdent = GetCurrentPage(); + XFormsPage* pPage = GetPage(sIdent); + if ( pPage ) + { + AddInstanceDialog aDlg(GetFrameWeld(), true); + aDlg.SetName( pPage->GetInstanceName() ); + aDlg.SetURL( pPage->GetInstanceURL() ); + aDlg.SetLinkInstance( pPage->GetLinkOnce() ); + OUString sOldName = aDlg.GetName(); + if (aDlg.run() == RET_OK) + { + OUString sNewName = aDlg.GetName(); + OUString sURL = aDlg.GetURL(); + bool bLinkOnce = aDlg.IsLinkInstance(); + try + { + xUIHelper->renameInstance( sOldName, + sNewName, + sURL, + !bLinkOnce ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" ); + } + pPage->SetInstanceName(sNewName); + pPage->SetInstanceURL(sURL); + pPage->SetLinkOnce(bLinkOnce); + m_xTabCtrl->set_tab_label_text(sIdent, sNewName); + bIsDocModified = true; + } + } + } + else if (rIdent == "instancesremove") + { + OString sIdent = GetCurrentPage(); + XFormsPage* pPage = GetPage(sIdent); + if (pPage) + { + OUString sInstName = pPage->GetInstanceName(); + std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(GetFrameWeld(), + VclMessageType::Question, VclButtonsType::YesNo, + SvxResId(RID_STR_QRY_REMOVE_INSTANCE))); + OUString sMessText = xQBox->get_primary_text(); + sMessText = sMessText.replaceFirst( INSTANCENAME, sInstName ); + xQBox->set_primary_text(sMessText); + if (xQBox->run() == RET_YES) + { + bool bDoRemove = false; + if (IsAdditionalPage(sIdent)) + { + auto aPageListEnd = m_aPageList.end(); + auto aFoundPage = std::find_if(m_aPageList.begin(), aPageListEnd, + [pPage](const auto&elem) { return elem.get() == pPage; }); + if ( aFoundPage != aPageListEnd ) + { + m_aPageList.erase( aFoundPage ); + bDoRemove = true; + } + } + else + { + m_xInstPage.reset(); + bDoRemove = true; + } + + if ( bDoRemove ) + { + try + { + xUIHelper->removeInstance( sInstName ); + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" ); + } + m_xTabCtrl->remove_page(sIdent); + m_xTabCtrl->set_current_page("instance"); + ModelSelectHdl( nullptr ); + bIsDocModified = true; + } + } + } + } + else if (rIdent == "instancesdetails") + { + m_bShowDetails = !m_bShowDetails; + m_xInstanceBtn->set_item_active("instancesdetails", m_bShowDetails); + ModelSelectHdl(m_xModelsBox.get()); + } + else + { + SAL_WARN( "svx.form", "DataNavigatorWindow::MenuSelectHdl(): wrong menu item" ); + } + + m_bIsNotifyDisabled = false; + + if ( bIsDocModified ) + SetDocModified(); + } + + bool DataNavigatorWindow::IsAdditionalPage(std::string_view rIdent) + { + return o3tl::starts_with(rIdent, "additional"); + } + + IMPL_LINK( DataNavigatorWindow, MenuActivateHdl, weld::Toggleable&, rBtn, void ) + { + if (m_xInstanceBtn.get() == &rBtn) + { + OString sIdent(m_xTabCtrl->get_current_page_ident()); + bool bIsInstPage = (IsAdditionalPage(sIdent) || sIdent == "instance"); + m_xInstanceBtn->set_item_sensitive( "instancesedit", bIsInstPage ); + m_xInstanceBtn->set_item_sensitive( "instancesremove", + bIsInstPage && m_xTabCtrl->get_n_pages() > MIN_PAGE_COUNT ); + m_xInstanceBtn->set_item_sensitive( "instancesdetails", bIsInstPage ); + } + else if (m_xModelBtn.get() == &rBtn) + { + // we need at least one model! + m_xModelBtn->set_item_sensitive("modelsremove", m_xModelsBox->get_count() > 1 ); + } + else + { + SAL_WARN( "svx.form", "DataNavigatorWindow::MenuActivateHdl(): wrong button" ); + } + } + + IMPL_LINK(DataNavigatorWindow, ActivatePageHdl, const OString&, rIdent, void) + { + XFormsPage* pPage = GetPage(rIdent); + if (!pPage) + return; + if (m_xDataContainer.is() && !pPage->HasModel()) + SetPageModel(rIdent); + } + + IMPL_LINK_NOARG(DataNavigatorWindow, UpdateHdl, Timer *, void) + { + ModelSelectHdl( nullptr ); + } + + XFormsPage* DataNavigatorWindow::GetPage(const OString& rCurId) + { + XFormsPage* pPage = nullptr; + if (rCurId == "submissions") + { + if (!m_xSubmissionPage) + m_xSubmissionPage.reset(new XFormsPage(m_xTabCtrl->get_page(rCurId), this, DGTSubmission)); + pPage = m_xSubmissionPage.get(); + } + else if (rCurId == "bindings") + { + if (!m_xBindingPage) + m_xBindingPage.reset(new XFormsPage(m_xTabCtrl->get_page(rCurId), this, DGTBinding)); + pPage = m_xBindingPage.get(); + } + else if (rCurId == "instance") + { + if (!m_xInstPage) + m_xInstPage.reset(new XFormsPage(m_xTabCtrl->get_page(rCurId), this, DGTInstance)); + pPage = m_xInstPage.get(); + } + else + { + sal_uInt16 nPos = m_xTabCtrl->get_page_index(rCurId); + if (HasFirstInstancePage() && nPos > 0) + nPos--; + if (m_aPageList.size() > nPos) + pPage = m_aPageList[nPos].get(); + else + { + m_aPageList.emplace_back(std::make_unique<XFormsPage>(m_xTabCtrl->get_page(rCurId), this, DGTInstance)); + pPage = m_aPageList.back().get(); + } + } + return pPage; + } + + OString DataNavigatorWindow::GetCurrentPage() const + { + return m_xTabCtrl->get_current_page_ident(); + } + + void DataNavigatorWindow::LoadModels() + { + if ( !m_xFrameModel.is() ) + { + // get model of active frame + Reference< XController > xCtrl = m_xFrame->getController(); + if ( xCtrl.is() ) + { + try + { + m_xFrameModel = xCtrl->getModel(); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::LoadModels()" ); + } + } + } + + if ( m_xFrameModel.is() ) + { + try + { + Reference< css::xforms::XFormsSupplier > xFormsSupp( m_xFrameModel, UNO_QUERY ); + if ( xFormsSupp.is() ) + { + Reference< XNameContainer > xContainer = xFormsSupp->getXForms(); + if ( xContainer.is() ) + { + m_xDataContainer = xContainer; + const Sequence< OUString > aNameList = m_xDataContainer->getElementNames(); + for ( const OUString& rName : aNameList ) + { + Any aAny = m_xDataContainer->getByName( rName ); + Reference< css::xforms::XModel > xFormsModel; + if ( aAny >>= xFormsModel ) + m_xModelsBox->append_text(xFormsModel->getID()); + } + } + } + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::LoadModels()" ); + } + } + + if (m_xModelsBox->get_count() > 0) + { + m_xModelsBox->set_active(0); + ModelSelectHdl(m_xModelsBox.get()); + } + } + + void DataNavigatorWindow::SetPageModel(const OString& rIdent) + { + OUString sModel(m_xModelsBox->get_active_text()); + try + { + Any aAny = m_xDataContainer->getByName( sModel ); + Reference< css::xforms::XModel > xFormsModel; + if ( aAny >>= xFormsModel ) + { + int nPagePos = -1; + XFormsPage* pPage = GetPage(rIdent); + DBG_ASSERT( pPage, "DataNavigatorWindow::SetPageModel(): no page" ); + if (IsAdditionalPage(rIdent) || rIdent == "instance") + { + // instance page + nPagePos = m_xTabCtrl->get_page_index(rIdent); + } + m_bIsNotifyDisabled = true; + OUString sText = pPage->SetModel( xFormsModel, nPagePos ); + m_bIsNotifyDisabled = false; + if (!sText.isEmpty()) + m_xTabCtrl->set_tab_label_text(rIdent, sText); + } + } + catch (const NoSuchElementException& ) + { + SAL_WARN( "svx.form", "DataNavigatorWindow::SetPageModel(): no such element" ); + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::SetPageModel()" ); + } + } + + void DataNavigatorWindow::InitPages() + { + OUString sModel(m_xModelsBox->get_active_text()); + try + { + Any aAny = m_xDataContainer->getByName( sModel ); + Reference< css::xforms::XModel > xModel; + if ( aAny >>= xModel ) + { + Reference< XEnumerationAccess > xNumAccess = xModel->getInstances(); + if ( xNumAccess.is() ) + { + Reference < XEnumeration > xNum = xNumAccess->createEnumeration(); + if ( xNum.is() && xNum->hasMoreElements() ) + { + sal_Int32 nAlreadyLoadedCount = m_aPageList.size(); + if ( !HasFirstInstancePage() && nAlreadyLoadedCount > 0 ) + nAlreadyLoadedCount--; + sal_Int32 nIdx = 0; + while ( xNum->hasMoreElements() ) + { + if ( nIdx > nAlreadyLoadedCount ) + { + Sequence< PropertyValue > xPropSeq; + if ( xNum->nextElement() >>= xPropSeq ) + CreateInstancePage( xPropSeq ); + else + { + SAL_WARN( "svx.form", "DataNavigator::InitPages(): invalid instance" ); + } + } + else + xNum->nextElement(); + nIdx++; + } + } + } + } + } + catch ( NoSuchElementException& ) + { + SAL_WARN( "svx.form", "DataNavigatorWindow::SetPageModel(): no such element" ); + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::SetPageModel()" ); + } + } + + void DataNavigatorWindow::ClearAllPageModels( bool bClearPages ) + { + if ( m_xInstPage ) + m_xInstPage->ClearModel(); + if ( m_xSubmissionPage ) + m_xSubmissionPage->ClearModel(); + if ( m_xBindingPage ) + m_xBindingPage->ClearModel(); + + sal_Int32 nCount = m_aPageList.size(); + for (sal_Int32 i = 0; i < nCount; ++i) + { + XFormsPage* pPage = m_aPageList[i].get(); + pPage->ClearModel(); + } + + if ( bClearPages ) + { + m_aPageList.clear(); + while ( m_xTabCtrl->get_n_pages() > MIN_PAGE_COUNT ) + m_xTabCtrl->remove_page(m_xTabCtrl->get_page_ident(1)); + } + } + + void DataNavigatorWindow::CreateInstancePage( const Sequence< PropertyValue >& _xPropSeq ) + { + OUString sInstName; + auto pProp = std::find_if(_xPropSeq.begin(), _xPropSeq.end(), + [](const PropertyValue& rProp) { return PN_INSTANCE_ID == rProp.Name; }); + if (pProp != _xPropSeq.end()) + pProp->Value >>= sInstName; + + OString sPageId = GetNewPageId(); + if ( sInstName.isEmpty() ) + { + SAL_WARN( "svx.form", "DataNavigatorWindow::CreateInstancePage(): instance without name" ); + sInstName = "untitled"; + } + m_xTabCtrl->insert_page(sPageId, sInstName, m_xTabCtrl->get_n_pages() - 2); + } + + bool DataNavigatorWindow::HasFirstInstancePage() const + { + return m_xTabCtrl->get_page_ident(0) == "instance"; + } + + OString DataNavigatorWindow::GetNewPageId() const + { + int nMax = 0; + + int nCount = m_xTabCtrl->get_n_pages(); + for (int i = 0; i < nCount; ++i) + { + OString sIdent = m_xTabCtrl->get_page_ident(i); + OString sNumber; + if (!sIdent.startsWith("additional", &sNumber)) + continue; + int nPageId = sNumber.toInt32(); + if (nMax < nPageId) + nMax = nPageId; + } + + return "additional" + OString::number(nMax + 1); + } + + void DataNavigatorWindow::SetDocModified() + { + SfxObjectShell* pCurrentDoc = SfxObjectShell::Current(); + DBG_ASSERT( pCurrentDoc, "DataNavigatorWindow::SetDocModified(): no objectshell" ); + if (pCurrentDoc && !pCurrentDoc->IsModified() && pCurrentDoc->IsEnableSetModified()) + pCurrentDoc->SetModified(); + } + + void DataNavigatorWindow::NotifyChanges( bool _bLoadAll ) + { + if ( m_bIsNotifyDisabled ) + return; + + if ( _bLoadAll ) + { + // reset all members + RemoveBroadcaster(); + m_xDataContainer.clear(); + m_xFrameModel.clear(); + m_xModelsBox->clear(); + m_nLastSelectedPos = -1; + // for a reload + LoadModels(); + } + else + m_aUpdateTimer.Start(); + } + + void DataNavigatorWindow::AddContainerBroadcaster( const css::uno::Reference< css::container::XContainer >& xContainer ) + { + Reference< XContainerListener > xListener = m_xDataListener; + xContainer->addContainerListener( xListener ); + m_aContainerList.push_back( xContainer ); + } + + + void DataNavigatorWindow::AddEventBroadcaster( const css::uno::Reference< css::xml::dom::events::XEventTarget >& xTarget ) + { + Reference< XEventListener > xListener = m_xDataListener; + xTarget->addEventListener( EVENTTYPE_CHARDATA, xListener, true ); + xTarget->addEventListener( EVENTTYPE_CHARDATA, xListener, false ); + xTarget->addEventListener( EVENTTYPE_ATTR, xListener, true ); + xTarget->addEventListener( EVENTTYPE_ATTR, xListener, false ); + m_aEventTargetList.push_back( xTarget ); + } + + void DataNavigatorWindow::RemoveBroadcaster() + { + Reference< XContainerListener > xContainerListener = m_xDataListener; + sal_Int32 i, nCount = m_aContainerList.size(); + for ( i = 0; i < nCount; ++i ) + m_aContainerList[i]->removeContainerListener( xContainerListener ); + Reference< XEventListener > xEventListener = m_xDataListener; + nCount = m_aEventTargetList.size(); + for ( i = 0; i < nCount; ++i ) + { + m_aEventTargetList[i]->removeEventListener( EVENTTYPE_CHARDATA, xEventListener, true ); + m_aEventTargetList[i]->removeEventListener( EVENTTYPE_CHARDATA, xEventListener, false ); + m_aEventTargetList[i]->removeEventListener( EVENTTYPE_ATTR, xEventListener, true ); + m_aEventTargetList[i]->removeEventListener( EVENTTYPE_ATTR, xEventListener, false ); + } + } + + DataNavigator::DataNavigator(SfxBindings* _pBindings, SfxChildWindow* _pMgr, vcl::Window* _pParent) + : SfxDockingWindow(_pBindings, _pMgr, _pParent, "DataNavigator", "svx/ui/datanavigator.ui") + , SfxControllerItem(SID_FM_DATANAVIGATOR_CONTROL, *_pBindings) + , m_xDataWin(new DataNavigatorWindow(this, *m_xBuilder, _pBindings)) + { + SetText( SvxResId( RID_STR_DATANAVIGATOR ) ); + + Size aSize = GetOptimalSize(); + Size aLogSize = PixelToLogic(aSize, MapMode(MapUnit::MapAppFont)); + SfxDockingWindow::SetFloatingSize( aLogSize ); + } + + DataNavigator::~DataNavigator() + { + disposeOnce(); + } + + void DataNavigator::dispose() + { + m_xDataWin.reset(); + ::SfxControllerItem::dispose(); + SfxDockingWindow::dispose(); + } + + void DataNavigator::StateChangedAtToolBoxControl( sal_uInt16 , SfxItemState , const SfxPoolItem* ) + { + } + + Size DataNavigator::CalcDockingSize( SfxChildAlignment eAlign ) + { + if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) ) + return Size(); + + return SfxDockingWindow::CalcDockingSize( eAlign ); + } + + SfxChildAlignment DataNavigator::CheckAlignment( SfxChildAlignment eActAlign, SfxChildAlignment eAlign ) + { + switch ( eAlign ) + { + case SfxChildAlignment::LEFT: + case SfxChildAlignment::RIGHT: + case SfxChildAlignment::NOALIGNMENT: + return eAlign; + default: + break; + } + return eActAlign; + } + + SFX_IMPL_DOCKINGWINDOW( DataNavigatorManager, SID_FM_SHOW_DATANAVIGATOR ) + + DataNavigatorManager::DataNavigatorManager( + vcl::Window* _pParent, sal_uInt16 _nId, SfxBindings* _pBindings, SfxChildWinInfo* _pInfo ) : + + SfxChildWindow( _pParent, _nId ) + + { + SetWindow( VclPtr<DataNavigator>::Create( _pBindings, this, _pParent ) ); + SetAlignment(SfxChildAlignment::RIGHT); + GetWindow()->SetSizePixel( Size( 250, 400 ) ); + static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo ); + } + + AddDataItemDialog::AddDataItemDialog(weld::Window* pParent, ItemNode* _pNode, + const Reference< css::xforms::XFormsUIHelper1 >& _rUIHelper) + : GenericDialogController(pParent, "svx/ui/adddataitemdialog.ui", "AddDataItemDialog") + , m_xUIHelper(_rUIHelper) + , m_pItemNode(_pNode) + , m_eItemType(DITNone) + , m_sFL_Element(SvxResId(RID_STR_ELEMENT)) + , m_sFL_Attribute(SvxResId(RID_STR_ATTRIBUTE)) + , m_sFL_Binding(SvxResId(RID_STR_BINDING)) + , m_sFT_BindingExp(SvxResId(RID_STR_BINDING_EXPR)) + , m_xItemFrame(m_xBuilder->weld_frame("itemframe")) + , m_xNameFT(m_xBuilder->weld_label("nameft")) + , m_xNameED(m_xBuilder->weld_entry("name")) + , m_xDefaultFT(m_xBuilder->weld_label("valueft")) + , m_xDefaultED(m_xBuilder->weld_entry("value")) + , m_xDefaultBtn(m_xBuilder->weld_button("browse")) + , m_xSettingsFrame(m_xBuilder->weld_widget("settingsframe")) + , m_xDataTypeFT(m_xBuilder->weld_label("datatypeft")) + , m_xDataTypeLB(m_xBuilder->weld_combo_box("datatype")) + , m_xRequiredCB(m_xBuilder->weld_check_button("required")) + , m_xRequiredBtn(m_xBuilder->weld_button("requiredcond")) + , m_xRelevantCB(m_xBuilder->weld_check_button("relevant")) + , m_xRelevantBtn(m_xBuilder->weld_button("relevantcond")) + , m_xConstraintCB(m_xBuilder->weld_check_button("constraint")) + , m_xConstraintBtn(m_xBuilder->weld_button("constraintcond")) + , m_xReadonlyCB(m_xBuilder->weld_check_button("readonly")) + , m_xReadonlyBtn(m_xBuilder->weld_button("readonlycond")) + , m_xCalculateCB(m_xBuilder->weld_check_button("calculate")) + , m_xCalculateBtn(m_xBuilder->weld_button("calculatecond")) + , m_xOKBtn(m_xBuilder->weld_button("ok")) + { + InitDialog(); + InitFromNode(); + InitDataTypeBox(); + Check(nullptr); + } + + AddDataItemDialog::~AddDataItemDialog() + { + if ( m_xTempBinding.is() ) + { + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + if ( xModel.is() ) + { + try + { + Reference < XSet > xBindings = xModel->getBindings(); + if ( xBindings.is() ) + xBindings->remove( Any( m_xTempBinding ) ); + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::Dtor()" ); + } + } + } + if( m_xUIHelper.is() && m_xBinding.is() ) + { + // remove binding, if it does not convey 'useful' information + m_xUIHelper->removeBindingIfUseless( m_xBinding ); + } + } + + IMPL_LINK(AddDataItemDialog, CheckHdl, weld::Toggleable&, rBox, void) + { + Check(&rBox); + } + + void AddDataItemDialog::Check(const weld::Toggleable* pBox) + { + // Condition buttons are only enable if their check box is checked + m_xReadonlyBtn->set_sensitive( m_xReadonlyCB->get_active() ); + m_xRequiredBtn->set_sensitive( m_xRequiredCB->get_active() ); + m_xRelevantBtn->set_sensitive( m_xRelevantCB->get_active() ); + m_xConstraintBtn->set_sensitive( m_xConstraintCB->get_active() ); + m_xCalculateBtn->set_sensitive( m_xCalculateCB->get_active() ); + + if ( !(pBox && m_xTempBinding.is()) ) + return; + + OUString sTemp, sPropName; + if ( m_xRequiredCB.get() == pBox ) + sPropName = PN_REQUIRED_EXPR; + else if ( m_xRelevantCB.get() == pBox ) + sPropName = PN_RELEVANT_EXPR; + else if ( m_xConstraintCB.get() == pBox ) + sPropName = PN_CONSTRAINT_EXPR; + else if ( m_xReadonlyCB.get() == pBox ) + sPropName = PN_READONLY_EXPR; + else if ( m_xCalculateCB.get() == pBox ) + sPropName = PN_CALCULATE_EXPR; + bool bIsChecked = pBox->get_active(); + m_xTempBinding->getPropertyValue( sPropName ) >>= sTemp; + if ( bIsChecked && sTemp.isEmpty() ) + sTemp = TRUE_VALUE; + else if ( !bIsChecked && !sTemp.isEmpty() ) + sTemp.clear(); + m_xTempBinding->setPropertyValue( sPropName, Any( sTemp ) ); + } + + IMPL_LINK(AddDataItemDialog, ConditionHdl, weld::Button&, rBtn, void) + { + OUString sPropName; + if ( m_xDefaultBtn.get() == &rBtn ) + sPropName = PN_BINDING_EXPR; + else if ( m_xRequiredBtn.get() == &rBtn ) + sPropName = PN_REQUIRED_EXPR; + else if ( m_xRelevantBtn.get() == &rBtn ) + sPropName = PN_RELEVANT_EXPR; + else if ( m_xConstraintBtn.get() == &rBtn ) + sPropName = PN_CONSTRAINT_EXPR; + else if (m_xReadonlyBtn.get() == &rBtn) + sPropName = PN_READONLY_EXPR; + else if (m_xCalculateBtn.get() == &rBtn) + sPropName = PN_CALCULATE_EXPR; + AddConditionDialog aDlg(m_xDialog.get(), sPropName, m_xTempBinding); + bool bIsDefBtn = ( m_xDefaultBtn.get() == &rBtn ); + OUString sCondition; + if ( bIsDefBtn ) + sCondition = m_xDefaultED->get_text(); + else + { + OUString sTemp; + m_xTempBinding->getPropertyValue( sPropName ) >>= sTemp; + if ( sTemp.isEmpty() ) + sTemp = TRUE_VALUE; + sCondition = sTemp; + } + aDlg.SetCondition( sCondition ); + + if (aDlg.run() == RET_OK) + { + OUString sNewCondition = aDlg.GetCondition(); + if ( bIsDefBtn ) + m_xDefaultED->set_text(sNewCondition); + else + { + + m_xTempBinding->setPropertyValue( + sPropName, Any( sNewCondition ) ); + } + } + } + + static void copyPropSet( const Reference< XPropertySet >& xFrom, Reference< XPropertySet > const & xTo ) + { + DBG_ASSERT( xFrom.is(), "copyPropSet(): no source" ); + DBG_ASSERT( xTo.is(), "copyPropSet(): no target" ); + + try + { + // get property names & infos, and iterate over target properties + const Sequence< Property > aProperties = xTo->getPropertySetInfo()->getProperties(); + Reference< XPropertySetInfo > xFromInfo = xFrom->getPropertySetInfo(); + for ( const Property& rProperty : aProperties ) + { + const OUString& rName = rProperty.Name; + + // if both set have the property, copy the value + // (catch and ignore exceptions, if any) + if ( xFromInfo->hasPropertyByName( rName ) ) + { + // don't set readonly properties + Property aProperty = xFromInfo->getPropertyByName( rName ); + if ( ( aProperty.Attributes & PropertyAttribute::READONLY ) == 0 ) + xTo->setPropertyValue(rName, xFrom->getPropertyValue( rName )); + } + // else: no property? then ignore. + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "copyPropSet()" ); + } + } + + IMPL_LINK_NOARG(AddDataItemDialog, OKHdl, weld::Button&, void) + { + bool bIsHandleBinding = ( DITBinding == m_eItemType ); + bool bIsHandleText = ( DITText == m_eItemType ); + OUString sNewName( m_xNameED->get_text() ); + + if ( ( !bIsHandleBinding && !bIsHandleText && !m_xUIHelper->isValidXMLName( sNewName ) ) || + ( bIsHandleBinding && sNewName.isEmpty() ) ) + { + // Error and don't close the dialog + std::unique_ptr<weld::MessageDialog> xErrBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + SvxResId(RID_STR_INVALID_XMLNAME))); + xErrBox->set_primary_text(xErrBox->get_primary_text().replaceFirst(MSG_VARIABLE, sNewName)); + xErrBox->run(); + return; + } + + OUString sDataType( m_xDataTypeLB->get_active_text() ); + m_xTempBinding->setPropertyValue( PN_BINDING_TYPE, Any( sDataType ) ); + + if ( bIsHandleBinding ) + { + // copy properties from temp binding to original binding + copyPropSet( m_xTempBinding, m_pItemNode->m_xPropSet ); + try + { + OUString sValue = m_xNameED->get_text(); + m_pItemNode->m_xPropSet->setPropertyValue( PN_BINDING_ID, Any( sValue ) ); + sValue = m_xDefaultED->get_text(); + m_pItemNode->m_xPropSet->setPropertyValue( PN_BINDING_EXPR, Any( sValue ) ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataDialog::OKHdl()" ); + } + } + else + { + // copy properties from temp binding to original binding + copyPropSet( m_xTempBinding, m_xBinding ); + try + { + if ( bIsHandleText ) + m_xUIHelper->setNodeValue( m_pItemNode->m_xNode, m_xDefaultED->get_text() ); + else + { + Reference< css::xml::dom::XNode > xNewNode = + m_xUIHelper->renameNode( m_pItemNode->m_xNode, m_xNameED->get_text() ); + m_xUIHelper->setNodeValue( xNewNode, m_xDefaultED->get_text() ); + m_pItemNode->m_xNode = xNewNode; + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataDialog::OKHdl()" ); + } + } + // then close the dialog + m_xDialog->response(RET_OK); + } + + void AddDataItemDialog::InitDialog() + { + // set handler + Link<weld::Toggleable&,void> aLink = LINK( this, AddDataItemDialog, CheckHdl ); + m_xRequiredCB->connect_toggled( aLink ); + m_xRelevantCB->connect_toggled( aLink ); + m_xConstraintCB->connect_toggled( aLink ); + m_xReadonlyCB->connect_toggled( aLink ); + m_xCalculateCB->connect_toggled( aLink ); + + Link<weld::Button&,void> aLink2 = LINK( this, AddDataItemDialog, ConditionHdl ); + m_xDefaultBtn->connect_clicked( aLink2 ); + m_xRequiredBtn->connect_clicked( aLink2 ); + m_xRelevantBtn->connect_clicked( aLink2 ); + m_xConstraintBtn->connect_clicked( aLink2 ); + m_xReadonlyBtn->connect_clicked( aLink2 ); + m_xCalculateBtn->connect_clicked( aLink2 ); + + m_xOKBtn->connect_clicked( LINK( this, AddDataItemDialog, OKHdl ) ); + } + + void AddDataItemDialog::InitFromNode() + { + if ( m_pItemNode ) + { + if ( m_pItemNode->m_xNode.is() ) + { + try + { + // detect type of the node + css::xml::dom::NodeType eChildType = m_pItemNode->m_xNode->getNodeType(); + switch ( eChildType ) + { + case css::xml::dom::NodeType_ATTRIBUTE_NODE: + m_eItemType = DITAttribute; + break; + case css::xml::dom::NodeType_ELEMENT_NODE: + m_eItemType = DITElement; + break; + case css::xml::dom::NodeType_TEXT_NODE: + m_eItemType = DITText; + break; + default: + OSL_FAIL( "AddDataItemDialog::InitFronNode: cannot handle this node type!" ); + break; + } + + /** Get binding of the node and clone it + Then use this temporary binding in the dialog. + When the user click OK the temporary binding will be copied + into the original binding. + */ + + Reference< css::xml::dom::XNode > xNode = m_pItemNode->m_xNode; + m_xBinding = m_xUIHelper->getBindingForNode( xNode, true ); + if ( m_xBinding.is() ) + { + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + if ( xModel.is() ) + { + m_xTempBinding = m_xUIHelper->cloneBindingAsGhost( m_xBinding ); + Reference < XSet > xBindings = xModel->getBindings(); + if ( xBindings.is() ) + xBindings->insert( Any( m_xTempBinding ) ); + } + } + + if ( m_eItemType != DITText ) + { + OUString sName( m_xUIHelper->getNodeName( m_pItemNode->m_xNode ) ); + m_xNameED->set_text( sName ); + } + m_xDefaultED->set_text( m_pItemNode->m_xNode->getNodeValue() ); + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" ); + } + } + else if ( m_pItemNode->m_xPropSet.is() ) + { + m_eItemType = DITBinding; + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + if ( xModel.is() ) + { + try + { + m_xTempBinding = m_xUIHelper->cloneBindingAsGhost( m_pItemNode->m_xPropSet ); + Reference < XSet > xBindings = xModel->getBindings(); + if ( xBindings.is() ) + xBindings->insert( Any( m_xTempBinding ) ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" ); + } + } + try + { + Reference< XPropertySetInfo > xInfo = m_pItemNode->m_xPropSet->getPropertySetInfo(); + OUString sTemp; + if ( xInfo->hasPropertyByName( PN_BINDING_ID ) ) + { + m_pItemNode->m_xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp; + m_xNameED->set_text( sTemp ); + m_pItemNode->m_xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp; + m_xDefaultED->set_text( sTemp ); + } + else if ( xInfo->hasPropertyByName( PN_SUBMISSION_BIND ) ) + { + m_pItemNode->m_xPropSet->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp; + m_xNameED->set_text( sTemp ); + } + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" ); + } + + m_xDefaultBtn->show(); + } + + if ( m_xTempBinding.is() ) + { + try + { + OUString sTemp; + if ( ( m_xTempBinding->getPropertyValue( PN_REQUIRED_EXPR ) >>= sTemp ) + && !sTemp.isEmpty() ) + m_xRequiredCB->set_active(true); + if ( ( m_xTempBinding->getPropertyValue( PN_RELEVANT_EXPR ) >>= sTemp ) + && !sTemp.isEmpty() ) + m_xRelevantCB->set_active(true); + if ( ( m_xTempBinding->getPropertyValue( PN_CONSTRAINT_EXPR ) >>= sTemp ) + && !sTemp.isEmpty() ) + m_xConstraintCB->set_active(true); + if ( ( m_xTempBinding->getPropertyValue( PN_READONLY_EXPR ) >>= sTemp ) + && !sTemp.isEmpty() ) + m_xReadonlyCB->set_active(true); + if ( ( m_xTempBinding->getPropertyValue( PN_CALCULATE_EXPR ) >>= sTemp ) + && !sTemp.isEmpty() ) + m_xCalculateCB->set_active(true); + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" ); + } + } + } + + if ( DITText == m_eItemType ) + { + m_xSettingsFrame->hide(); + m_xNameFT->set_sensitive(false); + m_xNameED->set_sensitive(false); + } + } + + void AddDataItemDialog::InitDataTypeBox() + { + if ( m_eItemType == DITText ) + return; + + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + if ( !xModel.is() ) + return; + + try + { + Reference< css::xforms::XDataTypeRepository > xDataTypes = + xModel->getDataTypeRepository(); + if ( xDataTypes.is() ) + { + const Sequence< OUString > aNameList = xDataTypes->getElementNames(); + for ( const OUString& rName : aNameList ) + m_xDataTypeLB->append_text(rName); + } + + if ( m_xTempBinding.is() ) + { + OUString sTemp; + if ( m_xTempBinding->getPropertyValue( PN_BINDING_TYPE ) >>= sTemp ) + { + int nPos = m_xDataTypeLB->find_text(sTemp); + if (nPos == -1) + { + m_xDataTypeLB->append_text(sTemp); + nPos = m_xDataTypeLB->get_count() - 1; + } + m_xDataTypeLB->set_active(nPos); + } + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitDataTypeBox()" ); + } + } + + void AddDataItemDialog::InitText( DataItemType _eType ) + { + OUString sText; + + switch ( _eType ) + { + case DITAttribute : + { + sText = m_sFL_Attribute; + break; + } + + case DITBinding : + { + sText = m_sFL_Binding; + m_xDefaultFT->set_label(m_sFT_BindingExp); + break; + } + + default: + { + sText = m_sFL_Element; + } + } + + m_xItemFrame->set_label(sText); + } + + AddConditionDialog::AddConditionDialog(weld::Window* pParent, + const OUString& _rPropertyName, + const Reference< XPropertySet >& _rPropSet) + : GenericDialogController(pParent, "svx/ui/addconditiondialog.ui", "AddConditionDialog") + , m_aResultIdle("svx AddConditionDialog m_aResultIdle") + , m_sPropertyName(_rPropertyName) + , m_xBinding(_rPropSet) + , m_xConditionED(m_xBuilder->weld_text_view("condition")) + , m_xResultWin(m_xBuilder->weld_text_view("result")) + , m_xEditNamespacesBtn(m_xBuilder->weld_button("edit")) + , m_xOKBtn(m_xBuilder->weld_button("ok")) + { + DBG_ASSERT( m_xBinding.is(), "AddConditionDialog::Ctor(): no Binding" ); + + m_xConditionED->set_size_request(m_xConditionED->get_approximate_digit_width() * 52, + m_xConditionED->get_height_rows(4)); + m_xResultWin->set_size_request(m_xResultWin->get_approximate_digit_width() * 52, + m_xResultWin->get_height_rows(4)); + + m_xConditionED->connect_changed( LINK( this, AddConditionDialog, ModifyHdl ) ); + m_xEditNamespacesBtn->connect_clicked( LINK( this, AddConditionDialog, EditHdl ) ); + m_xOKBtn->connect_clicked( LINK( this, AddConditionDialog, OKHdl ) ); + m_aResultIdle.SetPriority( TaskPriority::LOWEST ); + m_aResultIdle.SetInvokeHandler( LINK( this, AddConditionDialog, ResultHdl ) ); + + if ( !m_sPropertyName.isEmpty() ) + { + try + { + OUString sTemp; + if ( ( m_xBinding->getPropertyValue( m_sPropertyName ) >>= sTemp ) + && !sTemp.isEmpty() ) + { + m_xConditionED->set_text( sTemp ); + } + else + { +//! m_xBinding->setPropertyValue( m_sPropertyName, makeAny( TRUE_VALUE ) ); + m_xConditionED->set_text( TRUE_VALUE ); + } + + Reference< css::xforms::XModel > xModel; + if ( ( m_xBinding->getPropertyValue( PN_BINDING_MODEL ) >>= xModel ) && xModel.is() ) + m_xUIHelper.set( xModel, UNO_QUERY ); + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddConditionDialog::Ctor()" ); + } + } + + DBG_ASSERT( m_xUIHelper.is(), "AddConditionDialog::Ctor(): no UIHelper" ); + ResultHdl( &m_aResultIdle ); + } + + AddConditionDialog::~AddConditionDialog() + { + } + + IMPL_LINK_NOARG(AddConditionDialog, EditHdl, weld::Button&, void) + { + Reference< XNameContainer > xNameContnr; + try + { + m_xBinding->getPropertyValue( PN_BINDING_NAMESPACES ) >>= xNameContnr; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::EditHdl()" ); + } + NamespaceItemDialog aDlg(this, xNameContnr); + aDlg.run(); + try + { + m_xBinding->setPropertyValue( PN_BINDING_NAMESPACES, Any( xNameContnr ) ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::EditHdl()" ); + } + } + + IMPL_LINK_NOARG(AddConditionDialog, OKHdl, weld::Button&, void) + { + m_xDialog->response(RET_OK); + } + + IMPL_LINK_NOARG(AddConditionDialog, ModifyHdl, weld::TextView&, void) + { + m_aResultIdle.Start(); + } + + IMPL_LINK_NOARG(AddConditionDialog, ResultHdl, Timer *, void) + { + OUString sCondition = comphelper::string::strip(m_xConditionED->get_text(), ' '); + OUString sResult; + if ( !sCondition.isEmpty() ) + { + try + { + sResult = m_xUIHelper->getResultForExpression( m_xBinding, ( m_sPropertyName == PN_BINDING_EXPR ), sCondition ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddConditionDialog::ResultHdl()" ); + } + } + m_xResultWin->set_text(sResult); + } + + NamespaceItemDialog::NamespaceItemDialog(AddConditionDialog* pCondDlg, Reference<XNameContainer>& rContainer) + : GenericDialogController(pCondDlg->getDialog(), "svx/ui/namespacedialog.ui", "NamespaceDialog") + , m_pConditionDlg(pCondDlg) + , m_rNamespaces(rContainer) + , m_xNamespacesList(m_xBuilder->weld_tree_view("namespaces")) + , m_xAddNamespaceBtn(m_xBuilder->weld_button("add")) + , m_xEditNamespaceBtn(m_xBuilder->weld_button("edit")) + , m_xDeleteNamespaceBtn(m_xBuilder->weld_button("delete")) + , m_xOKBtn(m_xBuilder->weld_button("ok")) + { + m_xNamespacesList->set_size_request(m_xNamespacesList->get_approximate_digit_width() * 80, + m_xNamespacesList->get_height_rows(8)); + + std::vector<int> aWidths + { + o3tl::narrowing<int>(m_xNamespacesList->get_approximate_digit_width() * 20) + }; + m_xNamespacesList->set_column_fixed_widths(aWidths); + + m_xNamespacesList->connect_changed( LINK( this, NamespaceItemDialog, SelectHdl ) ); + Link<weld::Button&,void> aLink = LINK( this, NamespaceItemDialog, ClickHdl ); + m_xAddNamespaceBtn->connect_clicked( aLink ); + m_xEditNamespaceBtn->connect_clicked( aLink ); + m_xDeleteNamespaceBtn->connect_clicked( aLink ); + m_xOKBtn->connect_clicked( LINK( this, NamespaceItemDialog, OKHdl ) ); + + LoadNamespaces(); + SelectHdl(*m_xNamespacesList); + } + + NamespaceItemDialog::~NamespaceItemDialog() + { + } + + IMPL_LINK_NOARG( NamespaceItemDialog, SelectHdl, weld::TreeView&, void) + { + bool bEnable = m_xNamespacesList->get_selected_index() != -1; + m_xEditNamespaceBtn->set_sensitive( bEnable ); + m_xDeleteNamespaceBtn->set_sensitive( bEnable ); + } + + IMPL_LINK( NamespaceItemDialog, ClickHdl, weld::Button&, rButton, void ) + { + if (m_xAddNamespaceBtn.get() == &rButton) + { + ManageNamespaceDialog aDlg(m_xDialog.get(), m_pConditionDlg, false); + if (aDlg.run() == RET_OK) + { + m_xNamespacesList->append_text(aDlg.GetPrefix()); + int nRow = m_xNamespacesList->n_children(); + m_xNamespacesList->set_text(nRow - 1, aDlg.GetURL(), 1); + } + } + else if (m_xEditNamespaceBtn.get() == &rButton) + { + ManageNamespaceDialog aDlg(m_xDialog.get(), m_pConditionDlg, true); + int nEntry = m_xNamespacesList->get_selected_index(); + DBG_ASSERT( nEntry != -1, "NamespaceItemDialog::ClickHdl(): no entry" ); + OUString sPrefix(m_xNamespacesList->get_text(nEntry, 0)); + aDlg.SetNamespace(sPrefix, m_xNamespacesList->get_text(nEntry, 1)); + if (aDlg.run() == RET_OK) + { + // if a prefix was changed, mark the old prefix as 'removed' + if( sPrefix != aDlg.GetPrefix() ) + m_aRemovedList.push_back( sPrefix ); + + m_xNamespacesList->set_text(nEntry, aDlg.GetPrefix(), 0); + m_xNamespacesList->set_text(nEntry, aDlg.GetURL(), 1); + } + } + else if (m_xDeleteNamespaceBtn.get() == &rButton) + { + int nEntry = m_xNamespacesList->get_selected_index(); + DBG_ASSERT( nEntry != -1, "NamespaceItemDialog::ClickHdl(): no entry" ); + OUString sPrefix(m_xNamespacesList->get_text(nEntry, 0)); + m_aRemovedList.push_back( sPrefix ); + m_xNamespacesList->remove(nEntry); + } + else + { + SAL_WARN( "svx.form", "NamespaceItemDialog::ClickHdl(): invalid button" ); + } + + SelectHdl(*m_xNamespacesList); + } + + IMPL_LINK_NOARG(NamespaceItemDialog, OKHdl, weld::Button&, void) + { + try + { + // update namespace container + sal_Int32 i, nRemovedCount = m_aRemovedList.size(); + for( i = 0; i < nRemovedCount; ++i ) + m_rNamespaces->removeByName( m_aRemovedList[i] ); + + sal_Int32 nEntryCount = m_xNamespacesList->n_children(); + for( i = 0; i < nEntryCount; ++i ) + { + OUString sPrefix(m_xNamespacesList->get_text(i, 0)); + OUString sURL(m_xNamespacesList->get_text(i, 1)); + + if ( m_rNamespaces->hasByName( sPrefix ) ) + m_rNamespaces->replaceByName( sPrefix, Any( sURL ) ); + else + m_rNamespaces->insertByName( sPrefix, Any( sURL ) ); + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "NamespaceItemDialog::OKHdl()" ); + } + // and close the dialog + m_xDialog->response(RET_OK); + } + + void NamespaceItemDialog::LoadNamespaces() + { + try + { + int nRow = 0; + const Sequence< OUString > aAllNames = m_rNamespaces->getElementNames(); + for ( const OUString& sPrefix : aAllNames ) + { + if ( m_rNamespaces->hasByName( sPrefix ) ) + { + OUString sURL; + Any aAny = m_rNamespaces->getByName( sPrefix ); + if (aAny >>= sURL) + { + m_xNamespacesList->append_text(sPrefix); + m_xNamespacesList->set_text(nRow, sURL, 1); + ++nRow; + } + } + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "NamespaceItemDialog::LoadNamespaces()" ); + } + } + + ManageNamespaceDialog::ManageNamespaceDialog(weld::Window* pParent, AddConditionDialog* pCondDlg, bool bIsEdit) + : GenericDialogController(pParent, "svx/ui/addnamespacedialog.ui", "AddNamespaceDialog") + , m_pConditionDlg(pCondDlg) + , m_xPrefixED(m_xBuilder->weld_entry("prefix")) + , m_xUrlED(m_xBuilder->weld_entry("url")) + , m_xOKBtn(m_xBuilder->weld_button("ok")) + , m_xAltTitle(m_xBuilder->weld_label("alttitle")) + { + if (bIsEdit) + m_xDialog->set_title(m_xAltTitle->get_label()); + + m_xOKBtn->connect_clicked(LINK(this, ManageNamespaceDialog, OKHdl)); + } + + ManageNamespaceDialog::~ManageNamespaceDialog() + { + } + + IMPL_LINK_NOARG(ManageNamespaceDialog, OKHdl, weld::Button&, void) + { + OUString sPrefix = m_xPrefixED->get_text(); + + try + { + if (!m_pConditionDlg->GetUIHelper()->isValidPrefixName(sPrefix)) + { + std::unique_ptr<weld::MessageDialog> xErrBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + SvxResId(RID_STR_INVALID_XMLPREFIX))); + xErrBox->set_primary_text(xErrBox->get_primary_text().replaceFirst(MSG_VARIABLE, sPrefix)); + xErrBox->run(); + return; + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "ManageNamespacesDialog::OKHdl()" ); + } + + // no error so close the dialog + m_xDialog->response(RET_OK); + } + + AddSubmissionDialog::AddSubmissionDialog( + weld::Window* pParent, ItemNode* _pNode, + const Reference< css::xforms::XFormsUIHelper1 >& _rUIHelper) + : GenericDialogController(pParent, "svx/ui/addsubmissiondialog.ui", "AddSubmissionDialog") + , m_pItemNode(_pNode) + , m_xUIHelper(_rUIHelper) + , m_xNameED(m_xBuilder->weld_entry("name")) + , m_xActionED(m_xBuilder->weld_entry("action")) + , m_xMethodLB(m_xBuilder->weld_combo_box("method")) + , m_xRefED(m_xBuilder->weld_entry("expression")) + , m_xRefBtn(m_xBuilder->weld_button("browse")) + , m_xBindLB(m_xBuilder->weld_combo_box("binding")) + , m_xReplaceLB(m_xBuilder->weld_combo_box("replace")) + , m_xOKBtn(m_xBuilder->weld_button("ok")) + { + FillAllBoxes(); + + m_xRefBtn->connect_clicked( LINK( this, AddSubmissionDialog, RefHdl ) ); + m_xOKBtn->connect_clicked( LINK( this, AddSubmissionDialog, OKHdl ) ); + } + + AddSubmissionDialog::~AddSubmissionDialog() + { + // #i38991# if we have added a binding, we need to remove it as well. + if( m_xCreatedBinding.is() && m_xUIHelper.is() ) + m_xUIHelper->removeBindingIfUseless( m_xCreatedBinding ); + } + + IMPL_LINK_NOARG(AddSubmissionDialog, RefHdl, weld::Button&, void) + { + AddConditionDialog aDlg(m_xDialog.get(), PN_BINDING_EXPR, m_xTempBinding ); + aDlg.SetCondition( m_xRefED->get_text() ); + if ( aDlg.run() == RET_OK ) + m_xRefED->set_text(aDlg.GetCondition()); + } + + IMPL_LINK_NOARG(AddSubmissionDialog, OKHdl, weld::Button&, void) + { + OUString sName(m_xNameED->get_text()); + if(sName.isEmpty()) + { + std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + SvxResId(RID_STR_EMPTY_SUBMISSIONNAME))); + xErrorBox->run(); + return; + } + + if ( !m_xSubmission.is() ) + { + DBG_ASSERT( !m_xNewSubmission.is(), + "AddSubmissionDialog::OKHdl(): new submission already exists" ); + + // add a new submission + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + if ( xModel.is() ) + { + try + { + m_xNewSubmission = xModel->createSubmission(); + m_xSubmission = m_xNewSubmission; + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::OKHdl()" ); + } + } + } + + if ( m_xSubmission.is() ) + { + OUString sTemp = m_xNameED->get_text(); + try + { + m_xSubmission->setPropertyValue( PN_SUBMISSION_ID, Any( sTemp ) ); + sTemp = m_xActionED->get_text(); + m_xSubmission->setPropertyValue( PN_SUBMISSION_ACTION, Any( sTemp ) ); + sTemp = m_aMethodString.toAPI( m_xMethodLB->get_active_text() ); + m_xSubmission->setPropertyValue( PN_SUBMISSION_METHOD, Any( sTemp ) ); + sTemp = m_xRefED->get_text(); + m_xSubmission->setPropertyValue( PN_SUBMISSION_REF, Any( sTemp ) ); + OUString sEntry = m_xBindLB->get_active_text(); + sal_Int32 nColonIdx = sEntry.indexOf(':'); + if (nColonIdx != -1) + sEntry = sEntry.copy(0, nColonIdx); + sTemp = sEntry; + m_xSubmission->setPropertyValue( PN_SUBMISSION_BIND, Any( sTemp ) ); + sTemp = m_aReplaceString.toAPI( m_xReplaceLB->get_active_text() ); + m_xSubmission->setPropertyValue( PN_SUBMISSION_REPLACE, Any( sTemp ) ); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::OKHdl()" ); + } + } + + m_xDialog->response(RET_OK); + } + + void AddSubmissionDialog::FillAllBoxes() + { + // method box + m_xMethodLB->append_text(SvxResId(RID_STR_METHOD_POST)); + m_xMethodLB->append_text(SvxResId(RID_STR_METHOD_PUT)); + m_xMethodLB->append_text(SvxResId(RID_STR_METHOD_GET)); + m_xMethodLB->set_active(0); + + // binding box + Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY ); + if ( xModel.is() ) + { + try + { + Reference< XEnumerationAccess > xNumAccess = xModel->getBindings(); + if ( xNumAccess.is() ) + { + Reference < XEnumeration > xNum = xNumAccess->createEnumeration(); + if ( xNum.is() && xNum->hasMoreElements() ) + { + while ( xNum->hasMoreElements() ) + { + Reference< XPropertySet > xPropSet; + Any aAny = xNum->nextElement(); + if ( aAny >>= xPropSet ) + { + OUString sEntry; + OUString sTemp; + xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp; + sEntry += sTemp + ": "; + xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp; + sEntry += sTemp; + m_xBindLB->append_text(sEntry); + + if ( !m_xTempBinding.is() ) + m_xTempBinding = xPropSet; + } + } + } + } + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::FillAllBoxes()" ); + } + } + + // #i36342# we need a temporary binding; create one if no existing binding + // is found + if( !m_xTempBinding.is() ) + { + m_xCreatedBinding = m_xUIHelper->getBindingForNode( + Reference<css::xml::dom::XNode>( + xModel->getDefaultInstance()->getDocumentElement(), + UNO_QUERY_THROW ), + true ); + m_xTempBinding = m_xCreatedBinding; + } + + // replace box + m_xReplaceLB->append_text(SvxResId(RID_STR_REPLACE_NONE)); + m_xReplaceLB->append_text(SvxResId(RID_STR_REPLACE_INST)); + m_xReplaceLB->append_text(SvxResId(RID_STR_REPLACE_DOC)); + + + // init the controls with the values of the submission + if ( m_pItemNode && m_pItemNode->m_xPropSet.is() ) + { + m_xSubmission = m_pItemNode->m_xPropSet; + try + { + OUString sTemp; + m_xSubmission->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp; + m_xNameED->set_text( sTemp ); + m_xSubmission->getPropertyValue( PN_SUBMISSION_ACTION ) >>= sTemp; + m_xActionED->set_text( sTemp ); + m_xSubmission->getPropertyValue( PN_SUBMISSION_REF ) >>= sTemp; + m_xRefED->set_text(sTemp); + + m_xSubmission->getPropertyValue( PN_SUBMISSION_METHOD ) >>= sTemp; + sTemp = m_aMethodString.toUI( sTemp ); + sal_Int32 nPos = m_xMethodLB->find_text( sTemp ); + if (nPos == -1) + { + m_xMethodLB->append_text( sTemp ); + nPos = m_xMethodLB->get_count() - 1; + } + m_xMethodLB->set_active( nPos ); + + m_xSubmission->getPropertyValue( PN_SUBMISSION_BIND ) >>= sTemp; + nPos = m_xBindLB->find_text(sTemp); + if (nPos == -1) + { + m_xBindLB->append_text(sTemp); + nPos = m_xBindLB->get_count() - 1; + } + m_xBindLB->set_active(nPos); + + m_xSubmission->getPropertyValue( PN_SUBMISSION_REPLACE ) >>= sTemp; + sTemp = m_aReplaceString.toUI( sTemp ); + if ( sTemp.isEmpty() ) + sTemp = m_xReplaceLB->get_text(0); // first entry == "none" + nPos = m_xReplaceLB->find_text(sTemp); + if (nPos == -1) + { + m_xReplaceLB->append_text(sTemp); + nPos = m_xReplaceLB->get_count() - 1; + } + m_xReplaceLB->set_active(nPos); + } + catch ( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::FillAllBoxes()" ); + } + } + + m_xRefBtn->set_sensitive(m_xTempBinding.is()); + } + + AddModelDialog::AddModelDialog(weld::Window* pParent, bool bIsEdit) + : GenericDialogController(pParent, "svx/ui/addmodeldialog.ui", "AddModelDialog") + , m_xNameED(m_xBuilder->weld_entry("name")) + , m_xModifyCB(m_xBuilder->weld_check_button("modify")) + , m_xAltTitle(m_xBuilder->weld_label("alttitle")) + { + if (bIsEdit) + m_xDialog->set_title(m_xAltTitle->get_label()); + } + + AddModelDialog::~AddModelDialog() + { + } + + AddInstanceDialog::AddInstanceDialog(weld::Window* pParent, bool _bEdit) + : GenericDialogController(pParent, "svx/ui/addinstancedialog.ui", "AddInstanceDialog") + , m_xNameED(m_xBuilder->weld_entry("name")) + , m_xURLFT(m_xBuilder->weld_label("urlft")) + , m_xURLED(new SvtURLBox(m_xBuilder->weld_combo_box("url"))) + , m_xFilePickerBtn(m_xBuilder->weld_button("browse")) + , m_xLinkInstanceCB(m_xBuilder->weld_check_button("link")) + , m_xAltTitle(m_xBuilder->weld_label("alttitle")) + { + if (_bEdit) + m_xDialog->set_title(m_xAltTitle->get_label()); + + m_xURLED->DisableHistory(); + m_xFilePickerBtn->connect_clicked(LINK(this, AddInstanceDialog, FilePickerHdl)); + + // load the filter name from fps resource + m_sAllFilterName = Translate::get(STR_FILTERNAME_ALL, Translate::Create("fps")); + } + + AddInstanceDialog::~AddInstanceDialog() + { + } + + IMPL_LINK_NOARG(AddInstanceDialog, FilePickerHdl, weld::Button&, void) + { + ::sfx2::FileDialogHelper aDlg( + css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, + FileDialogFlags::NONE, m_xDialog.get()); + aDlg.SetContext(sfx2::FileDialogHelper::FormsAddInstance); + + aDlg.AddFilter( m_sAllFilterName, FILEDIALOG_FILTER_ALL ); + OUString sFilterName( "XML" ); + aDlg.AddFilter( sFilterName, "*.xml" ); + aDlg.SetCurrentFilter( sFilterName ); + + if (aDlg.Execute() == ERRCODE_NONE) + m_xURLED->set_entry_text(aDlg.GetPath()); + } + + LinkedInstanceWarningBox::LinkedInstanceWarningBox(weld::Widget* pParent) + : MessageDialogController(pParent, "svx/ui/formlinkwarndialog.ui", + "FormLinkWarnDialog") + { + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/dbcharsethelper.cxx b/svx/source/form/dbcharsethelper.cxx new file mode 100644 index 000000000..a20ffa7c1 --- /dev/null +++ b/svx/source/form/dbcharsethelper.cxx @@ -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 . + */ + +#include <dbcharsethelper.hxx> + +#include <connectivity/dbcharset.hxx> + +using namespace ::dbtools; + +namespace svxform::charset_helper +{ + + sal_Int32 getSupportedTextEncodings( ::std::vector< rtl_TextEncoding >& _rEncs ) + { + OCharsetMap aCharsetInfo; + _rEncs.clear(); + + OCharsetMap::const_iterator aLoop = aCharsetInfo.begin(); + OCharsetMap::const_iterator aLoopEnd = aCharsetInfo.end(); + while (aLoop != aLoopEnd) + { + _rEncs.push_back( (*aLoop).getEncoding() ); + ++aLoop; + } + + return _rEncs.size(); + } + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/delayedevent.cxx b/svx/source/form/delayedevent.cxx new file mode 100644 index 000000000..8a9cb218d --- /dev/null +++ b/svx/source/form/delayedevent.cxx @@ -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 . + */ + +#include <delayedevent.hxx> +#include <vcl/svapp.hxx> +#include <sal/log.hxx> + +namespace svxform +{ + void DelayedEvent::Call() + { + CancelPendingCall(); + SAL_WARN_IF( m_nEventId != nullptr, "svx.form", "DelayedEvent::Call: CancelPendingCall did not work!" ); + + m_nEventId = Application::PostUserEvent( LINK( this, DelayedEvent, OnCall ) ); + } + + void DelayedEvent::CancelPendingCall() + { + if ( m_nEventId ) + Application::RemoveUserEvent( m_nEventId ); + m_nEventId = nullptr; + } + + IMPL_LINK( DelayedEvent, OnCall, void*, _pArg, void ) + { + m_nEventId = nullptr; + m_aHandler.Call( _pArg ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/filtnav.cxx b/svx/source/form/filtnav.cxx new file mode 100644 index 000000000..9b1703f6a --- /dev/null +++ b/svx/source/form/filtnav.cxx @@ -0,0 +1,1850 @@ +/* -*- 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 <filtnav.hxx> +#include <fmexch.hxx> +#include <helpids.h> +#include <fmprop.hxx> +#include <svx/strings.hrc> + +#include <com/sun/star/awt/XControl.hpp> +#include <com/sun/star/form/runtime/XFormController.hpp> +#include <com/sun/star/util/NumberFormatter.hpp> +#include <com/sun/star/sdb/SQLContext.hpp> + +#include <comphelper/processfactory.hxx> +#include <comphelper/string.hxx> +#include <connectivity/dbtools.hxx> +#include <connectivity/sqlnode.hxx> +#include <cppuhelper/implbase.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <fmshimp.hxx> +#include <o3tl/safeint.hxx> +#include <sfx2/objitem.hxx> +#include <svx/dialmgr.hxx> +#include <svx/fmshell.hxx> +#include <svx/fmtools.hxx> +#include <svx/svxids.hrc> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/diagnose_ex.h> +#include <vcl/commandevent.hxx> +#include <vcl/event.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +#include <bitmaps.hlst> + +#include <functional> + +using namespace ::svxform; +using namespace ::connectivity; +using namespace ::dbtools; + +namespace svxform +{ + using ::com::sun::star::uno::Reference; + using ::com::sun::star::container::XIndexAccess; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::beans::XPropertySet; + using ::com::sun::star::form::runtime::XFormController; + using ::com::sun::star::form::runtime::XFilterController; + using ::com::sun::star::form::runtime::XFilterControllerListener; + using ::com::sun::star::form::runtime::FilterEvent; + using ::com::sun::star::lang::EventObject; + using ::com::sun::star::form::XForm; + using ::com::sun::star::container::XChild; + using ::com::sun::star::awt::XControl; + using ::com::sun::star::sdbc::XConnection; + using ::com::sun::star::util::XNumberFormatsSupplier; + using ::com::sun::star::util::XNumberFormatter; + using ::com::sun::star::util::NumberFormatter; + using ::com::sun::star::sdbc::XRowSet; + using ::com::sun::star::lang::Locale; + using ::com::sun::star::sdb::SQLContext; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::uno::UNO_SET_THROW; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::uno::Sequence; + + +OFilterItemExchange::OFilterItemExchange() + : m_pFormItem(nullptr) +{ +} + +void OFilterItemExchange::AddSupportedFormats() +{ + AddFormat(getFormatId()); +} + +SotClipboardFormatId OFilterItemExchange::getFormatId() +{ + static SotClipboardFormatId s_nFormat = + SotExchange::RegisterFormatName("application/x-openoffice;windows_formatname=\"form.FilterControlExchange\""); + DBG_ASSERT(static_cast<SotClipboardFormatId>(-1) != s_nFormat, "OFilterExchangeHelper::getFormatId: bad exchange id!"); + return s_nFormat; +} + +rtl::Reference<OLocalExchange> OFilterExchangeHelper::createExchange() const +{ + return new OFilterItemExchange; +} + +OUString FmFilterData::GetImage() const +{ + return OUString(); +} + +FmParentData::~FmParentData() +{ +} + +OUString FmFormItem::GetImage() const +{ + return RID_SVXBMP_FORM; +} + +FmFilterItem* FmFilterItems::Find( const ::sal_Int32 _nFilterComponentIndex ) const +{ + for ( auto & pData : m_aChildren ) + { + FmFilterItem& rCondition = dynamic_cast<FmFilterItem&>(*pData); + if ( _nFilterComponentIndex == rCondition.GetComponentIndex() ) + return &rCondition; + } + return nullptr; +} + +OUString FmFilterItems::GetImage() const +{ + return RID_SVXBMP_FILTER; +} + +FmFilterItem::FmFilterItem( FmFilterItems* pParent, + const OUString& aFieldName, + const OUString& aText, + const sal_Int32 _nComponentIndex ) + :FmFilterData(pParent, aText) + ,m_aFieldName(aFieldName) + ,m_nComponentIndex( _nComponentIndex ) +{ +} + +OUString FmFilterItem::GetImage() const +{ + return RID_SVXBMP_FIELD; +} + +// Hints for communication between model and view + +namespace { + +class FmFilterHint : public SfxHint +{ + FmFilterData* m_pData; + +public: + explicit FmFilterHint(FmFilterData* pData):m_pData(pData){} + FmFilterData* GetData() const { return m_pData; } +}; + +class FmFilterInsertedHint : public FmFilterHint +{ + size_t m_nPos; // Position relative to the parent of the data + +public: + FmFilterInsertedHint(FmFilterData* pData, size_t nRelPos) + :FmFilterHint(pData) + ,m_nPos(nRelPos){} + + size_t GetPos() const { return m_nPos; } +}; + +class FmFilterRemovedHint : public FmFilterHint +{ +public: + explicit FmFilterRemovedHint(FmFilterData* pData) + :FmFilterHint(pData){} +}; + + +class FmFilterTextChangedHint : public FmFilterHint +{ +public: + explicit FmFilterTextChangedHint(FmFilterData* pData) + :FmFilterHint(pData){} +}; + +class FilterClearingHint : public SfxHint +{ +public: + FilterClearingHint(){} +}; + +class FmFilterCurrentChangedHint : public SfxHint +{ +public: + FmFilterCurrentChangedHint(){} +}; + +} + +// class FmFilterAdapter, listener at the FilterControls +class FmFilterAdapter : public ::cppu::WeakImplHelper< XFilterControllerListener > +{ + FmFilterModel* m_pModel; + Reference< XIndexAccess > m_xControllers; + +public: + FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers); + +// XEventListener + virtual void SAL_CALL disposing(const EventObject& Source) override; + +// XFilterControllerListener + virtual void SAL_CALL predicateExpressionChanged( const FilterEvent& Event ) override; + virtual void SAL_CALL disjunctiveTermRemoved( const FilterEvent& Event ) override; + virtual void SAL_CALL disjunctiveTermAdded( const FilterEvent& Event ) override; + +// helpers + /// @throws RuntimeException + void dispose(); + + void AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd ); + + static void setText(sal_Int32 nPos, + const FmFilterItem* pFilterItem, + const OUString& rText); +}; + + +FmFilterAdapter::FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers) + :m_pModel( pModel ) + ,m_xControllers( xControllers ) +{ + AddOrRemoveListener( m_xControllers, true ); +} + + +void FmFilterAdapter::dispose() +{ + AddOrRemoveListener( m_xControllers, false ); +} + + +void FmFilterAdapter::AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd ) +{ + for (sal_Int32 i = 0, nLen = _rxControllers->getCount(); i < nLen; ++i) + { + Reference< XIndexAccess > xElement( _rxControllers->getByIndex(i), UNO_QUERY ); + + // step down + AddOrRemoveListener( xElement, _bAdd ); + + // handle this particular controller + Reference< XFilterController > xController( xElement, UNO_QUERY ); + OSL_ENSURE( xController.is(), "FmFilterAdapter::InsertElements: no XFilterController, cannot sync data!" ); + if ( xController.is() ) + { + if ( _bAdd ) + xController->addFilterControllerListener( this ); + else + xController->removeFilterControllerListener( this ); + } + } +} + + +void FmFilterAdapter::setText(sal_Int32 nRowPos, + const FmFilterItem* pFilterItem, + const OUString& rText) +{ + FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( pFilterItem->GetParent()->GetParent() ); + assert(pFormItem); + try + { + Reference< XFilterController > xController( pFormItem->GetController(), UNO_QUERY_THROW ); + xController->setPredicateExpression( pFilterItem->GetComponentIndex(), nRowPos, rText ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +// XEventListener + +void SAL_CALL FmFilterAdapter::disposing(const EventObject& /*e*/) +{ +} + + +namespace +{ + OUString lcl_getLabelName_nothrow( const Reference< XControl >& _rxControl ) + { + OUString sLabelName; + try + { + Reference< XPropertySet > xModel( _rxControl->getModel(), UNO_QUERY_THROW ); + sLabelName = getLabelName( xModel ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return sLabelName; + } + + Reference< XPropertySet > lcl_getBoundField_nothrow( const Reference< XControl >& _rxControl ) + { + Reference< XPropertySet > xField; + try + { + Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY_THROW ); + xField.set( xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY_THROW ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return xField; + } +} + +// XFilterControllerListener +void FmFilterAdapter::predicateExpressionChanged( const FilterEvent& Event ) +{ + SolarMutexGuard aGuard; + + if ( !m_pModel ) + return; + + // the controller which sent the event + Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW ); + Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW ); + Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW ); + + FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm ); + OSL_ENSURE( pFormItem, "FmFilterAdapter::predicateExpressionChanged: don't know this form!" ); + if ( !pFormItem ) + return; + + const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() ); + + FmFilterData* pData = pFormItem->GetChildren()[nActiveTerm].get(); + FmFilterItems& rFilter = dynamic_cast<FmFilterItems&>(*pData); + FmFilterItem* pFilterItem = rFilter.Find( Event.FilterComponent ); + if ( pFilterItem ) + { + if ( !Event.PredicateExpression.isEmpty()) + { + pFilterItem->SetText( Event.PredicateExpression ); + // notify the UI + FmFilterTextChangedHint aChangeHint(pFilterItem); + m_pModel->Broadcast( aChangeHint ); + } + else + { + // no text anymore so remove the condition + m_pModel->Remove(pFilterItem); + } + } + else + { + // searching the component by field name + OUString aFieldName( lcl_getLabelName_nothrow( xFilterController->getFilterComponent( Event.FilterComponent ) ) ); + + std::unique_ptr<FmFilterItem> pNewFilterItem(new FmFilterItem(&rFilter, aFieldName, Event.PredicateExpression, Event.FilterComponent)); + m_pModel->Insert(rFilter.GetChildren().end(), std::move(pNewFilterItem)); + } + + // ensure there's one empty term in the filter, just in case the active term was previously empty + m_pModel->EnsureEmptyFilterRows( *pFormItem ); +} + + +void SAL_CALL FmFilterAdapter::disjunctiveTermRemoved( const FilterEvent& Event ) +{ + SolarMutexGuard aGuard; + + Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW ); + Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW ); + Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW ); + + FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm ); + OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermRemoved: don't know this form!" ); + if ( !pFormItem ) + return; + + auto& rTermItems = pFormItem->GetChildren(); + const bool bValidIndex = ( Event.DisjunctiveTerm >= 0 ) && ( o3tl::make_unsigned(Event.DisjunctiveTerm) < rTermItems.size() ); + OSL_ENSURE( bValidIndex, "FmFilterAdapter::disjunctiveTermRemoved: invalid term index!" ); + if ( !bValidIndex ) + return; + + // if the first term was removed, then the to-be first term needs its text updated + if ( Event.DisjunctiveTerm == 0 ) + { + rTermItems[1]->SetText( SvxResId(RID_STR_FILTER_FILTER_FOR)); + FmFilterTextChangedHint aChangeHint( rTermItems[1].get() ); + m_pModel->Broadcast( aChangeHint ); + } + + // finally remove the entry from the model + m_pModel->Remove( rTermItems.begin() + Event.DisjunctiveTerm ); + + // ensure there's one empty term in the filter, just in case the currently removed one was the last empty one + m_pModel->EnsureEmptyFilterRows( *pFormItem ); +} + + +void SAL_CALL FmFilterAdapter::disjunctiveTermAdded( const FilterEvent& Event ) +{ + SolarMutexGuard aGuard; + + Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW ); + Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW ); + Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW ); + + FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm ); + OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermAdded: don't know this form!" ); + if ( !pFormItem ) + return; + + const sal_Int32 nInsertPos = Event.DisjunctiveTerm; + bool bValidIndex = ( nInsertPos >= 0 ) && ( o3tl::make_unsigned(nInsertPos) <= pFormItem->GetChildren().size() ); + if ( !bValidIndex ) + { + OSL_FAIL( "FmFilterAdapter::disjunctiveTermAdded: invalid index!" ); + return; + } + + auto insertPos = pFormItem->GetChildren().begin() + nInsertPos; + + // "Filter for" for first position, "Or" for the other positions + std::unique_ptr<FmFilterItems> pFilterItems(new FmFilterItems(pFormItem, (nInsertPos?SvxResId(RID_STR_FILTER_FILTER_OR):SvxResId(RID_STR_FILTER_FILTER_FOR)))); + m_pModel->Insert( insertPos, std::move(pFilterItems) ); +} + + +FmFilterModel::FmFilterModel() + :FmParentData(nullptr, OUString()) + ,OSQLParserClient(comphelper::getProcessComponentContext()) + ,m_pCurrentItems(nullptr) +{ +} + + +FmFilterModel::~FmFilterModel() +{ + Clear(); +} + + +void FmFilterModel::Clear() +{ + // notify + FilterClearingHint aClearedHint; + Broadcast( aClearedHint ); + + // lose endings + if (m_pAdapter.is()) + { + m_pAdapter->dispose(); + m_pAdapter.clear(); + } + + m_pCurrentItems = nullptr; + m_xController = nullptr; + m_xControllers = nullptr; + + m_aChildren.clear(); +} + + +void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent) +{ + if ( xCurrent == m_xController ) + return; + + if (!xControllers.is()) + { + Clear(); + return; + } + + // there is only a new current controller + if ( m_xControllers != xControllers ) + { + Clear(); + + m_xControllers = xControllers; + Update(m_xControllers, this); + + DBG_ASSERT(xCurrent.is(), "FmFilterModel::Update(...) no current controller"); + + // Listening for TextChanges + m_pAdapter = new FmFilterAdapter(this, xControllers); + + SetCurrentController(xCurrent); + EnsureEmptyFilterRows( *this ); + } + else + SetCurrentController(xCurrent); +} + + +void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, FmParentData* pParent) +{ + try + { + sal_Int32 nCount = xControllers->getCount(); + for ( sal_Int32 i = 0; i < nCount; ++i ) + { + Reference< XFormController > xController( xControllers->getByIndex(i), UNO_QUERY_THROW ); + + Reference< XPropertySet > xFormProperties( xController->getModel(), UNO_QUERY_THROW ); + OUString aName; + OSL_VERIFY( xFormProperties->getPropertyValue( FM_PROP_NAME ) >>= aName ); + + // Insert a new item for the form + FmFormItem* pFormItem = new FmFormItem( pParent, xController, aName ); + Insert( pParent->GetChildren().end(), std::unique_ptr<FmFilterData>(pFormItem) ); + + Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW ); + + // insert the existing filters for the form + OUString aTitle(SvxResId(RID_STR_FILTER_FILTER_FOR)); + + const Sequence< Sequence< OUString > > aExpressions = xFilterController->getPredicateExpressions(); + for ( auto const & conjunctionTerm : aExpressions ) + { + // we always display one row, even if there's no term to be displayed + FmFilterItems* pFilterItems = new FmFilterItems( pFormItem, aTitle ); + Insert( pFormItem->GetChildren().end(), std::unique_ptr<FmFilterData>(pFilterItems) ); + + const Sequence< OUString >& rDisjunction( conjunctionTerm ); + sal_Int32 nComponentIndex = -1; + for ( const OUString& rDisjunctiveTerm : rDisjunction ) + { + ++nComponentIndex; + + if ( rDisjunctiveTerm.isEmpty() ) + // no condition for this particular component in this particular conjunction term + continue; + + // determine the display name of the control + const Reference< XControl > xFilterControl( xFilterController->getFilterComponent( nComponentIndex ) ); + const OUString sDisplayName( lcl_getLabelName_nothrow( xFilterControl ) ); + + // insert a new entry + std::unique_ptr<FmFilterItem> pANDCondition(new FmFilterItem( pFilterItems, sDisplayName, rDisjunctiveTerm, nComponentIndex )); + Insert( pFilterItems->GetChildren().end(), std::move(pANDCondition) ); + } + + // title for the next conditions + aTitle = SvxResId( RID_STR_FILTER_FILTER_OR ); + } + + // now add dependent controllers + Update( xController, pFormItem ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +FmFormItem* FmFilterModel::Find(const ::std::vector<std::unique_ptr<FmFilterData>>& rItems, const Reference< XFormController > & xController) const +{ + for (const auto& rItem : rItems) + { + FmFormItem* pForm = dynamic_cast<FmFormItem*>( rItem.get() ); + if (pForm) + { + if ( xController == pForm->GetController() ) + return pForm; + else + { + pForm = Find(pForm->GetChildren(), xController); + if (pForm) + return pForm; + } + } + } + return nullptr; +} + + +FmFormItem* FmFilterModel::Find(const ::std::vector<std::unique_ptr<FmFilterData>>& rItems, const Reference< XForm >& xForm) const +{ + for (const auto& rItem : rItems) + { + FmFormItem* pForm = dynamic_cast<FmFormItem*>( rItem.get() ); + if (pForm) + { + if (xForm == pForm->GetController()->getModel()) + return pForm; + else + { + pForm = Find(pForm->GetChildren(), xForm); + if (pForm) + return pForm; + } + } + } + return nullptr; +} + +void FmFilterModel::SetCurrentController(const Reference< XFormController > & xCurrent) +{ + if ( xCurrent == m_xController ) + return; + + m_xController = xCurrent; + + FmFormItem* pItem = Find( m_aChildren, xCurrent ); + if ( !pItem ) + return; + + try + { + Reference< XFilterController > xFilterController( m_xController, UNO_QUERY_THROW ); + const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() ); + if (nActiveTerm != -1 && pItem->GetChildren().size() > o3tl::make_unsigned(nActiveTerm)) + { + SetCurrentItems( static_cast< FmFilterItems* >( pItem->GetChildren()[ nActiveTerm ].get() ) ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + +void FmFilterModel::AppendFilterItems( FmFormItem& _rFormItem ) +{ + // insert the condition behind the last filter items + auto iter = std::find_if(_rFormItem.GetChildren().rbegin(), _rFormItem.GetChildren().rend(), + [](const std::unique_ptr<FmFilterData>& rChild) { return dynamic_cast<const FmFilterItems*>(rChild.get()) != nullptr; }); + + sal_Int32 nInsertPos = iter.base() - _rFormItem.GetChildren().begin(); + // delegate this to the FilterController, it will notify us, which will let us update our model + try + { + Reference< XFilterController > xFilterController( _rFormItem.GetFilterController(), UNO_SET_THROW ); + if ( nInsertPos >= xFilterController->getDisjunctiveTerms() ) + xFilterController->appendEmptyDisjunctiveTerm(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + +void FmFilterModel::Insert(const ::std::vector<std::unique_ptr<FmFilterData>>::iterator& rPos, std::unique_ptr<FmFilterData> pData) +{ + auto pTemp = pData.get(); + size_t nPos; + ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pData->GetParent()->GetChildren(); + if (rPos == rItems.end()) + { + nPos = rItems.size(); + rItems.push_back(std::move(pData)); + } + else + { + nPos = rPos - rItems.begin(); + rItems.insert(rPos, std::move(pData)); + } + + // notify the UI + FmFilterInsertedHint aInsertedHint(pTemp, nPos); + Broadcast( aInsertedHint ); +} + +void FmFilterModel::Remove(FmFilterData* pData) +{ + FmParentData* pParent = pData->GetParent(); + ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pParent->GetChildren(); + + // erase the item from the model + auto i = ::std::find_if(rItems.begin(), rItems.end(), + [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pData; } ); + DBG_ASSERT(i != rItems.end(), "FmFilterModel::Remove(): unknown Item"); + // position within the parent + sal_Int32 nPos = i - rItems.begin(); + if (auto pFilterItems = dynamic_cast<FmFilterItems*>( pData)) + { + FmFormItem* pFormItem = static_cast<FmFormItem*>(pParent); + + try + { + Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW ); + + bool bEmptyLastTerm = ( ( nPos == 0 ) && xFilterController->getDisjunctiveTerms() == 1 ); + if ( bEmptyLastTerm ) + { + // remove all children (by setting an empty predicate expression) + ::std::vector< std::unique_ptr<FmFilterData> >& rChildren = pFilterItems->GetChildren(); + while ( !rChildren.empty() ) + { + auto removePos = rChildren.end() - 1; + if (FmFilterItem* pFilterItem = dynamic_cast<FmFilterItem*>( removePos->get() )) + { + FmFilterAdapter::setText( nPos, pFilterItem, OUString() ); + } + Remove( removePos ); + } + } + else + { + xFilterController->removeDisjunctiveTerm( nPos ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + else // FormItems can not be deleted + { + FmFilterItem& rFilterItem = dynamic_cast<FmFilterItem&>(*pData); + + // if it's the last condition remove the parent + if (rItems.size() == 1) + Remove(rFilterItem.GetParent()); + else + { + // find the position of the father within his father + ::std::vector<std::unique_ptr<FmFilterData>>& rParentParentItems = pData->GetParent()->GetParent()->GetChildren(); + auto j = ::std::find_if(rParentParentItems.begin(), rParentParentItems.end(), + [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == rFilterItem.GetParent(); }); + DBG_ASSERT(j != rParentParentItems.end(), "FmFilterModel::Remove(): unknown Item"); + sal_Int32 nParentPos = j - rParentParentItems.begin(); + + // EmptyText removes the filter + FmFilterAdapter::setText(nParentPos, &rFilterItem, OUString()); + Remove( i ); + } + } +} + +void FmFilterModel::Remove( const ::std::vector<std::unique_ptr<FmFilterData>>::iterator& rPos ) +{ + // remove from parent's child list + std::unique_ptr<FmFilterData> pData = std::move(*rPos); + pData->GetParent()->GetChildren().erase( rPos ); + + // notify the view, this will remove the actual SvTreeListEntry + FmFilterRemovedHint aRemoveHint( pData.get() ); + Broadcast( aRemoveHint ); +} + + +bool FmFilterModel::ValidateText(FmFilterItem const * pItem, OUString& rText, OUString& rErrorMsg) const +{ + FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( pItem->GetParent()->GetParent() ); + assert(pFormItem); + try + { + Reference< XFormController > xFormController( pFormItem->GetController() ); + // obtain the connection of the form belonging to the controller + Reference< XRowSet > xRowSet( xFormController->getModel(), UNO_QUERY_THROW ); + Reference< XConnection > xConnection( getConnection( xRowSet ) ); + + // obtain a number formatter for this connection + // TODO: shouldn't this be cached? + Reference< XNumberFormatsSupplier > xFormatSupplier = getNumberFormats( xConnection, true ); + Reference< XNumberFormatter > xFormatter( NumberFormatter::create( comphelper::getProcessComponentContext() ), UNO_QUERY_THROW ); + xFormatter->attachNumberFormatsSupplier( xFormatSupplier ); + + // get the field (database column) which the item is responsible for + Reference< XFilterController > xFilterController( xFormController, UNO_QUERY_THROW ); + Reference< XPropertySet > xField( lcl_getBoundField_nothrow( xFilterController->getFilterComponent( pItem->GetComponentIndex() ) ), UNO_SET_THROW ); + + // parse the given text as filter predicate + OUString aErr, aTxt( rText ); + std::unique_ptr< OSQLParseNode > pParseNode = predicateTree( aErr, aTxt, xFormatter, xField ); + rErrorMsg = aErr; + rText = aTxt; + if ( pParseNode != nullptr ) + { + OUString aPreparedText; + Locale aAppLocale = Application::GetSettings().GetUILanguageTag().getLocale(); + pParseNode->parseNodeToPredicateStr( + aPreparedText, xConnection, xFormatter, xField, OUString(), aAppLocale, OUString("."), getParseContext() ); + rText = aPreparedText; + return true; + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + return false; +} + + +void FmFilterModel::Append(FmFilterItems* pItems, std::unique_ptr<FmFilterItem> pFilterItem) +{ + Insert(pItems->GetChildren().end(), std::move(pFilterItem)); +} + + +void FmFilterModel::SetTextForItem(FmFilterItem* pItem, const OUString& rText) +{ + ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pItem->GetParent()->GetParent()->GetChildren(); + auto i = ::std::find_if(rItems.begin(), rItems.end(), + [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pItem->GetParent(); }); + sal_Int32 nParentPos = i - rItems.begin(); + + FmFilterAdapter::setText(nParentPos, pItem, rText); + + if (rText.isEmpty()) + Remove(pItem); + else + { + // Change the text + pItem->SetText(rText); + FmFilterTextChangedHint aChangeHint(pItem); + Broadcast( aChangeHint ); + } +} + + +void FmFilterModel::SetCurrentItems(FmFilterItems* pCurrent) +{ + if (m_pCurrentItems == pCurrent) + return; + + // search for the condition + if (pCurrent) + { + FmFormItem* pFormItem = static_cast<FmFormItem*>(pCurrent->GetParent()); + ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pFormItem->GetChildren(); + auto i = ::std::find_if(rItems.begin(), rItems.end(), + [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pCurrent; }); + + if (i != rItems.end()) + { + // determine the filter position + sal_Int32 nPos = i - rItems.begin(); + try + { + Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW ); + xFilterController->setActiveTerm( nPos ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + if ( m_xController != pFormItem->GetController() ) + // calls SetCurrentItems again + SetCurrentController( pFormItem->GetController() ); + else + m_pCurrentItems = pCurrent; + } + else + m_pCurrentItems = nullptr; + } + else + m_pCurrentItems = nullptr; + + + // notify the UI + FmFilterCurrentChangedHint aHint; + Broadcast( aHint ); +} + + +void FmFilterModel::EnsureEmptyFilterRows( FmParentData& _rItem ) +{ + // checks whether for each form there's one free level for input + ::std::vector< std::unique_ptr<FmFilterData> >& rChildren = _rItem.GetChildren(); + bool bAppendLevel = dynamic_cast<const FmFormItem*>(&_rItem) != nullptr; + + for ( const auto& rpChild : rChildren ) + { + FmFilterItems* pItems = dynamic_cast<FmFilterItems*>( rpChild.get() ); + if ( pItems && pItems->GetChildren().empty() ) + { + bAppendLevel = false; + break; + } + + FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( rpChild.get() ); + if (pFormItem) + { + EnsureEmptyFilterRows( *pFormItem ); + continue; + } + } + + if ( bAppendLevel ) + { + FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( &_rItem ); + OSL_ENSURE( pFormItem, "FmFilterModel::EnsureEmptyFilterRows: no FmFormItem, but a FmFilterItems child?" ); + if ( pFormItem ) + AppendFilterItems( *pFormItem ); + } +} + +const int nxD = 4; +const int nxDBmp = 12; + +IMPL_STATIC_LINK(FmFilterNavigator, CustomGetSizeHdl, weld::TreeView::get_size_args, aPayload, Size) +{ + vcl::RenderContext& rRenderContext = aPayload.first; + const OUString& rId = aPayload.second; + + Size aSize; + + FmFilterData* pData = weld::fromId<FmFilterData*>(rId); + OUString sText = pData->GetText(); + + if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData)) + { + rRenderContext.Push(vcl::PushFlags::FONT); + vcl::Font aFont(rRenderContext.GetFont()); + aFont.SetWeight(WEIGHT_BOLD); + rRenderContext.SetFont(aFont); + + OUString sName = pItem->GetFieldName() + ": "; + aSize = Size(rRenderContext.GetTextWidth(sName), rRenderContext.GetTextHeight()); + + rRenderContext.Pop(); + + aSize.AdjustWidth(rRenderContext.GetTextWidth(sText) + nxD); + } + else + { + aSize = Size(rRenderContext.GetTextWidth(sText), rRenderContext.GetTextHeight()); + if (dynamic_cast<FmFilterItems*>(pData)) + aSize.AdjustWidth(nxDBmp); + } + + return aSize; +} + +IMPL_STATIC_LINK(FmFilterNavigator, CustomRenderHdl, weld::TreeView::render_args, aPayload, void) +{ + vcl::RenderContext& rRenderContext = std::get<0>(aPayload); + const ::tools::Rectangle& rRect = std::get<1>(aPayload); + ::tools::Rectangle aRect(rRect.TopLeft(), Size(rRenderContext.GetOutputSize().Width() - rRect.Left(), rRect.GetHeight())); + bool bSelected = std::get<2>(aPayload); + const OUString& rId = std::get<3>(aPayload); + + rRenderContext.Push(vcl::PushFlags::TEXTCOLOR); + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + if (bSelected) + rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor()); + else + rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor()); + + FmFilterData* pData = weld::fromId<FmFilterData*>(rId); + OUString sText = pData->GetText(); + Point aPos(aRect.TopLeft()); + + if (FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pData)) + { + vcl::Font aFont(rRenderContext.GetFont()); + aFont.SetWeight(WEIGHT_BOLD); + + rRenderContext.Push(vcl::PushFlags::FONT); + rRenderContext.SetFont(aFont); + + OUString sName = pFilter->GetFieldName() + ": "; + rRenderContext.DrawText(aPos, sName); + + // position for the second text + aPos.AdjustX(rRenderContext.GetTextWidth(sName) + nxD); + rRenderContext.Pop(); + + rRenderContext.DrawText(aPos, sText); + } + else if (FmFilterItems* pRow = dynamic_cast<FmFilterItems*>(pData)) + { + FmFormItem* pForm = static_cast<FmFormItem*>(pRow->GetParent()); + + // current filter is significant painted + const bool bIsCurrentFilter = pForm->GetChildren()[ pForm->GetFilterController()->getActiveTerm() ].get() == pRow; + if (bIsCurrentFilter) + { + rRenderContext.Push(vcl::PushFlags::LINECOLOR); + rRenderContext.SetLineColor(rRenderContext.GetTextColor()); + + Point aFirst(aPos.X(), aRect.Bottom() - 6); + Point aSecond(aFirst .X() + 2, aFirst.Y() + 3); + + rRenderContext.DrawLine(aFirst, aSecond); + + aFirst = aSecond; + aFirst.AdjustX(1); + aSecond.AdjustX(6); + aSecond.AdjustY(-5); + + rRenderContext.DrawLine(aFirst, aSecond); + rRenderContext.Pop(); + } + + rRenderContext.DrawText(Point(aPos.X() + nxDBmp, aPos.Y()), sText); + } + else + rRenderContext.DrawText(aPos, sText); + + rRenderContext.Pop(); +} + +FmFilterNavigatorDropTarget::FmFilterNavigatorDropTarget(FmFilterNavigator& rTreeView) + : DropTargetHelper(rTreeView.get_widget().get_drop_target()) + , m_rTreeView(rTreeView) +{ +} + +sal_Int8 FmFilterNavigatorDropTarget::AcceptDrop(const AcceptDropEvent& rEvt) +{ + sal_Int8 nAccept = m_rTreeView.AcceptDrop(rEvt); + + if (nAccept != DND_ACTION_NONE) + { + // to enable the autoscroll when we're close to the edges + weld::TreeView& rWidget = m_rTreeView.get_widget(); + rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr, true); + } + + return nAccept; +} + +sal_Int8 FmFilterNavigatorDropTarget::ExecuteDrop(const ExecuteDropEvent& rEvt) +{ + return m_rTreeView.ExecuteDrop(rEvt); +} + +FmFilterNavigator::FmFilterNavigator(vcl::Window* pTopLevel, std::unique_ptr<weld::TreeView> xTreeView) + : m_xTopLevel(pTopLevel) + , m_xTreeView(std::move(xTreeView)) + , m_aDropTargetHelper(*this) + , m_nAsyncRemoveEvent(nullptr) +{ + m_xTreeView->set_help_id(HID_FILTER_NAVIGATOR); + + m_xTreeView->set_selection_mode(SelectionMode::Multiple); + + m_pModel.reset( new FmFilterModel() ); + StartListening( *m_pModel ); + + m_xTreeView->connect_custom_get_size(LINK(this, FmFilterNavigator, CustomGetSizeHdl)); + m_xTreeView->connect_custom_render(LINK(this, FmFilterNavigator, CustomRenderHdl)); + m_xTreeView->set_column_custom_renderer(0, true); + + m_xTreeView->connect_changed(LINK(this, FmFilterNavigator, SelectHdl)); + m_xTreeView->connect_key_press(LINK(this, FmFilterNavigator, KeyInputHdl)); + m_xTreeView->connect_popup_menu(LINK(this, FmFilterNavigator, PopupMenuHdl)); + m_xTreeView->connect_editing(LINK(this, FmFilterNavigator, EditingEntryHdl), + LINK(this, FmFilterNavigator, EditedEntryHdl)); + m_xTreeView->connect_drag_begin(LINK(this, FmFilterNavigator, DragBeginHdl)); +} + +FmFilterNavigator::~FmFilterNavigator() +{ + if (m_nAsyncRemoveEvent) + Application::RemoveUserEvent(m_nAsyncRemoveEvent); + EndListening(*m_pModel); + m_pModel.reset(); +} + +void FmFilterNavigator::UpdateContent(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent) +{ + if (xCurrent == m_pModel->GetCurrentController()) + return; + + m_pModel->Update(xControllers, xCurrent); + + // expand the filters for the current controller + std::unique_ptr<weld::TreeIter> xEntry = FindEntry(m_pModel->GetCurrentForm()); + if (!xEntry || m_xTreeView->get_row_expanded(*xEntry)) + return; + + m_xTreeView->unselect_all(); + + m_xTreeView->expand_row(*xEntry); + + xEntry = FindEntry(m_pModel->GetCurrentItems()); + if (xEntry) + { + if (!m_xTreeView->get_row_expanded(*xEntry)) + m_xTreeView->expand_row(*xEntry); + m_xTreeView->select(*xEntry); + SelectHdl(*m_xTreeView); + } +} + +IMPL_LINK(FmFilterNavigator, EditingEntryHdl, const weld::TreeIter&, rIter, bool) +{ + // returns true to allow editing + if (dynamic_cast<const FmFilterItem*>(weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter)))) + { + m_xEditingCurrently = m_xTreeView->make_iterator(&rIter); + return true; + } + m_xEditingCurrently.reset(); + return false; +} + +IMPL_LINK(FmFilterNavigator, EditedEntryHdl, const IterString&, rIterString, bool) +{ + const weld::TreeIter& rIter = rIterString.first; + const OUString& rNewText = rIterString.second; + + assert(m_xEditingCurrently && m_xTreeView->iter_compare(rIter, *m_xEditingCurrently) == 0 && + "FmFilterNavigator::EditedEntry: suspicious entry!"); + m_xEditingCurrently.reset(); + + FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter)); + + DBG_ASSERT(dynamic_cast<const FmFilterItem*>(pData) != nullptr, + "FmFilterNavigator::EditedEntry() wrong entry"); + + OUString aText(comphelper::string::strip(rNewText, ' ')); + if (aText.isEmpty()) + { + // deleting the entry asynchron + m_nAsyncRemoveEvent = Application::PostUserEvent(LINK(this, FmFilterNavigator, OnRemove), pData); + } + else + { + OUString aErrorMsg; + + if (m_pModel->ValidateText(static_cast<FmFilterItem*>(pData), aText, aErrorMsg)) + { + // this will set the text at the FmFilterItem, as well as update any filter controls + // which are connected to this particular entry + m_pModel->SetTextForItem(static_cast<FmFilterItem*>(pData), aText); + m_xTreeView->set_text(rIter, aText); + } + else + { + // display the error and return sal_False + SQLContext aError; + aError.Message = SvxResId(RID_STR_SYNTAXERROR); + aError.Details = aErrorMsg; + displayException(aError, VCLUnoHelper::GetInterface(m_xTopLevel)); + + return false; + } + } + return true; +} + +IMPL_LINK( FmFilterNavigator, OnRemove, void*, p, void ) +{ + m_nAsyncRemoveEvent = nullptr; + // now remove the entry + m_pModel->Remove(static_cast<FmFilterData*>(p)); +} + +sal_Int8 FmFilterNavigator::AcceptDrop( const AcceptDropEvent& rEvt ) +{ + if (!m_aControlExchange.isDragSource()) + return DND_ACTION_NONE; + + if (!OFilterItemExchange::hasFormat(m_aDropTargetHelper.GetDataFlavorExVector())) + return DND_ACTION_NONE; + + // do we contain the formitem? + if (!FindEntry(m_aControlExchange->getFormItem())) + return DND_ACTION_NONE; + + Point aDropPos = rEvt.maPosPixel; + std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator()); + // get_dest_row_at_pos with false cause we must drop exactly "on" a node to paste a condition into it + if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false)) + xDropTarget.reset(); + + if (!xDropTarget) + return DND_ACTION_NONE; + + FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xDropTarget)); + FmFormItem* pForm = nullptr; + if (dynamic_cast<const FmFilterItem*>(pData) != nullptr) + { + pForm = dynamic_cast<FmFormItem*>( pData->GetParent()->GetParent() ); + if (pForm != m_aControlExchange->getFormItem()) + return DND_ACTION_NONE; + } + else if (dynamic_cast<const FmFilterItems*>( pData) != nullptr) + { + pForm = dynamic_cast<FmFormItem*>( pData->GetParent() ); + if (pForm != m_aControlExchange->getFormItem()) + return DND_ACTION_NONE; + } + else + return DND_ACTION_NONE; + + return rEvt.mnAction; +} + +namespace +{ + FmFilterItems* getTargetItems(const weld::TreeView& rTreeView, const weld::TreeIter& rTarget) + { + FmFilterData* pData = weld::fromId<FmFilterData*>(rTreeView.get_id(rTarget)); + FmFilterItems* pTargetItems = dynamic_cast<FmFilterItems*>(pData); + if (!pTargetItems) + pTargetItems = dynamic_cast<FmFilterItems*>(pData->GetParent()); + return pTargetItems; + } +} + +sal_Int8 FmFilterNavigator::ExecuteDrop( const ExecuteDropEvent& rEvt ) +{ + if (!m_aControlExchange.isDragSource()) + return DND_ACTION_NONE; + + Point aDropPos = rEvt.maPosPixel; + std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator()); + // get_dest_row_at_pos with false cause we must drop exactly "on" a node to paste a condition into it + if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false)) + xDropTarget.reset(); + if (!xDropTarget) + return DND_ACTION_NONE; + + // search the container where to add the items + FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xDropTarget); + m_xTreeView->unselect_all(); + std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pTargetItems); + if (xEntry) + { + m_xTreeView->select(*xEntry); + m_xTreeView->set_cursor(*xEntry); + } + + insertFilterItem(m_aControlExchange->getDraggedEntries(),pTargetItems,DND_ACTION_COPY == rEvt.mnAction); + + return DND_ACTION_COPY; +} + +IMPL_LINK_NOARG(FmFilterNavigator, SelectHdl, weld::TreeView&, void) +{ + std::unique_ptr<weld::TreeIter> xIter(m_xTreeView->make_iterator()); + if (!m_xTreeView->get_selected(xIter.get())) + return; + + FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xIter)); + + FmFormItem* pFormItem = nullptr; + if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData)) + pFormItem = static_cast<FmFormItem*>(pItem->GetParent()->GetParent()); + else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData)) + pFormItem = static_cast<FmFormItem*>(pItems->GetParent()->GetParent()); + else + pFormItem = dynamic_cast<FmFormItem*>(pData); + + if (pFormItem) + { + // will the controller be exchanged? + if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData)) + m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(pItem->GetParent())); + else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData)) + m_pModel->SetCurrentItems(pItems); + else + m_pModel->SetCurrentController(pFormItem->GetController()); + } +} + +void FmFilterNavigator::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) +{ + if (const FmFilterInsertedHint* pInsertHint = dynamic_cast<const FmFilterInsertedHint*>(&rHint)) + { + Insert(pInsertHint->GetData(), pInsertHint->GetPos()); + } + else if( dynamic_cast<const FilterClearingHint*>(&rHint) ) + { + m_xTreeView->clear(); + } + else if (const FmFilterRemovedHint* pRemoveHint = dynamic_cast<const FmFilterRemovedHint*>(&rHint)) + { + Remove(pRemoveHint->GetData()); + } + else if (const FmFilterTextChangedHint *pChangeHint = dynamic_cast<const FmFilterTextChangedHint*>(&rHint)) + { + std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pChangeHint->GetData()); + if (xEntry) + m_xTreeView->set_text(*xEntry, pChangeHint->GetData()->GetText()); + } + else if( dynamic_cast<const FmFilterCurrentChangedHint*>(&rHint) ) + { + m_xTreeView->queue_draw(); + } +} + +std::unique_ptr<weld::TreeIter> FmFilterNavigator::FindEntry(const FmFilterData* pItem) const +{ + if (!pItem) + return nullptr; + std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator(); + if (!m_xTreeView->get_iter_first(*xEntry)) + return nullptr; + do + { + FmFilterData* pEntryItem = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xEntry)); + if (pEntryItem == pItem) + return xEntry; + } + while (m_xTreeView->iter_next(*xEntry)); + + return nullptr; +} + +void FmFilterNavigator::Insert(const FmFilterData* pItem, int nPos) +{ + const FmParentData* pParent = pItem->GetParent() ? pItem->GetParent() : m_pModel.get(); + + // insert the item + std::unique_ptr<weld::TreeIter> xParentEntry = FindEntry(pParent); + + OUString sId(weld::toId(pItem)); + std::unique_ptr<weld::TreeIter> xRet(m_xTreeView->make_iterator()); + m_xTreeView->insert(xParentEntry.get(), nPos, &pItem->GetText(), &sId, + nullptr, nullptr, false, xRet.get()); + m_xTreeView->set_image(*xRet, pItem->GetImage()); + + if (!xParentEntry) + return; + m_xTreeView->expand_row(*xParentEntry); +} + +void FmFilterNavigator::EndEditing() +{ + if (m_xEditingCurrently) + { + // end editing + m_xTreeView->end_editing(); + m_xEditingCurrently.reset(); + } +} + +void FmFilterNavigator::Remove(FmFilterData const * pItem) +{ + // the entry for the data + std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pItem); + if (!xEntry) + return; + + if (m_xEditingCurrently && m_xTreeView->iter_compare(*xEntry, *m_xEditingCurrently) == 0) + EndEditing(); + + m_xTreeView->remove(*xEntry); +} + +FmFormItem* FmFilterNavigator::getSelectedFilterItems(::std::vector<FmFilterItem*>& _rItemList) +{ + // be sure that the data is only used within only one form! + FmFormItem* pFirstItem = nullptr; + + bool bHandled = true; + bool bFoundSomething = false; + + m_xTreeView->selected_foreach([this, &bHandled, &bFoundSomething, &pFirstItem, &_rItemList](weld::TreeIter& rEntry) { + FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry)); + FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pFilterEntry); + if (pFilter) + { + FmFormItem* pForm = dynamic_cast<FmFormItem*>( pFilter->GetParent()->GetParent() ); + if (!pForm) + bHandled = false; + else if (!pFirstItem) + pFirstItem = pForm; + else if (pFirstItem != pForm) + bHandled = false; + + if (bHandled) + { + _rItemList.push_back(pFilter); + bFoundSomething = true; + } + } + return !bHandled; + }); + + if ( !bHandled || !bFoundSomething ) + pFirstItem = nullptr; + return pFirstItem; +} + +void FmFilterNavigator::insertFilterItem(const ::std::vector<FmFilterItem*>& _rFilterList,FmFilterItems* _pTargetItems,bool _bCopy) +{ + for (FmFilterItem* pLookupItem : _rFilterList) + { + if ( pLookupItem->GetParent() == _pTargetItems ) + continue; + + FmFilterItem* pFilterItem = _pTargetItems->Find( pLookupItem->GetComponentIndex() ); + OUString aText = pLookupItem->GetText(); + if ( !pFilterItem ) + { + pFilterItem = new FmFilterItem( _pTargetItems, pLookupItem->GetFieldName(), aText, pLookupItem->GetComponentIndex() ); + m_pModel->Append( _pTargetItems, std::unique_ptr<FmFilterItem>(pFilterItem) ); + } + + if ( !_bCopy ) + m_pModel->Remove( pLookupItem ); + + // now set the text for the new dragged item + m_pModel->SetTextForItem( pFilterItem, aText ); + } + + m_pModel->EnsureEmptyFilterRows( *_pTargetItems->GetParent() ); +} + +IMPL_LINK(FmFilterNavigator, DragBeginHdl, bool&, rUnsetDragIcon, bool) +{ + rUnsetDragIcon = false; + + // be sure that the data is only used within an only one form! + m_aControlExchange.prepareDrag(); + + ::std::vector<FmFilterItem*> aItemList; + if (FmFormItem* pFirstItem = getSelectedFilterItems(aItemList)) + { + m_aControlExchange->setDraggedEntries(std::move(aItemList)); + m_aControlExchange->setFormItem(pFirstItem); + + OFilterItemExchange& rExchange = *m_aControlExchange; + rtl::Reference<TransferDataContainer> xHelper(&rExchange); + m_xTreeView->enable_drag_source(xHelper, DND_ACTION_COPYMOVE); + rExchange.setDragging(true); + + return false; + } + return true; +} + +IMPL_LINK(FmFilterNavigator, PopupMenuHdl, const CommandEvent&, rEvt, bool) +{ + bool bHandled = false; + switch (rEvt.GetCommand()) + { + case CommandEventId::ContextMenu: + { + // the place where it was clicked + Point aWhere; + std::unique_ptr<weld::TreeIter> xClicked(m_xTreeView->make_iterator()); + if (rEvt.IsMouseEvent()) + { + aWhere = rEvt.GetMousePosPixel(); + if (!m_xTreeView->get_dest_row_at_pos(aWhere, xClicked.get(), false)) + break; + + if (!m_xTreeView->is_selected(*xClicked)) + { + m_xTreeView->unselect_all(); + m_xTreeView->select(*xClicked); + m_xTreeView->set_cursor(*xClicked); + } + } + else + { + if (!m_xTreeView->get_cursor(xClicked.get())) + break; + aWhere = m_xTreeView->get_row_area(*xClicked).Center(); + } + + ::std::vector<FmFilterData*> aSelectList; + m_xTreeView->selected_foreach([this, &aSelectList](weld::TreeIter& rEntry) { + FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry)); + + // don't delete forms + FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry); + if (!pForm) + aSelectList.push_back(pFilterEntry); + + return false; + }); + + if (aSelectList.size() == 1) + { + // don't delete the only empty row of a form + FmFilterItems* pFilterItems = dynamic_cast<FmFilterItems*>( aSelectList[0] ); + if (pFilterItems && pFilterItems->GetChildren().empty() + && pFilterItems->GetParent()->GetChildren().size() == 1) + aSelectList.clear(); + } + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "svx/ui/filtermenu.ui")); + std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu("menu")); + + // every condition could be deleted except the first one if it's the only one + bool bNoDelete = false; + if (aSelectList.empty()) + { + bNoDelete = true; + xContextMenu->remove("delete"); + } + + FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xClicked)); + auto pFilterItem = dynamic_cast<FmFilterItem*>(pFilterEntry); + bool bEdit = pFilterItem && + m_xTreeView->is_selected(*xClicked) && m_xTreeView->count_selected_rows() == 1; + + if (bNoDelete && !bEdit) + { + // nothing is in the menu, don't bother + return true; + } + + if (!bEdit) + { + xContextMenu->remove("edit"); + xContextMenu->remove("isnull"); + xContextMenu->remove("isnotnull"); + } + + OString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(aWhere, ::Size(1, 1))); + if (sIdent == "edit") + { + m_xTreeView->start_editing(*xClicked); + } + else if (sIdent == "isnull") + { + OUString aErrorMsg; + OUString aText = "IS NULL"; + assert(pFilterItem && "if item is null this menu entry was removed and unavailable"); + m_pModel->ValidateText(pFilterItem, aText, aErrorMsg); + m_pModel->SetTextForItem(pFilterItem, aText); + } + else if (sIdent == "isnotnull") + { + OUString aErrorMsg; + OUString aText = "IS NOT NULL"; + + assert(pFilterItem && "if item is null this menu entry was removed and unavailable"); + m_pModel->ValidateText(pFilterItem, aText, aErrorMsg); + m_pModel->SetTextForItem(pFilterItem, aText); + } + else if (sIdent == "delete") + { + DeleteSelection(); + } + bHandled = true; + } + break; + default: break; + } + + return bHandled; +} + +bool FmFilterNavigator::getNextEntry(weld::TreeIter& rEntry) +{ + bool bEntry = m_xTreeView->iter_next(rEntry); + // we need the next filter entry + if (bEntry) + { + while (!m_xTreeView->iter_has_child(rEntry)) + { + std::unique_ptr<weld::TreeIter> xNext = m_xTreeView->make_iterator(&rEntry); + if (!m_xTreeView->iter_next(*xNext)) + break; + m_xTreeView->copy_iterator(*xNext, rEntry); + } + } + return bEntry; +} + +bool FmFilterNavigator::getPrevEntry(weld::TreeIter& rEntry) +{ + bool bEntry = m_xTreeView->iter_previous(rEntry); + // check if the previous entry is a filter, if so get the next prev + if (bEntry && m_xTreeView->iter_has_child(rEntry)) + { + bEntry = m_xTreeView->iter_previous(rEntry); + // if the entry is still no leaf return + if (bEntry && m_xTreeView->iter_has_child(rEntry)) + bEntry = false; + } + return bEntry; +} +IMPL_LINK(FmFilterNavigator, KeyInputHdl, const ::KeyEvent&, rKEvt, bool) +{ + const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode(); + + switch ( rKeyCode.GetCode() ) + { + case KEY_UP: + case KEY_DOWN: + { + if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() ) + break; + + ::std::vector<FmFilterItem*> aItemList; + if ( !getSelectedFilterItems( aItemList ) ) + break; + + + std::vector<std::unique_ptr<weld::TreeIter>> aSelected; + m_xTreeView->selected_foreach([this, &aSelected](weld::TreeIter& rEntry){ + aSelected.emplace_back(m_xTreeView->make_iterator(&rEntry)); + return false; + }); + + std::unique_ptr<weld::TreeIter> xTarget; + ::std::function<bool(FmFilterNavigator*, weld::TreeIter&)> getter; + + if (rKeyCode.GetCode() == KEY_UP) + { + xTarget = m_xTreeView->make_iterator(aSelected.front().get()); + getter = ::std::mem_fn(&FmFilterNavigator::getPrevEntry); + } + else + { + xTarget = m_xTreeView->make_iterator(aSelected.back().get()); + getter = ::std::mem_fn(&FmFilterNavigator::getNextEntry); + } + + bool bTarget = getter(this, *xTarget); + if (!bTarget) + break; + + FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xTarget); + if (!pTargetItems) + break; + + ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end(); + bool bNextTargetItem = true; + while ( bNextTargetItem ) + { + ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin(); + for (; i != aEnd; ++i) + { + if ( (*i)->GetParent() == pTargetItems ) + { + bTarget = getter(this, *xTarget); + if (!bTarget) + return true; + pTargetItems = getTargetItems(*m_xTreeView, *xTarget); + break; + } + else + { + FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() ); + // we found the text component so jump above + if ( pFilterItem ) + { + bTarget = getter(this, *xTarget); + if (!bTarget) + return true; + + pTargetItems = getTargetItems(*m_xTreeView, *xTarget); + break; + } + } + } + bNextTargetItem = i != aEnd && pTargetItems; + } + + if ( pTargetItems ) + { + insertFilterItem( aItemList, pTargetItems, false ); + return true; + } + } + break; + + case KEY_DELETE: + { + if ( rKeyCode.GetModifier() ) + break; + + std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator(); + if (m_xTreeView->get_iter_first(*xEntry) && !m_xTreeView->is_selected(*xEntry)) + DeleteSelection(); + + return true; + } + } + + return false; +} + +void FmFilterNavigator::DeleteSelection() +{ + // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward + // the deletion of its child, I have to shrink the selection list + std::vector<FmFilterData*> aEntryList; + + m_xTreeView->selected_foreach([this, &aEntryList](weld::TreeIter& rEntry) { + FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry)); + + if (dynamic_cast<FmFilterItem*>(pFilterEntry)) + { + std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rEntry)); + if (m_xTreeView->iter_parent(*xParent) && m_xTreeView->is_selected(*xParent)) + return false; + } + + FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry); + if (!pForm) + aEntryList.emplace_back(pFilterEntry); + + return false; + }); + + // Remove the selection + m_xTreeView->unselect_all(); + + for (auto i = aEntryList.rbegin(); i != aEntryList.rend(); ++i) + m_pModel->Remove(*i); +} + +FmFilterNavigatorWin::FmFilterNavigatorWin(SfxBindings* _pBindings, SfxChildWindow* _pMgr, + vcl::Window* _pParent) + : SfxDockingWindow(_pBindings, _pMgr, _pParent, "FilterNavigator", "svx/ui/filternavigator.ui") + , SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings ) + , m_xNavigatorTree(new FmFilterNavigator(this, m_xBuilder->weld_tree_view("treeview"))) +{ + SetHelpId( HID_FILTER_NAVIGATOR_WIN ); + + SetText( SvxResId(RID_STR_FILTER_NAVIGATOR) ); + SfxDockingWindow::SetFloatingSize( Size(200,200) ); +} + +FmFilterNavigatorWin::~FmFilterNavigatorWin() +{ + disposeOnce(); +} + +void FmFilterNavigatorWin::dispose() +{ + m_xNavigatorTree.reset(); + ::SfxControllerItem::dispose(); + SfxDockingWindow::dispose(); +} + +void FmFilterNavigatorWin::UpdateContent(FmFormShell const * pFormShell) +{ + if (!m_xNavigatorTree) + return; + + if (!pFormShell) + m_xNavigatorTree->UpdateContent( nullptr, nullptr ); + else + { + Reference<XFormController> const xController(pFormShell->GetImpl()->getActiveInternalController_Lock()); + Reference< XIndexAccess > xContainer; + if (xController.is()) + { + Reference< XChild > xChild = xController; + for (Reference< XInterface > xParent(xChild->getParent()); + xParent.is(); + xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ()) + { + xContainer.set(xParent, UNO_QUERY); + xChild.set(xParent, UNO_QUERY); + } + } + m_xNavigatorTree->UpdateContent(xContainer, xController); + } +} + +void FmFilterNavigatorWin::StateChangedAtToolBoxControl( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState ) +{ + if( !pState || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID ) + return; + + if( eState >= SfxItemState::DEFAULT ) + { + FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() ); + UpdateContent( pShell ); + } + else + UpdateContent( nullptr ); +} + +bool FmFilterNavigatorWin::Close() +{ + if (m_xNavigatorTree) + m_xNavigatorTree->EndEditing(); + + UpdateContent( nullptr ); + return SfxDockingWindow::Close(); +} + +void FmFilterNavigatorWin::FillInfo( SfxChildWinInfo& rInfo ) const +{ + SfxDockingWindow::FillInfo( rInfo ); + rInfo.bVisible = false; +} + +Size FmFilterNavigatorWin::CalcDockingSize( SfxChildAlignment eAlign ) +{ + if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) ) + return Size(); + + return SfxDockingWindow::CalcDockingSize( eAlign ); +} + +SfxChildAlignment FmFilterNavigatorWin::CheckAlignment( SfxChildAlignment eActAlign, SfxChildAlignment eAlign ) +{ + switch (eAlign) + { + case SfxChildAlignment::LEFT: + case SfxChildAlignment::RIGHT: + case SfxChildAlignment::NOALIGNMENT: + return eAlign; + default: + break; + } + + return eActAlign; +} + +void FmFilterNavigatorWin::GetFocus() +{ + // oj #97405# + if (m_xNavigatorTree) + m_xNavigatorTree->GrabFocus(); + else + SfxDockingWindow::GetFocus(); +} + +SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR ) + + +FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId, + SfxBindings *_pBindings, SfxChildWinInfo* _pInfo ) + :SfxChildWindow( _pParent, _nId ) +{ + SetWindow( VclPtr<FmFilterNavigatorWin>::Create( _pBindings, this, _pParent ) ); + static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo ); +} + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmPropBrw.cxx b/svx/source/form/fmPropBrw.cxx new file mode 100644 index 000000000..1b24f9703 --- /dev/null +++ b/svx/source/form/fmPropBrw.cxx @@ -0,0 +1,581 @@ +/* -*- 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/macros.h> + +#include <fmprop.hxx> +#include <fmPropBrw.hxx> +#include <svx/strings.hrc> +#include <fmservs.hxx> +#include <fmshimp.hxx> +#include <fmpgeimp.hxx> + +#include <svx/dialmgr.hxx> +#include <svx/fmpage.hxx> +#include <svx/fmshell.hxx> +#include <svx/fmview.hxx> +#include <svx/sdrpagewindow.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svxids.hrc> + +#include <com/sun/star/awt/XControlContainer.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/form/XForm.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/form/inspection/DefaultFormComponentInspectorModel.hpp> +#include <com/sun/star/frame/Frame.hpp> +#include <com/sun/star/inspection/ObjectInspector.hpp> +#include <com/sun/star/inspection/XObjectInspectorUI.hpp> +#include <com/sun/star/inspection/DefaultHelpProvider.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/util/VetoException.hpp> + +#include <comphelper/processfactory.hxx> +#include <comphelper/property.hxx> +#include <comphelper/sequence.hxx> +#include <comphelper/types.hxx> +#include <cppuhelper/component_context.hxx> +#include <o3tl/deleter.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/childwin.hxx> +#include <sfx2/objitem.hxx> +#include <sfx2/objsh.hxx> +#include <tools/diagnose_ex.h> +#include <unotools/confignode.hxx> +#include <vcl/stdtext.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <vcl/weldutils.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::form::inspection; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::inspection; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::util; +using namespace ::svxform; +using ::com::sun::star::awt::XWindow; + +//= FmPropBrwMgr +SFX_IMPL_MODELESSDIALOGCONTOLLER(FmPropBrwMgr, SID_FM_SHOW_PROPERTIES) + +FmPropBrwMgr::FmPropBrwMgr( vcl::Window* _pParent, sal_uInt16 _nId, + SfxBindings* _pBindings, const SfxChildWinInfo* _pInfo) + :SfxChildWindow(_pParent, _nId) +{ + std::shared_ptr<FmPropBrw> xControl(new FmPropBrw(::comphelper::getProcessComponentContext(), _pBindings, + this, _pParent->GetFrameWeld(), _pInfo), o3tl::default_delete<FmPropBrw>()); + SetController(std::move(xControl)); + static_cast<FmPropBrw*>(GetController().get())->Initialize( _pInfo ); +} + +static OUString GetUIHeadlineName(sal_Int16 nClassId, const Any& aUnoObj) +{ + TranslateId pClassNameResourceId; + + switch ( nClassId ) + { + case FormComponentType::TEXTFIELD: + { + Reference< XInterface > xIFace; + aUnoObj >>= xIFace; + pClassNameResourceId = RID_STR_PROPTITLE_EDIT; + if (xIFace.is()) + { // we have a chance to check if it's a formatted field model + Reference< XServiceInfo > xInfo(xIFace, UNO_QUERY); + if (xInfo.is() && (xInfo->supportsService(FM_SUN_COMPONENT_FORMATTEDFIELD))) + pClassNameResourceId = RID_STR_PROPTITLE_FORMATTED; + else if (!xInfo.is()) + { + // couldn't distinguish between formatted and edit with the service name, so try with the properties + Reference< XPropertySet > xProps(xIFace, UNO_QUERY); + if (xProps.is()) + { + Reference< XPropertySetInfo > xPropsInfo = xProps->getPropertySetInfo(); + if (xPropsInfo.is() && xPropsInfo->hasPropertyByName(FM_PROP_FORMATSSUPPLIER)) + pClassNameResourceId = RID_STR_PROPTITLE_FORMATTED; + } + } + } + } + break; + + case FormComponentType::COMMANDBUTTON: + pClassNameResourceId = RID_STR_PROPTITLE_PUSHBUTTON; break; + case FormComponentType::RADIOBUTTON: + pClassNameResourceId = RID_STR_PROPTITLE_RADIOBUTTON; break; + case FormComponentType::CHECKBOX: + pClassNameResourceId = RID_STR_PROPTITLE_CHECKBOX; break; + case FormComponentType::LISTBOX: + pClassNameResourceId = RID_STR_PROPTITLE_LISTBOX; break; + case FormComponentType::COMBOBOX: + pClassNameResourceId = RID_STR_PROPTITLE_COMBOBOX; break; + case FormComponentType::GROUPBOX: + pClassNameResourceId = RID_STR_PROPTITLE_GROUPBOX; break; + case FormComponentType::IMAGEBUTTON: + pClassNameResourceId = RID_STR_PROPTITLE_IMAGEBUTTON; break; + case FormComponentType::FIXEDTEXT: + pClassNameResourceId = RID_STR_PROPTITLE_FIXEDTEXT; break; + case FormComponentType::GRIDCONTROL: + pClassNameResourceId = RID_STR_PROPTITLE_DBGRID; break; + case FormComponentType::FILECONTROL: + pClassNameResourceId = RID_STR_PROPTITLE_FILECONTROL; break; + case FormComponentType::DATEFIELD: + pClassNameResourceId = RID_STR_PROPTITLE_DATEFIELD; break; + case FormComponentType::TIMEFIELD: + pClassNameResourceId = RID_STR_PROPTITLE_TIMEFIELD; break; + case FormComponentType::NUMERICFIELD: + pClassNameResourceId = RID_STR_PROPTITLE_NUMERICFIELD; break; + case FormComponentType::CURRENCYFIELD: + pClassNameResourceId = RID_STR_PROPTITLE_CURRENCYFIELD; break; + case FormComponentType::PATTERNFIELD: + pClassNameResourceId = RID_STR_PROPTITLE_PATTERNFIELD; break; + case FormComponentType::IMAGECONTROL: + pClassNameResourceId = RID_STR_PROPTITLE_IMAGECONTROL; break; + case FormComponentType::HIDDENCONTROL: + pClassNameResourceId = RID_STR_PROPTITLE_HIDDEN; break; + case FormComponentType::SCROLLBAR: + pClassNameResourceId = RID_STR_PROPTITLE_SCROLLBAR; break; + case FormComponentType::SPINBUTTON: + pClassNameResourceId = RID_STR_PROPTITLE_SPINBUTTON; break; + case FormComponentType::NAVIGATIONBAR: + pClassNameResourceId = RID_STR_PROPTITLE_NAVBAR; break; + case FormComponentType::CONTROL: + default: + pClassNameResourceId = RID_STR_CONTROL; break; + } + + return SvxResId(pClassNameResourceId); +} + +FmPropBrw::FmPropBrw(const Reference< XComponentContext >& _xORB, SfxBindings* _pBindings, + SfxChildWindow* _pMgr, weld::Window* _pParent, const SfxChildWinInfo* _pInfo) + : SfxModelessDialogController(_pBindings, _pMgr, _pParent, "svx/ui/formpropertydialog.ui", "FormPropertyDialog") + , SfxControllerItem(SID_FM_PROPERTY_CONTROL, *_pBindings) + , m_bInitialStateChange(true) + , m_pParent(_pParent) + , m_nAsyncGetFocusId(nullptr) + , m_xContainer(m_xBuilder->weld_container("container")) + , m_xORB(_xORB) +{ + m_xContainer->set_size_request(m_xContainer->get_approximate_digit_width() * 72, m_xContainer->get_text_height() * 20); + + try + { + // create a frame wrapper for myself + m_xMeAsFrame = Frame::create(m_xORB); + + // transport the container area of this dialog to be the container window of the frame + css::uno::Reference<css::awt::XWindow> xFrameContainerWindow(new weld::TransportAsXWindow(m_xContainer.get())); + m_xMeAsFrame->initialize(xFrameContainerWindow); + m_xMeAsFrame->setName("form property browser"); + } + catch (const Exception&) + { + OSL_FAIL("FmPropBrw::FmPropBrw: could not create/initialize my frame!"); + m_xMeAsFrame.clear(); + } + + if ( _pInfo ) + m_sLastActivePage = _pInfo->aExtraString; +} + +FmPropBrw::~FmPropBrw() +{ + if (m_nAsyncGetFocusId) + { + Application::RemoveUserEvent(m_nAsyncGetFocusId); + m_nAsyncGetFocusId = nullptr; + } + + if (m_xBrowserController.is()) + implDetachController(); + try + { + // remove our own properties from the component context. We cannot ensure that the component context + // is freed (there might be refcount problems :-\), so at least ensure the context itself + // does hold the objects anymore + Reference<XNameContainer> xName(m_xInspectorContext,uno::UNO_QUERY); + if ( xName.is() ) + { + const OUString pProps[] = { OUString( "ContextDocument" ) + , OUString( "DialogParentWindow" ) + , OUString( "ControlContext" ) + , OUString( "ControlShapeAccess" ) }; + for (const auto & i : pProps) + xName->removeByName( i ); + } + } + catch (const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + ::SfxControllerItem::dispose(); +} + +OUString FmPropBrw::getCurrentPage() const +{ + OUString sCurrentPage; + try + { + if ( m_xBrowserController.is() ) + { + OSL_VERIFY( m_xBrowserController->getViewData() >>= sCurrentPage ); + } + + if ( sCurrentPage.isEmpty() ) + sCurrentPage = m_sLastActivePage; + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.form", "caught an exception while retrieving the current page!"); + } + return sCurrentPage; +} + +void FmPropBrw::implDetachController() +{ + m_sLastActivePage = getCurrentPage(); + + implSetNewSelection( InterfaceBag() ); + + if ( m_xMeAsFrame.is() ) + { + try + { + m_xMeAsFrame->setComponent(nullptr, nullptr); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.form", "caught an exception while resetting the component!"); + } + } + + // we attached a frame to the controller manually, so we need to manually tell it that it's detached, too + if ( m_xBrowserController.is() ) + { + m_xBrowserController->attachFrame( nullptr ); + } + + m_xBrowserController.clear(); + m_xInspectorModel.clear(); + m_xMeAsFrame.clear(); +} + +void FmPropBrw::Close() +{ + // suspend the controller (it is allowed to veto) + if ( m_xMeAsFrame.is() ) + { + try + { + Reference< XController > xController( m_xMeAsFrame->getController() ); + if ( xController.is() && !xController->suspend( true ) ) + return; + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.form", "caught an exception while asking the controller!"); + } + } + + implDetachController(); + + // remember our bindings: while we're closed, we're deleted, too, so accessing the bindings after this + // would be deadly + // 10/19/00 - 79321 - FS + SfxBindings& rBindings = SfxControllerItem::GetBindings(); + + SfxModelessDialogController::Close(); + + rBindings.Invalidate(SID_FM_CTL_PROPERTIES); + rBindings.Invalidate(SID_FM_PROPERTIES); +} + +bool FmPropBrw::implIsReadOnlyModel() const +{ + try + { + if ( m_xInspectorModel.is() ) + return m_xInspectorModel->getIsReadOnly(); + return false; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return true; +} + + +void FmPropBrw::implSetNewSelection( const InterfaceBag& _rSelection ) +{ + if ( !m_xBrowserController.is() ) + return; + + try + { + Reference< XObjectInspector > xInspector( m_xBrowserController, UNO_QUERY_THROW ); + + // tell it the objects to inspect + xInspector->inspect( comphelper::containerToSequence(_rSelection) ); + } + catch( const VetoException& ) + { + return; + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.form", ""); + return; + } + + // set the new title according to the selected object + OUString sTitle; + + if ( _rSelection.empty() ) + { + sTitle = SvxResId(RID_STR_NO_PROPERTIES); + } + else if ( _rSelection.size() > 1 ) + { + // no form component and (no form or no name) -> Multiselection + sTitle = SvxResId(RID_STR_PROPERTIES_CONTROL) + + SvxResId(RID_STR_PROPTITLE_MULTISELECT); + } + else + { + Reference< XPropertySet > xSingleSelection( *_rSelection.begin(), UNO_QUERY); + if ( ::comphelper::hasProperty( FM_PROP_CLASSID, xSingleSelection ) ) + { + sal_Int16 nClassID = FormComponentType::CONTROL; + xSingleSelection->getPropertyValue( FM_PROP_CLASSID ) >>= nClassID; + + sTitle = SvxResId(RID_STR_PROPERTIES_CONTROL) + + GetUIHeadlineName(nClassID, Any(xSingleSelection)); + } + else if ( Reference< XForm >( xSingleSelection, UNO_QUERY ).is() ) + sTitle = SvxResId(RID_STR_PROPERTIES_FORM); + } + + if ( implIsReadOnlyModel() ) + sTitle += SvxResId(RID_STR_READONLY_VIEW); + + m_xDialog->set_title(sTitle); +} + +void FmPropBrw::FillInfo( SfxChildWinInfo& rInfo ) const +{ + rInfo.bVisible = false; + rInfo.aExtraString = getCurrentPage(); +} + +IMPL_LINK_NOARG( FmPropBrw, OnAsyncGetFocus, void*, void ) +{ + m_nAsyncGetFocusId = nullptr; +} + +namespace +{ + bool lcl_shouldEnableHelpSection( const Reference< XComponentContext >& _rxContext ) + { + ::utl::OConfigurationTreeRoot aConfiguration( + ::utl::OConfigurationTreeRoot::createWithComponentContext( + _rxContext, + "/org.openoffice.Office.Common/Forms/PropertyBrowser/" ) ); + + bool bEnabled = false; + OSL_VERIFY( aConfiguration.getNodeValue( "DirectHelp" ) >>= bEnabled ); + return bEnabled; + } +} + +void FmPropBrw::impl_createPropertyBrowser_throw( FmFormShell* _pFormShell ) +{ + // the document in which we live + Reference< XInterface > xDocument; + if ( _pFormShell && _pFormShell->GetObjectShell() ) + xDocument = _pFormShell->GetObjectShell()->GetModel(); + + // the context of the controls in our document + Reference< awt::XControlContainer > xControlContext; + if ( _pFormShell && _pFormShell->GetFormView() ) + { + SdrPageView* pPageView = _pFormShell->GetFormView()->GetSdrPageView(); + + if(pPageView) + { + SdrPageWindow* pPageWindow = pPageView->GetPageWindow(0); + + if(pPageWindow) + { + xControlContext = pPageWindow->GetControlContainer(); + } + } + } + + // the default parent window for message boxes + Reference< XWindow > xParentWindow(m_xDialog->GetXWindow()); + + // the mapping from control models to control shapes + Reference< XMap > xControlMap; + FmFormPage* pFormPage = _pFormShell ? _pFormShell->GetCurPage() : nullptr; + if ( pFormPage ) + xControlMap = pFormPage->GetImpl().getControlToShapeMap(); + + // our own component context + + // a ComponentContext for the + ::cppu::ContextEntry_Init aHandlerContextInfo[] = + { + ::cppu::ContextEntry_Init( "ContextDocument", Any( xDocument ) ), + ::cppu::ContextEntry_Init( "DialogParentWindow", Any( xParentWindow ) ), + ::cppu::ContextEntry_Init( "ControlContext", Any( xControlContext ) ), + ::cppu::ContextEntry_Init( "ControlShapeAccess", Any( xControlMap ) ) + }; + m_xInspectorContext.set( + ::cppu::createComponentContext( aHandlerContextInfo, SAL_N_ELEMENTS( aHandlerContextInfo ), + m_xORB ) ); + + bool bEnableHelpSection = lcl_shouldEnableHelpSection( m_xORB ); + + // an object inspector model + m_xInspectorModel = + bEnableHelpSection + ? DefaultFormComponentInspectorModel::createWithHelpSection( m_xInspectorContext, 3, 5 ) + : DefaultFormComponentInspectorModel::createDefault( m_xInspectorContext ); + + // an object inspector + m_xBrowserController = + ObjectInspector::createWithModel( + m_xInspectorContext, m_xInspectorModel + ); + + if ( !m_xBrowserController.is() ) + { + ShowServiceNotAvailableError(m_pParent, u"com.sun.star.inspection.ObjectInspector", true); + } + else + { + m_xBrowserController->attachFrame( Reference<XFrame>(m_xMeAsFrame,UNO_QUERY_THROW) ); + } + + if ( bEnableHelpSection ) + { + Reference< XObjectInspector > xInspector( m_xBrowserController, UNO_QUERY_THROW ); + Reference< XObjectInspectorUI > xInspectorUI( xInspector->getInspectorUI() ); + DefaultHelpProvider::create( m_xInspectorContext, xInspectorUI ); + } +} + + +void FmPropBrw::impl_ensurePropertyBrowser_nothrow( FmFormShell* _pFormShell ) +{ + // the document in which we live + Reference< XInterface > xDocument; + SfxObjectShell* pObjectShell = _pFormShell ? _pFormShell->GetObjectShell() : nullptr; + if ( pObjectShell ) + xDocument = pObjectShell->GetModel(); + if ( ( xDocument == m_xLastKnownDocument ) && m_xBrowserController.is() ) + // nothing to do + return; + + try + { + // clean up any previous instances of the object inspector + if ( m_xMeAsFrame.is() ) + m_xMeAsFrame->setComponent( nullptr, nullptr ); + else + ::comphelper::disposeComponent( m_xBrowserController ); + m_xBrowserController.clear(); + m_xInspectorModel.clear(); + + // and create a new one + impl_createPropertyBrowser_throw( _pFormShell ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + m_xLastKnownDocument = xDocument; +} + + +void FmPropBrw::StateChangedAtToolBoxControl(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState) +{ + if (!pState || SID_FM_PROPERTY_CONTROL != nSID) + return; + + try + { + if (eState >= SfxItemState::DEFAULT) + { + FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() ); + InterfaceBag aSelection; + if ( pShell ) + pShell->GetImpl()->getCurrentSelection_Lock(aSelection); + + impl_ensurePropertyBrowser_nothrow( pShell ); + + // set the new object to inspect + implSetNewSelection( aSelection ); + + // if this is the first time we're here, some additional things need to be done ... + if ( m_bInitialStateChange ) + { + // if we're just newly created, we want to have the focus + m_nAsyncGetFocusId = Application::PostUserEvent(LINK(this, FmPropBrw, OnAsyncGetFocus)); + + // and additionally, we want to show the page which was active during + // our previous incarnation + if ( !m_sLastActivePage.isEmpty() ) + { + try + { + if ( m_xBrowserController.is() ) + m_xBrowserController->restoreViewData( Any( m_sLastActivePage ) ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.form", + "caught an exception while setting the initial page!"); + } + } + + m_bInitialStateChange = false; + } + + } + else + { + implSetNewSelection( InterfaceBag() ); + } + } + catch (Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", ""); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmcontrolbordermanager.cxx b/svx/source/form/fmcontrolbordermanager.cxx new file mode 100644 index 000000000..b46733995 --- /dev/null +++ b/svx/source/form/fmcontrolbordermanager.cxx @@ -0,0 +1,425 @@ +/* -*- 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 <fmcontrolbordermanager.hxx> + +#include <fmprop.hxx> + +#include <com/sun/star/form/validation/XValidatableFormComponent.hpp> +#include <com/sun/star/awt/XTextComponent.hpp> +#include <com/sun/star/awt/XListBox.hpp> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <osl/diagnose.h> + + +namespace svxform +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::awt; + using namespace ::com::sun::star::form::validation; + + + //= helper + + + static void setUnderline( const Reference< XVclWindowPeer >& _rxPeer, const UnderlineDescriptor& _rUnderline ) + { + OSL_ENSURE( _rxPeer.is(), "setUnderline: invalid peer!" ); + + // the underline type is an aspect of the font + FontDescriptor aFont; + OSL_VERIFY( _rxPeer->getProperty( FM_PROP_FONT ) >>= aFont ); + aFont.Underline = _rUnderline.nUnderlineType; + _rxPeer->setProperty( FM_PROP_FONT, Any( aFont ) ); + // the underline color is a separate property + _rxPeer->setProperty( FM_PROP_TEXTLINECOLOR, Any( _rUnderline.nUnderlineColor ) ); + } + + + static void getUnderline( const Reference< XVclWindowPeer >& _rxPeer, UnderlineDescriptor& _rUnderline ) + { + OSL_ENSURE( _rxPeer.is(), "getUnderline: invalid peer!" ); + + FontDescriptor aFont; + OSL_VERIFY( _rxPeer->getProperty( FM_PROP_FONT ) >>= aFont ); + _rUnderline.nUnderlineType = aFont.Underline; + + OSL_VERIFY( _rxPeer->getProperty( FM_PROP_TEXTLINECOLOR ) >>= _rUnderline.nUnderlineColor ); + } + + + static void getBorder( const Reference< XVclWindowPeer >& _rxPeer, BorderDescriptor& _rBorder ) + { + OSL_ENSURE( _rxPeer.is(), "getBorder: invalid peer!" ); + + OSL_VERIFY( _rxPeer->getProperty( FM_PROP_BORDER ) >>= _rBorder.nBorderType ); + OSL_VERIFY( _rxPeer->getProperty( FM_PROP_BORDERCOLOR ) >>= _rBorder.nBorderColor ); + } + + + static void setBorder( const Reference< XVclWindowPeer >& _rxPeer, const BorderDescriptor& _rBorder ) + { + OSL_ENSURE( _rxPeer.is(), "setBorder: invalid peer!" ); + + _rxPeer->setProperty( FM_PROP_BORDER, Any( _rBorder.nBorderType ) ); + _rxPeer->setProperty( FM_PROP_BORDERCOLOR, Any( _rBorder.nBorderColor ) ); + } + + ControlBorderManager::ControlBorderManager() + :m_nFocusColor ( 0x000000FF ) + ,m_nMouseHoveColor( 0x007098BE ) + ,m_nInvalidColor ( 0x00FF0000 ) + ,m_bDynamicBorderColors( false ) + { + } + + + ControlBorderManager::~ControlBorderManager() + { + } + + + bool ControlBorderManager::canColorBorder( const Reference< XVclWindowPeer >& _rxPeer ) + { + OSL_PRECOND( _rxPeer.is(), "ControlBorderManager::canColorBorder: invalid peer!" ); + + PeerBag::const_iterator aPos = m_aColorableControls.find( _rxPeer ); + if ( aPos != m_aColorableControls.end() ) + return true; + + aPos = m_aNonColorableControls.find( _rxPeer ); + if ( aPos != m_aNonColorableControls.end() ) + return false; + + // this peer is not yet known + + // no border coloring for controls which are not for text input + // #i37434# / 2004-11-19 / frank.schoenheit@sun.com + Reference< XTextComponent > xText( _rxPeer, UNO_QUERY ); + Reference< XListBox > xListBox( _rxPeer, UNO_QUERY ); + if ( xText.is() || xListBox.is() ) + { + sal_Int16 nBorderStyle = VisualEffect::NONE; + OSL_VERIFY( _rxPeer->getProperty( FM_PROP_BORDER ) >>= nBorderStyle ); + if ( nBorderStyle == VisualEffect::FLAT ) + // if you change this to also accept LOOK3D, then this would also work, but look ugly + { + m_aColorableControls.insert( _rxPeer ); + return true; + } + } + + m_aNonColorableControls.insert( _rxPeer ); + return false; + } + + + ControlStatus ControlBorderManager::getControlStatus( const Reference< XControl >& _rxControl ) + { + ControlStatus nStatus = ControlStatus::NONE; + + if ( _rxControl.get() == m_aFocusControl.xControl.get() ) + nStatus |= ControlStatus::Focused; + + if ( _rxControl.get() == m_aMouseHoverControl.xControl.get() ) + nStatus |= ControlStatus::MouseHover; + + if ( m_aInvalidControls.find( ControlData( _rxControl ) ) != m_aInvalidControls.end() ) + nStatus |= ControlStatus::Invalid; + + return nStatus; + } + + + Color ControlBorderManager::getControlColorByStatus( ControlStatus _nStatus ) const + { + // "invalid" is ranked highest + if ( _nStatus & ControlStatus::Invalid ) + return m_nInvalidColor; + + // then, "focused" is more important than ... + if ( _nStatus & ControlStatus::Focused ) + return m_nFocusColor; + + // ... "mouse over" + if ( _nStatus & ControlStatus::MouseHover ) + return m_nMouseHoveColor; + + OSL_FAIL( "ControlBorderManager::getControlColorByStatus: invalid status!" ); + return Color(0); + } + + + void ControlBorderManager::updateBorderStyle( const Reference< XControl >& _rxControl, const Reference< XVclWindowPeer >& _rxPeer, const BorderDescriptor& _rFallback ) + { + OSL_PRECOND( _rxControl.is() && _rxPeer.is(), "ControlBorderManager::updateBorderStyle: invalid parameters!" ); + + ControlStatus nStatus = getControlStatus( _rxControl ); + BorderDescriptor aBorder; + aBorder.nBorderType = ( nStatus == ControlStatus::NONE ) + ? _rFallback.nBorderType + : VisualEffect::FLAT; + aBorder.nBorderColor = ( nStatus == ControlStatus::NONE ) + ? _rFallback.nBorderColor + : getControlColorByStatus( nStatus ); + setBorder( _rxPeer, aBorder ); + } + + + void ControlBorderManager::determineOriginalBorderStyle( const Reference< XControl >& _rxControl, BorderDescriptor& _rData ) const + { + _rData = ControlData(); + if ( m_aFocusControl.xControl.get() == _rxControl.get() ) + { + _rData = m_aFocusControl; + } + else if ( m_aMouseHoverControl.xControl.get() == _rxControl.get() ) + { + _rData = m_aMouseHoverControl; + } + else + { + ControlBag::const_iterator aPos = m_aInvalidControls.find( _rxControl ); + if ( aPos != m_aInvalidControls.end() ) + { + _rData = *aPos; + } + else + { + Reference< XVclWindowPeer > xPeer( _rxControl->getPeer(), UNO_QUERY ); + getBorder( xPeer, _rData ); + } + } + } + + + void ControlBorderManager::controlStatusGained( const Reference< XInterface >& _rxControl, ControlData& _rControlData ) + { + if ( _rxControl == _rControlData.xControl ) + // nothing to do - though suspicious + return; + + Reference< XControl > xAsControl( _rxControl, UNO_QUERY ); + DBG_ASSERT( xAsControl.is(), "ControlBorderManager::controlStatusGained: invalid control!" ); + if ( !xAsControl.is() ) + return; + + try + { + Reference< XVclWindowPeer > xPeer( xAsControl->getPeer(), UNO_QUERY ); + if ( xPeer.is() && canColorBorder( xPeer ) ) + { + // remember the control and its current border color + _rControlData.xControl.clear(); // so determineOriginalBorderStyle doesn't get confused + + determineOriginalBorderStyle( xAsControl, _rControlData ); + + _rControlData.xControl = xAsControl; + + updateBorderStyle( xAsControl, xPeer, _rControlData ); + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "ControlBorderManager::controlStatusGained" ); + } + } + + + void ControlBorderManager::controlStatusLost( const Reference< XInterface >& _rxControl, ControlData& _rControlData ) + { + if ( _rxControl != _rControlData.xControl ) + // nothing to do + return; + + OSL_PRECOND( _rControlData.xControl.is(), "ControlBorderManager::controlStatusLost: invalid control data - this will crash!" ); + try + { + Reference< XVclWindowPeer > xPeer( _rControlData.xControl->getPeer(), UNO_QUERY ); + if ( xPeer.is() && canColorBorder( xPeer ) ) + { + ControlData aPreviousStatus( _rControlData ); + _rControlData = ControlData(); + updateBorderStyle( aPreviousStatus.xControl, xPeer, aPreviousStatus ); + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "ControlBorderManager::controlStatusLost" ); + } + } + + + void ControlBorderManager::enableDynamicBorderColor( ) + { + m_bDynamicBorderColors = true; + } + + + void ControlBorderManager::disableDynamicBorderColor( ) + { + m_bDynamicBorderColors = false; + restoreAll(); + } + + + void ControlBorderManager::setStatusColor( ControlStatus _nStatus, Color _nColor ) + { + switch ( _nStatus ) + { + case ControlStatus::Focused: + m_nFocusColor = _nColor; + break; + case ControlStatus::MouseHover: + m_nMouseHoveColor = _nColor; + break; + case ControlStatus::Invalid: + m_nInvalidColor = _nColor; + break; + default: + OSL_FAIL( "ControlBorderManager::setStatusColor: invalid status!" ); + } + } + + + void ControlBorderManager::restoreAll() + { + if ( m_aFocusControl.xControl.is() ) + controlStatusLost( m_aFocusControl.xControl, m_aFocusControl ); + if ( m_aMouseHoverControl.xControl.is() ) + controlStatusLost( m_aMouseHoverControl.xControl, m_aMouseHoverControl ); + + ControlBag aInvalidControls; + m_aInvalidControls.swap( aInvalidControls ); + + for (const auto& rControl : aInvalidControls) + { + Reference< XVclWindowPeer > xPeer( rControl.xControl->getPeer(), UNO_QUERY ); + if ( xPeer.is() ) + { + updateBorderStyle( rControl.xControl, xPeer, rControl ); + xPeer->setProperty( FM_PROP_HELPTEXT, Any( rControl.sOriginalHelpText ) ); + setUnderline( xPeer, rControl ); + } + } + } + + + void ControlBorderManager::focusGained( const Reference< XInterface >& _rxControl ) + { + if ( m_bDynamicBorderColors ) + controlStatusGained( _rxControl, m_aFocusControl ); + } + + + void ControlBorderManager::focusLost( const Reference< XInterface >& _rxControl ) + { + if ( m_bDynamicBorderColors ) + controlStatusLost( _rxControl, m_aFocusControl ); + } + + + void ControlBorderManager::mouseEntered( const Reference< XInterface >& _rxControl ) + { + if ( m_bDynamicBorderColors ) + controlStatusGained( _rxControl, m_aMouseHoverControl ); + } + + + void ControlBorderManager::mouseExited( const Reference< XInterface >& _rxControl ) + { + if ( m_bDynamicBorderColors ) + controlStatusLost( _rxControl, m_aMouseHoverControl ); + } + + + void ControlBorderManager::validityChanged( const Reference< XControl >& _rxControl, const Reference< XValidatableFormComponent >& _rxValidatable ) + { + try + { + OSL_ENSURE( _rxControl.is(), "ControlBorderManager::validityChanged: invalid control!" ); + OSL_ENSURE( _rxValidatable.is(), "ControlBorderManager::validityChanged: invalid validatable!" ); + + Reference< XVclWindowPeer > xPeer( _rxControl.is() ? _rxControl->getPeer() : Reference< XWindowPeer >(), UNO_QUERY ); + if ( !xPeer.is() || !_rxValidatable.is() ) + return; + + ControlData aData( _rxControl ); + + if ( _rxValidatable->isValid() ) + { + ControlBag::iterator aPos = m_aInvalidControls.find( aData ); + if ( aPos != m_aInvalidControls.end() ) + { // invalid before, valid now + ControlData aOriginalLayout( *aPos ); + m_aInvalidControls.erase( aPos ); + + // restore all the things we used to indicate invalidity + if ( m_bDynamicBorderColors ) + updateBorderStyle( _rxControl, xPeer, aOriginalLayout ); + xPeer->setProperty( FM_PROP_HELPTEXT, Any( aOriginalLayout.sOriginalHelpText ) ); + setUnderline( xPeer, aOriginalLayout ); + } + return; + } + + // we're here in the INVALID case + if ( m_aInvalidControls.find( _rxControl ) == m_aInvalidControls.end() ) + { // valid before, invalid now + + // remember the current border + determineOriginalBorderStyle( _rxControl, aData ); + // and tool tip + xPeer->getProperty( FM_PROP_HELPTEXT ) >>= aData.sOriginalHelpText; + // and font + getUnderline( xPeer, aData ); + + m_aInvalidControls.insert( aData ); + + // update the border to the new invalidity + if ( m_bDynamicBorderColors && canColorBorder( xPeer ) ) + updateBorderStyle( _rxControl, xPeer, aData ); + else + { + // and also the new font + setUnderline( xPeer, UnderlineDescriptor( css::awt::FontUnderline::WAVE, m_nInvalidColor ) ); + } + } + + // update the explanation for invalidity (this is always done, even if the validity did not change) + Reference< XValidator > xValidator = _rxValidatable->getValidator(); + OSL_ENSURE( xValidator.is(), "ControlBorderManager::validityChanged: invalid, but no validator?" ); + OUString sExplainInvalidity = xValidator.is() ? xValidator->explainInvalid( _rxValidatable->getCurrentValue() ) : OUString(); + xPeer->setProperty( FM_PROP_HELPTEXT, Any( sExplainInvalidity ) ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "ControlBorderManager::validityChanged" ); + } + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmcontrollayout.cxx b/svx/source/form/fmcontrollayout.cxx new file mode 100644 index 000000000..985fc6ef1 --- /dev/null +++ b/svx/source/form/fmcontrollayout.cxx @@ -0,0 +1,312 @@ +/* -*- 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 <fmcontrollayout.hxx> +#include <fmprop.hxx> + +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/awt/VisualEffect.hpp> +#include <com/sun/star/i18n/ScriptType.hpp> +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/awt/FontDescriptor.hpp> +#include <com/sun/star/style/XStyleFamiliesSupplier.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/container/XChild.hpp> + +#include <comphelper/processfactory.hxx> +#include <i18nlangtag/mslangid.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <unotools/confignode.hxx> +#include <unotools/syslocale.hxx> +#include <unotools/localedatawrapper.hxx> + +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <vcl/outdev.hxx> + + +namespace svxform +{ + + + using namespace ::utl; + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::uno::UNO_SET_THROW; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::uno::RuntimeException; + using ::com::sun::star::uno::Any; + using ::com::sun::star::beans::XPropertySet; + using ::com::sun::star::beans::XPropertySetInfo; + using ::com::sun::star::lang::Locale; + using ::com::sun::star::awt::FontDescriptor; + using ::com::sun::star::style::XStyleFamiliesSupplier; + using ::com::sun::star::lang::XServiceInfo; + using ::com::sun::star::container::XNameAccess; + using ::com::sun::star::container::XChild; + + namespace FormComponentType = ::com::sun::star::form::FormComponentType; + namespace VisualEffect = ::com::sun::star::awt::VisualEffect; + namespace ScriptType = ::com::sun::star::i18n::ScriptType; + + + namespace + { + ::utl::OConfigurationNode getLayoutSettings( DocumentType _eDocType ) + { + OUString sConfigName = "/org.openoffice.Office.Common/Forms/ControlLayout/" + + DocumentClassification::getModuleIdentifierForDocumentType( _eDocType ); + return OConfigurationTreeRoot::createWithComponentContext( + ::comphelper::getProcessComponentContext(), // TODO + sConfigName ); + } + + template< class INTERFACE_TYPE > + Reference< INTERFACE_TYPE > getTypedModelNode( const Reference< XInterface >& _rxModelNode ) + { + Reference< INTERFACE_TYPE > xTypedNode( _rxModelNode, UNO_QUERY ); + if ( xTypedNode.is() ) + return xTypedNode; + else + { + Reference< XChild > xChild( _rxModelNode, UNO_QUERY ); + if ( xChild.is() ) + return getTypedModelNode< INTERFACE_TYPE >( xChild->getParent() ); + else + return nullptr; + } + } + + + bool lcl_getDocumentDefaultStyleAndFamily( const Reference< XInterface >& _rxDocument, OUString& _rFamilyName, OUString& _rStyleName ) + { + bool bSuccess = true; + Reference< XServiceInfo > xDocumentSI( _rxDocument, UNO_QUERY ); + if ( xDocumentSI.is() ) + { + if ( xDocumentSI->supportsService("com.sun.star.text.TextDocument") + || xDocumentSI->supportsService("com.sun.star.text.WebDocument") + ) + { + _rFamilyName = "ParagraphStyles"; + _rStyleName = "Standard"; + } + else if ( xDocumentSI->supportsService("com.sun.star.sheet.SpreadsheetDocument") ) + { + _rFamilyName = "CellStyles"; + _rStyleName = "Default"; + } + else if ( xDocumentSI->supportsService("com.sun.star.drawing.DrawingDocument") + || xDocumentSI->supportsService("com.sun.star.presentation.PresentationDocument") + ) + { + _rFamilyName = "graphics"; + _rStyleName = "standard"; + } + else + bSuccess = false; + } + return bSuccess; + } + + + void lcl_initializeControlFont( const Reference< XPropertySet >& _rxModel ) + { + try + { + Reference< XPropertySet > xStyle( ControlLayouter::getDefaultDocumentTextStyle( _rxModel ), UNO_SET_THROW ); + Reference< XPropertySetInfo > xStylePSI( xStyle->getPropertySetInfo(), UNO_SET_THROW ); + + // determine the script type associated with the system locale + const SvtSysLocale aSysLocale; + const LocaleDataWrapper& rSysLocaleData = aSysLocale.GetLocaleData(); + const sal_Int16 eSysLocaleScriptType = MsLangId::getScriptType( rSysLocaleData.getLanguageTag().getLanguageType() ); + + // depending on this script type, use the right property from the document's style which controls the + // default locale for document content + const char* pCharLocalePropertyName = "CharLocale"; + switch ( eSysLocaleScriptType ) + { + case ScriptType::LATIN: + // already defaulted above + break; + case ScriptType::ASIAN: + pCharLocalePropertyName = "CharLocaleAsian"; + break; + case ScriptType::COMPLEX: + pCharLocalePropertyName = "CharLocaleComplex"; + break; + default: + OSL_FAIL( "lcl_initializeControlFont: unexpected script type for system locale!" ); + break; + } + + OUString sCharLocalePropertyName = OUString::createFromAscii( pCharLocalePropertyName ); + Locale aDocumentCharLocale; + if ( xStylePSI->hasPropertyByName( sCharLocalePropertyName ) ) + { + OSL_VERIFY( xStyle->getPropertyValue( sCharLocalePropertyName ) >>= aDocumentCharLocale ); + } + // fall back to CharLocale property at the style + if ( aDocumentCharLocale.Language.isEmpty() ) + { + sCharLocalePropertyName = "CharLocale"; + if ( xStylePSI->hasPropertyByName( sCharLocalePropertyName ) ) + { + OSL_VERIFY( xStyle->getPropertyValue( sCharLocalePropertyName ) >>= aDocumentCharLocale ); + } + } + // fall back to the system locale + if ( aDocumentCharLocale.Language.isEmpty() ) + { + aDocumentCharLocale = rSysLocaleData.getLanguageTag().getLocale(); + } + + // retrieve a default font for this locale, and set it at the control + vcl::Font aFont = OutputDevice::GetDefaultFont( DefaultFontType::SANS, LanguageTag::convertToLanguageType( aDocumentCharLocale ), GetDefaultFontFlags::OnlyOne ); + FontDescriptor aFontDesc = VCLUnoHelper::CreateFontDescriptor( aFont ); + _rxModel->setPropertyValue("FontDescriptor", Any( aFontDesc ) + ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + + + //= ControlLayouter + + + Reference< XPropertySet > ControlLayouter::getDefaultDocumentTextStyle( const Reference< XPropertySet >& _rxModel ) + { + // the style family collection + Reference< XStyleFamiliesSupplier > xSuppStyleFamilies( getTypedModelNode< XStyleFamiliesSupplier >( _rxModel ), UNO_SET_THROW ); + Reference< XNameAccess > xStyleFamilies( xSuppStyleFamilies->getStyleFamilies(), UNO_SET_THROW ); + + // the names of the family, and the style - depends on the document type we live in + OUString sFamilyName, sStyleName; + if ( !lcl_getDocumentDefaultStyleAndFamily( xSuppStyleFamilies, sFamilyName, sStyleName ) ) + throw RuntimeException("unknown document type!"); + + // the concrete style + Reference< XNameAccess > xStyleFamily( xStyleFamilies->getByName( sFamilyName ), UNO_QUERY_THROW ); + return Reference< XPropertySet >( xStyleFamily->getByName( sStyleName ), UNO_QUERY_THROW ); + } + + + void ControlLayouter::initializeControlLayout( const Reference< XPropertySet >& _rxControlModel, DocumentType _eDocType ) + { + DBG_ASSERT( _rxControlModel.is(), "ControlLayouter::initializeControlLayout: invalid model!" ); + if ( !_rxControlModel.is() ) + return; + + try + { + Reference< XPropertySetInfo > xPSI( _rxControlModel->getPropertySetInfo(), UNO_SET_THROW ); + + // the control type + sal_Int16 nClassId = FormComponentType::CONTROL; + _rxControlModel->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId; + + // the document type + if ( _eDocType == eUnknownDocumentType ) + _eDocType = DocumentClassification::classifyHostDocument( _rxControlModel ); + + // let's see what the configuration says about the visual effect + OConfigurationNode aConfig = getLayoutSettings( _eDocType ); + Any aVisualEffect = aConfig.getNodeValue( OUString( "VisualEffect" ) ); + if ( aVisualEffect.hasValue() ) + { + OUString sVisualEffect; + OSL_VERIFY( aVisualEffect >>= sVisualEffect ); + + sal_Int16 nVisualEffect = VisualEffect::NONE; + if ( sVisualEffect == "flat" ) + nVisualEffect = VisualEffect::FLAT; + else if ( sVisualEffect == "3D" ) + nVisualEffect = VisualEffect::LOOK3D; + + if ( xPSI->hasPropertyByName( FM_PROP_BORDER ) ) + { + if ( ( nClassId != FormComponentType::COMMANDBUTTON ) + && ( nClassId != FormComponentType::RADIOBUTTON ) + && ( nClassId != FormComponentType::CHECKBOX ) + && ( nClassId != FormComponentType::GROUPBOX ) + && ( nClassId != FormComponentType::FIXEDTEXT ) + && ( nClassId != FormComponentType::SCROLLBAR ) + && ( nClassId != FormComponentType::SPINBUTTON ) + ) + { + _rxControlModel->setPropertyValue( FM_PROP_BORDER, Any( nVisualEffect ) ); + if ( ( nVisualEffect == VisualEffect::FLAT ) + && ( xPSI->hasPropertyByName( FM_PROP_BORDERCOLOR ) ) + ) + // light gray flat border + _rxControlModel->setPropertyValue( FM_PROP_BORDERCOLOR, Any( sal_Int32(0x00C0C0C0) ) ); + } + } + if ( xPSI->hasPropertyByName( FM_PROP_VISUALEFFECT ) ) + _rxControlModel->setPropertyValue( FM_PROP_VISUALEFFECT, Any( nVisualEffect ) ); + } + + // the font (only if we use the document's ref devices for rendering control text, otherwise, the + // default font of VCL controls is assumed to be fine) + if ( useDocumentReferenceDevice( _eDocType ) + && xPSI->hasPropertyByName( FM_PROP_FONT ) + ) + lcl_initializeControlFont( _rxControlModel ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "ControlLayouter::initializeControlLayout" ); + } + } + + bool ControlLayouter::useDynamicBorderColor( DocumentType _eDocType ) + { + OConfigurationNode aConfig = getLayoutSettings( _eDocType ); + Any aDynamicBorderColor = aConfig.getNodeValue( OUString( "DynamicBorderColors" ) ); + bool bDynamicBorderColor = false; + OSL_VERIFY( aDynamicBorderColor >>= bDynamicBorderColor ); + return bDynamicBorderColor; + } + + + bool ControlLayouter::useDocumentReferenceDevice( DocumentType _eDocType ) + { + if ( _eDocType == eUnknownDocumentType ) + return false; + OConfigurationNode aConfig = getLayoutSettings( _eDocType ); + Any aUseRefDevice = aConfig.getNodeValue( OUString( "UseDocumentTextMetrics" ) ); + bool bUseRefDevice = false; + OSL_VERIFY( aUseRefDevice >>= bUseRefDevice ); + return bUseRefDevice; + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmdmod.cxx b/svx/source/form/fmdmod.cxx new file mode 100644 index 000000000..e475cf8f8 --- /dev/null +++ b/svx/source/form/fmdmod.cxx @@ -0,0 +1,92 @@ +/* -*- 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 <sal/macros.h> +#include <svx/fmdmod.hxx> +#include <fmservs.hxx> +#include <fmobj.hxx> +#include <svx/unoshape.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/sequence.hxx> +#include <com/sun/star/uno/XComponentContext.hpp> + +using namespace ::svxform; + + +::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL SvxFmMSFactory::createInstance(const OUString& rServiceSpecifier) +{ + ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRet; + + if ( rServiceSpecifier.startsWith( "com.sun.star.form.component." ) ) + { + css::uno::Reference<css::uno::XComponentContext> xContext = comphelper::getProcessComponentContext(); + xRet = xContext->getServiceManager()->createInstanceWithContext(rServiceSpecifier, xContext); + } + else if ( rServiceSpecifier == "com.sun.star.drawing.ControlShape" ) + { + SdrModel& rTargetModel(getSdrModelFromUnoModel()); + SdrObject* pObj = new FmFormObj(rTargetModel); + xRet = static_cast<cppu::OWeakObject*>(static_cast<SvxShape_UnoImplHelper*>(new SvxShapeControl(pObj))); + } + + if (!xRet.is()) + { + xRet = SvxUnoDrawMSFactory::createInstance(rServiceSpecifier); + } + + return xRet; +} + + +::com::sun::star::uno::Sequence< OUString > SAL_CALL SvxFmMSFactory::getAvailableServiceNames() +{ + static const rtl::OUStringConstExpr aSvxComponentServiceNameList[] = + { + FM_SUN_COMPONENT_TEXTFIELD, + FM_SUN_COMPONENT_FORM, + FM_SUN_COMPONENT_LISTBOX, + FM_SUN_COMPONENT_COMBOBOX, + FM_SUN_COMPONENT_RADIOBUTTON, + FM_SUN_COMPONENT_GROUPBOX, + FM_SUN_COMPONENT_FIXEDTEXT, + FM_SUN_COMPONENT_COMMANDBUTTON, + FM_SUN_COMPONENT_CHECKBOX, + FM_SUN_COMPONENT_GRIDCONTROL, + FM_SUN_COMPONENT_IMAGEBUTTON, + FM_SUN_COMPONENT_FILECONTROL, + FM_SUN_COMPONENT_TIMEFIELD, + FM_SUN_COMPONENT_DATEFIELD, + FM_SUN_COMPONENT_NUMERICFIELD, + FM_SUN_COMPONENT_CURRENCYFIELD, + FM_SUN_COMPONENT_PATTERNFIELD, + FM_SUN_COMPONENT_HIDDENCONTROL, + FM_SUN_COMPONENT_IMAGECONTROL + }; + + static const sal_uInt16 nSvxComponentServiceNameListCount = SAL_N_ELEMENTS(aSvxComponentServiceNameList); + + auto aSeq( comphelper::arrayToSequence< OUString >(aSvxComponentServiceNameList, nSvxComponentServiceNameListCount) ); + + ::com::sun::star::uno::Sequence< OUString > aParentSeq( SvxUnoDrawMSFactory::getAvailableServiceNames() ); + return comphelper::concatSequences( aParentSeq, aSeq ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmdocumentclassification.cxx b/svx/source/form/fmdocumentclassification.cxx new file mode 100644 index 000000000..e624e23f5 --- /dev/null +++ b/svx/source/form/fmdocumentclassification.cxx @@ -0,0 +1,197 @@ +/* -*- 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 <fmdocumentclassification.hxx> + +#include <com/sun/star/container/XChild.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/xforms/XFormsSupplier.hpp> +#include <com/sun/star/frame/XModule.hpp> + +#include <o3tl/string_view.hxx> +#include <tools/diagnose_ex.h> + + +namespace svxform +{ + + + namespace + { + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::container::XChild; + using ::com::sun::star::frame::XModel; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::frame::XModule; + + + template< class TYPE > + Reference< TYPE > getTypedModelNode( const Reference< XInterface >& _rxModelNode ) + { + Reference< TYPE > xTypedNode( _rxModelNode, UNO_QUERY ); + if ( xTypedNode.is() ) + return xTypedNode; + else + { + Reference< XChild > xChild( _rxModelNode, UNO_QUERY ); + if ( xChild.is() ) + return getTypedModelNode< TYPE >( xChild->getParent() ); + else + return Reference< TYPE >(); + } + } + + + Reference< XModel > getDocument( const Reference< XInterface >& _rxModelNode ) + { + return getTypedModelNode< XModel >( _rxModelNode ); + } + } + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::xforms; + using namespace ::com::sun::star::container; + + + namespace + { + + struct ModuleInfo + { + const char* pAsciiModuleOrServiceName; + DocumentType eType; + }; + + + const ModuleInfo* lcl_getModuleInfo() + { + static const ModuleInfo aModuleInfo[] = + { + { "com.sun.star.text.TextDocument", eTextDocument }, + { "com.sun.star.text.WebDocument", eWebDocument }, + { "com.sun.star.sheet.SpreadsheetDocument", eSpreadsheetDocument }, + { "com.sun.star.drawing.DrawingDocument", eDrawingDocument }, + { "com.sun.star.presentation.PresentationDocument", ePresentationDocument }, + { "com.sun.star.xforms.XMLFormDocument", eEnhancedForm }, + { "com.sun.star.sdb.FormDesign", eDatabaseForm }, + { "com.sun.star.sdb.TextReportDesign", eDatabaseReport }, + { "com.sun.star.text.GlobalDocument", eTextDocument }, + { nullptr, eUnknownDocumentType } + }; + return aModuleInfo; + } + } + + + //= DocumentClassification + + + DocumentType DocumentClassification::classifyDocument( const Reference< XModel >& _rxDocumentModel ) + { + DocumentType eType( eUnknownDocumentType ); + + OSL_ENSURE( _rxDocumentModel.is(), "DocumentClassification::classifyDocument: invalid document!" ); + if ( !_rxDocumentModel.is() ) + return eType; + + try + { + // first, check whether the document has a ModuleIdentifier which we know + Reference< XModule > xModule( _rxDocumentModel, UNO_QUERY ); + if ( xModule.is() ) + eType = getDocumentTypeForModuleIdentifier( xModule->getIdentifier() ); + if ( eType != eUnknownDocumentType ) + return eType; + + // second, check whether it supports one of the services we know + Reference< XServiceInfo > xSI( _rxDocumentModel, UNO_QUERY_THROW ); + const ModuleInfo* pModuleInfo = lcl_getModuleInfo(); + while ( pModuleInfo->pAsciiModuleOrServiceName ) + { + if ( xSI->supportsService( OUString::createFromAscii( pModuleInfo->pAsciiModuleOrServiceName ) ) ) + return pModuleInfo->eType; + ++pModuleInfo; + } + + // last: uhm, there is no last resort + OSL_FAIL( "DocumentClassification::classifyDocument: unknown document!" ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + return eType; + } + + + DocumentType DocumentClassification::classifyHostDocument( const Reference< XInterface >& _rxFormComponent ) + { + DocumentType eType( eUnknownDocumentType ); + + try + { + Reference< XModel > xDocument( getDocument( _rxFormComponent ) ); + if ( !xDocument.is() ) + return eUnknownDocumentType; + eType = classifyDocument( xDocument ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "DocumentClassification::classifyHostDocument" ); + } + + return eType; + } + + + DocumentType DocumentClassification::getDocumentTypeForModuleIdentifier( std::u16string_view _rModuleIdentifier ) + { + const ModuleInfo* pModuleInfo = lcl_getModuleInfo(); + while ( pModuleInfo->pAsciiModuleOrServiceName ) + { + if ( o3tl::equalsAscii(_rModuleIdentifier, pModuleInfo->pAsciiModuleOrServiceName ) ) + return pModuleInfo->eType; + ++pModuleInfo; + } + return eUnknownDocumentType; + } + + + OUString DocumentClassification::getModuleIdentifierForDocumentType( DocumentType _eType ) + { + const ModuleInfo* pModuleInfo = lcl_getModuleInfo(); + while ( pModuleInfo->pAsciiModuleOrServiceName ) + { + if ( pModuleInfo->eType == _eType ) + return OUString::createFromAscii( pModuleInfo->pAsciiModuleOrServiceName ); + ++pModuleInfo; + } + return OUString(); + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmdpage.cxx b/svx/source/form/fmdpage.cxx new file mode 100644 index 000000000..2351564e0 --- /dev/null +++ b/svx/source/form/fmdpage.cxx @@ -0,0 +1,115 @@ +/* -*- 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/fmpage.hxx> +#include <fmobj.hxx> +#include <svx/fmdpage.hxx> +#include <svx/unoshape.hxx> +#include <vcl/svapp.hxx> +#include <cppuhelper/queryinterface.hxx> + +using ::com::sun::star::uno::Any; +using ::com::sun::star::form::XFormsSupplier2; + +SvxFmDrawPage::SvxFmDrawPage( SdrPage* pInPage ) : + SvxDrawPage( pInPage ) +{ +} + +SvxFmDrawPage::~SvxFmDrawPage() noexcept +{ +} + +css::uno::Sequence< sal_Int8 > SAL_CALL SvxFmDrawPage::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +Any SAL_CALL SvxFmDrawPage::queryAggregation( const css::uno::Type& _rType ) +{ + Any aRet = ::cppu::queryInterface ( _rType + , static_cast< XFormsSupplier2* >( this ) + , static_cast< XFormsSupplier* >( this ) + ); + if ( !aRet.hasValue() ) + aRet = SvxDrawPage::queryAggregation( _rType ); + + return aRet; +} + +css::uno::Sequence< css::uno::Type > SAL_CALL SvxFmDrawPage::getTypes( ) +{ + return comphelper::concatSequences(SvxDrawPage::getTypes(), + css::uno::Sequence { cppu::UnoType<css::form::XFormsSupplier>::get() }); +} + +SdrObject *SvxFmDrawPage::CreateSdrObject_( const css::uno::Reference< css::drawing::XShape > & xDescr ) +{ + OUString aShapeType( xDescr->getShapeType() ); + + if ( aShapeType == "com.sun.star.drawing.ShapeControl" // compatibility + || aShapeType == "com.sun.star.drawing.ControlShape" + ) + { + return new FmFormObj(GetSdrPage()->getSdrModelFromSdrPage()); + } + else + { + return SvxDrawPage::CreateSdrObject_( xDescr ); + } +} + +css::uno::Reference< css::drawing::XShape > SvxFmDrawPage::CreateShape( SdrObject *pObj ) const +{ + if( SdrInventor::FmForm == pObj->GetObjInventor() ) + { + css::uno::Reference< css::drawing::XShape > xShape = static_cast<SvxShape*>(new SvxShapeControl( pObj )); + return xShape; + } + else + return SvxDrawPage::CreateShape( pObj ); +} + +// XFormsSupplier +css::uno::Reference< css::container::XNameContainer > SAL_CALL SvxFmDrawPage::getForms() +{ + SolarMutexGuard g; + + css::uno::Reference< css::container::XNameContainer > xForms; + + FmFormPage *pFmPage = dynamic_cast<FmFormPage*>( GetSdrPage() ); + if( pFmPage ) + xForms.set( pFmPage->GetForms(), css::uno::UNO_QUERY_THROW ); + + return xForms; +} + +// XFormsSupplier2 +sal_Bool SAL_CALL SvxFmDrawPage::hasForms() +{ + SolarMutexGuard g; + + bool bHas = false; + FmFormPage* pFormPage = dynamic_cast<FmFormPage*>( GetSdrPage() ); + if ( pFormPage ) + bHas = pFormPage->GetForms( false ).is(); + return bHas; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmexch.cxx b/svx/source/form/fmexch.cxx new file mode 100644 index 000000000..5a5429b10 --- /dev/null +++ b/svx/source/form/fmexch.cxx @@ -0,0 +1,347 @@ +/* -*- 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 <fmexch.hxx> + +#include <sot/formats.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> + +namespace svxform +{ + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::datatransfer; + + OLocalExchange::OLocalExchange( ) + :m_bDragging( false ) + ,m_bClipboardOwner( false ) + { + } + + void OLocalExchange::copyToClipboard(const weld::Widget& rWidget, const GrantAccess&) + { + if ( m_bClipboardOwner ) + { // simulate a lostOwnership to notify parties interested in + m_aClipboardListener.Call( *this ); + } + + m_bClipboardOwner = true; + CopyToClipboard(rWidget.get_clipboard()); + } + + void OLocalExchange::clear() + { + if ( !isClipboardOwner() ) + return; + + try + { + Reference< clipboard::XClipboard > xClipBoard( getOwnClipboard() ); + if ( xClipBoard.is() ) + xClipBoard->setContents( nullptr, nullptr ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + m_bClipboardOwner = false; + } + + void SAL_CALL OLocalExchange::lostOwnership( const Reference< clipboard::XClipboard >& _rxClipboard, const Reference< XTransferable >& _rxTrans ) + { + TransferDataContainer::implCallOwnLostOwnership( _rxClipboard, _rxTrans ); + m_bClipboardOwner = false; + + m_aClipboardListener.Call( *this ); + } + + void OLocalExchange::setDragging(bool bDragging) + { + m_bDragging = bDragging; + } + + void OLocalExchange::DragFinished( sal_Int8 nDropAction ) + { + TransferDataContainer::DragFinished( nDropAction ); + setDragging(false); + } + + bool OLocalExchange::hasFormat( const DataFlavorExVector& _rFormats, SotClipboardFormatId _nFormatId ) + { + return std::any_of(_rFormats.begin(), _rFormats.end(), + [&_nFormatId](const DataFlavorEx& rFormat) { return rFormat.mnSotId == _nFormatId; }); + } + + bool OLocalExchange::GetData( const css::datatransfer::DataFlavor& /*_rFlavor*/, const OUString& /*rDestDoc*/ ) + { + return false; // do not have any formats by default + } + + OControlTransferData::OControlTransferData( ) + : m_bFocusEntry(false) + { + } + + OControlTransferData::OControlTransferData( const Reference< XTransferable >& _rxTransferable ) + : m_bFocusEntry(false) + { + TransferableDataHelper aExchangedData( _rxTransferable ); + + // try the formats we know + if ( OControlExchange::hasControlPathFormat( aExchangedData.GetDataFlavorExVector() ) ) + { // paths to the controls, relative to a root + Sequence< Any > aControlPathData; + if ( aExchangedData.GetAny(OControlExchange::getControlPathFormatId(), OUString()) >>= aControlPathData ) + { + DBG_ASSERT( aControlPathData.getLength() >= 2, "OControlTransferData::OControlTransferData: invalid data for the control path format!" ); + if ( aControlPathData.getLength() >= 2 ) + { + aControlPathData[0] >>= m_xFormsRoot; + aControlPathData[1] >>= m_aControlPaths; + } + } + else + { + OSL_FAIL( "OControlTransferData::OControlTransferData: invalid data for the control path format (2)!" ); + } + } + if ( OControlExchange::hasHiddenControlModelsFormat( aExchangedData.GetDataFlavorExVector() ) ) + { // sequence of models of hidden controls + aExchangedData.GetAny(OControlExchange::getHiddenControlModelsFormatId(), OUString()) >>= m_aHiddenControlModels; + } + + updateFormats( ); + } + + + static bool lcl_fillDataFlavorEx( SotClipboardFormatId nId, DataFlavorEx& _rFlavor ) + { + _rFlavor.mnSotId = nId; + return SotExchange::GetFormatDataFlavor( _rFlavor.mnSotId, _rFlavor ); + } + + + void OControlTransferData::updateFormats( ) + { + m_aCurrentFormats.clear(); + m_aCurrentFormats.reserve( 3 ); + + DataFlavorEx aFlavor; + + if ( m_aHiddenControlModels.hasElements() ) + { + if ( lcl_fillDataFlavorEx( OControlExchange::getHiddenControlModelsFormatId(), aFlavor ) ) + m_aCurrentFormats.push_back( aFlavor ); + } + + if ( m_xFormsRoot.is() && m_aControlPaths.hasElements() ) + { + if ( lcl_fillDataFlavorEx( OControlExchange::getControlPathFormatId(), aFlavor ) ) + m_aCurrentFormats.push_back( aFlavor ); + } + + if ( !m_aSelectedEntries.empty() ) + { + if ( lcl_fillDataFlavorEx( OControlExchange::getFieldExchangeFormatId(), aFlavor ) ) + m_aCurrentFormats.push_back( aFlavor ); + } + } + + size_t OControlTransferData::onEntryRemoved(const weld::TreeView* pView, const weld::TreeIter* _pEntry) + { + auto aIter = std::find_if(m_aSelectedEntries.begin(), m_aSelectedEntries.end(), + [pView, _pEntry](const auto& rElem) { + return pView->iter_compare(*rElem, *_pEntry) == 0; + }); + if (aIter != m_aSelectedEntries.end()) + m_aSelectedEntries.erase(aIter); + + return m_aSelectedEntries.size(); + } + + void OControlTransferData::addSelectedEntry(std::unique_ptr<weld::TreeIter> xEntry) + { + m_aSelectedEntries.emplace(std::move(xEntry)); + } + + void OControlTransferData::setFocusEntry(bool _bFocusEntry) + { + m_bFocusEntry = _bFocusEntry; + } + + void OControlTransferData::addHiddenControlsFormat(const css::uno::Sequence< css::uno::Reference< css::uno::XInterface > >& seqInterfaces) + { + m_aHiddenControlModels = seqInterfaces; + } + + void OControlTransferData::buildPathFormat(const weld::TreeView* pTreeBox, const weld::TreeIter* pRoot) + { + m_aControlPaths.realloc(0); + + sal_Int32 nEntryCount = m_aSelectedEntries.size(); + if (nEntryCount == 0) + return; + + m_aControlPaths.realloc(nEntryCount); + css::uno::Sequence<sal_uInt32>* pAllPaths = m_aControlPaths.getArray(); + for (const auto& rCurrentEntry : m_aSelectedEntries) + { + // first we collect the path in an array + ::std::vector< sal_uInt32 > aCurrentPath; + + std::unique_ptr<weld::TreeIter> xLoop(pTreeBox->make_iterator(rCurrentEntry.get())); + while (pTreeBox->iter_compare(*xLoop, *pRoot) != 0) + { + aCurrentPath.push_back(pTreeBox->get_iter_index_in_parent(*xLoop)); + bool bLoop = pTreeBox->iter_parent(*xLoop); + assert(bLoop && "OControlTransferData::buildPathFormat: invalid root or entry !"); (void)bLoop; + } + + // then we can transfer it into css::uno::Sequence + Sequence<sal_uInt32>& rCurrentPath = *pAllPaths; + sal_Int32 nDepth = aCurrentPath.size(); + + rCurrentPath.realloc(nDepth); + sal_uInt32* pSeq = rCurrentPath.getArray(); + sal_Int32 j,k; + for (j = nDepth - 1, k = 0; k<nDepth; --j, ++k) + pSeq[j] = aCurrentPath[k]; + ++pAllPaths; + } + } + + void OControlTransferData::buildListFromPath(const weld::TreeView* pTreeBox, const weld::TreeIter* pRoot) + { + ListBoxEntrySet().swap(m_aSelectedEntries); + + for (const css::uno::Sequence<sal_uInt32>& rPaths : std::as_const(m_aControlPaths)) + { + std::unique_ptr<weld::TreeIter> xSearch(pTreeBox->make_iterator(pRoot)); + for (const sal_uInt32 nThisPath : rPaths) + pTreeBox->iter_nth_child(*xSearch, nThisPath); + m_aSelectedEntries.emplace(std::move(xSearch)); + } + } + + OControlExchange::OControlExchange( ) + { + } + + bool OControlExchange::GetData( const DataFlavor& _rFlavor, const OUString& rDestDoc ) + { + const SotClipboardFormatId nFormatId = SotExchange::GetFormat( _rFlavor ); + + if ( getControlPathFormatId( ) == nFormatId ) + { + // ugly. We have to pack all the info into one object + Sequence< Any > aCompleteInfo( 2 ); + OSL_ENSURE( m_xFormsRoot.is(), "OLocalExchange::GetData: invalid forms root for this format!" ); + aCompleteInfo.getArray()[ 0 ] <<= m_xFormsRoot; + aCompleteInfo.getArray()[ 1 ] <<= m_aControlPaths; + + SetAny( Any( aCompleteInfo ) ); + } + else if ( getHiddenControlModelsFormatId() == nFormatId ) + { + // just need to transfer the models + SetAny( Any( m_aHiddenControlModels ) ); + } + else + return OLocalExchange::GetData(_rFlavor, rDestDoc); + + return true; + } + + void OControlExchange::AddSupportedFormats() + { + if (m_bFocusEntry && !m_aSelectedEntries.empty()) + AddFormat(getFieldExchangeFormatId()); + + if (m_aControlPaths.hasElements()) + AddFormat(getControlPathFormatId()); + + if (m_aHiddenControlModels.hasElements()) + AddFormat(getHiddenControlModelsFormatId()); + } + + SotClipboardFormatId OControlExchange::getControlPathFormatId() + { + static SotClipboardFormatId s_nFormat = + SotExchange::RegisterFormatName("application/x-openoffice;windows_formatname=\"svxform.ControlPathExchange\""); + DBG_ASSERT(static_cast<SotClipboardFormatId>(-1) != s_nFormat, "OControlExchange::getControlPathFormatId: bad exchange id!"); + return s_nFormat; + } + + SotClipboardFormatId OControlExchange::getHiddenControlModelsFormatId() + { + static SotClipboardFormatId s_nFormat = + SotExchange::RegisterFormatName("application/x-openoffice;windows_formatname=\"svxform.HiddenControlModelsExchange\""); + DBG_ASSERT(static_cast<SotClipboardFormatId>(-1) != s_nFormat, "OControlExchange::getHiddenControlModelsFormatId: bad exchange id!"); + return s_nFormat; + } + + + SotClipboardFormatId OControlExchange::getFieldExchangeFormatId() + { + static SotClipboardFormatId s_nFormat = + SotExchange::RegisterFormatName("application/x-openoffice;windows_formatname=\"svxform.FieldNameExchange\""); + DBG_ASSERT(static_cast<SotClipboardFormatId>(-1) != s_nFormat, "OControlExchange::getFieldExchangeFormatId: bad exchange id!"); + return s_nFormat; + } + + //= OControlExchangeHelper + rtl::Reference<OLocalExchange> OControlExchangeHelper::createExchange() const + { + return new OControlExchange; + } + + OLocalExchangeHelper::OLocalExchangeHelper() + { + } + + OLocalExchangeHelper::~OLocalExchangeHelper() + { + implReset(); + } + + void OLocalExchangeHelper::copyToClipboard(const weld::Widget& rWidget) const + { + DBG_ASSERT( m_xTransferable.is(), "OLocalExchangeHelper::copyToClipboard: not prepared!" ); + m_xTransferable->copyToClipboard(rWidget, OLocalExchange::GrantAccess()); + } + + void OLocalExchangeHelper::implReset() + { + if (m_xTransferable.is()) + { + m_xTransferable->setClipboardListener( Link<OLocalExchange&,void>() ); + m_xTransferable.clear(); + } + } + + void OLocalExchangeHelper::prepareDrag( ) + { + DBG_ASSERT(!m_xTransferable.is() || !m_xTransferable->isDragging(), "OLocalExchangeHelper::prepareDrag: recursive DnD?"); + + implReset(); + m_xTransferable = createExchange(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmexpl.cxx b/svx/source/form/fmexpl.cxx new file mode 100644 index 000000000..8ab6006bd --- /dev/null +++ b/svx/source/form/fmexpl.cxx @@ -0,0 +1,527 @@ +/* -*- 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/strings.hrc> +#include <fmexpl.hxx> + +#include <helpids.h> +#include <svx/svdobjkind.hxx> +#include <svx/fmtools.hxx> +#include <fmexch.hxx> + +#include <svx/svxids.hrc> + +#include <fmprop.hxx> +#include <bitmaps.hlst> +#include <svx/dialmgr.hxx> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <sfx2/objitem.hxx> + +#include <svx/fmshell.hxx> +#include <comphelper/types.hxx> + +using namespace ::svxform; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::container; + +FmNavInsertedHint::FmNavInsertedHint( FmEntryData* pInsertedEntryData, sal_uInt32 nRelPos ) + :pEntryData( pInsertedEntryData ) + ,nPos( nRelPos ) + +{ +} + + +FmNavInsertedHint::~FmNavInsertedHint() +{ +} + + + +FmNavModelReplacedHint::FmNavModelReplacedHint( FmEntryData* pAffectedEntryData ) + :pEntryData( pAffectedEntryData ) +{ +} + + +FmNavModelReplacedHint::~FmNavModelReplacedHint() +{ +} + +FmNavRemovedHint::FmNavRemovedHint( FmEntryData* pRemovedEntryData ) + :pEntryData( pRemovedEntryData ) +{ +} + + +FmNavRemovedHint::~FmNavRemovedHint() +{ +} + +FmNavNameChangedHint::FmNavNameChangedHint( FmEntryData* pData, const OUString& rNewName ) + :pEntryData( pData ) + ,aNewName( rNewName ) +{ +} + + +FmNavNameChangedHint::~FmNavNameChangedHint() +{ +} + +FmNavClearedHint::FmNavClearedHint() +{ +} + + +FmNavClearedHint::~FmNavClearedHint() +{ +} + + +FmEntryDataList::FmEntryDataList() +{ +} + + +FmEntryDataList::~FmEntryDataList() +{ +} + + +void FmEntryDataList::removeNoDelete( FmEntryData* pItem ) +{ + auto it = std::find_if(maEntryDataList.begin(), maEntryDataList.end(), + [&pItem](const std::unique_ptr<FmEntryData>& rEntryData) { return rEntryData.get() == pItem; }); + if (it != maEntryDataList.end()) + { + it->release(); + maEntryDataList.erase( it ); + return; + } + assert(false); +} + + +void FmEntryDataList::insert( std::unique_ptr<FmEntryData> pItem, size_t Index ) +{ + if ( Index < maEntryDataList.size() ) + { + maEntryDataList.insert( maEntryDataList.begin() + Index, std::move(pItem) ); + } + else + maEntryDataList.push_back( std::move(pItem) ); +} + + +void FmEntryDataList::clear() +{ + maEntryDataList.clear(); +} + + +FmEntryData::FmEntryData( FmEntryData* pParentData, const Reference< XInterface >& _rxIFace ) + :pParent( pParentData ) +{ + pChildList.reset( new FmEntryDataList() ); + + newObject( _rxIFace ); +} + + +FmEntryData::~FmEntryData() +{ + pChildList->clear(); +} + + +void FmEntryData::newObject( const css::uno::Reference< css::uno::XInterface >& _rxIFace ) +{ + // do not just copy, normalize it + m_xNormalizedIFace.set( _rxIFace, UNO_QUERY ); + m_xProperties.set(m_xNormalizedIFace, css::uno::UNO_QUERY); + m_xChild.set(m_xNormalizedIFace, css::uno::UNO_QUERY); +} + + +FmEntryData::FmEntryData( const FmEntryData& rEntryData ) +{ + pChildList.reset( new FmEntryDataList() ); + aText = rEntryData.GetText(); + m_aNormalImage = rEntryData.GetNormalImage(); + pParent = rEntryData.GetParent(); + + FmEntryData* pChildData; + size_t nEntryCount = rEntryData.GetChildList()->size(); + for( size_t i = 0; i < nEntryCount; i++ ) + { + pChildData = rEntryData.GetChildList()->at( i ); + std::unique_ptr<FmEntryData> pNewChildData = pChildData->Clone(); + pChildList->insert( std::move(pNewChildData), size_t(-1) ); + } + + m_xNormalizedIFace = rEntryData.m_xNormalizedIFace; + m_xProperties = rEntryData.m_xProperties; + m_xChild = rEntryData.m_xChild; +} + + + +bool FmEntryData::IsEqualWithoutChildren( FmEntryData* pEntryData ) +{ + if(this == pEntryData) + return true; + + if( !pEntryData ) + return false; + + if( aText != pEntryData->GetText() ) + return false; + + if( !pEntryData->GetParent() && pParent ) + return false; + + if( pEntryData->GetParent() && !pParent ) + return false; + + if( !pEntryData->GetParent() && !pParent ) + return true; + + if( !pParent->IsEqualWithoutChildren(pEntryData->GetParent()) ) + return false; + + return true; +} + +FmFormData::FmFormData(const Reference< XForm >& _rxForm, FmFormData* _pParent) + : FmEntryData(_pParent, _rxForm) + , m_xForm(_rxForm) +{ + // set images + m_aNormalImage = RID_SVXBMP_FORM; + + // set title + if (m_xForm.is()) + { + Reference< XPropertySet > xSet(m_xForm, UNO_QUERY); + if (xSet.is()) + { + OUString aEntryName(::comphelper::getString(xSet->getPropertyValue( FM_PROP_NAME ))); + SetText(aEntryName); + } + } + else + SetText( OUString() ); +} + +FmFormData::~FmFormData() +{ +} + +FmFormData::FmFormData( const FmFormData& rFormData ) + :FmEntryData( rFormData ) +{ + m_xForm = rFormData.GetFormIface(); +} + + +std::unique_ptr<FmEntryData> FmFormData::Clone() +{ + return std::unique_ptr<FmEntryData>(new FmFormData( *this )); +} + + +bool FmFormData::IsEqualWithoutChildren( FmEntryData* pEntryData ) +{ + if(this == pEntryData) + return true; + FmFormData* pFormData = dynamic_cast<FmFormData*>(pEntryData); + if( !pFormData ) + return false; + if( m_xForm.get() != pFormData->GetFormIface().get() ) + return false; + + return FmEntryData::IsEqualWithoutChildren( pFormData ); +} + +FmControlData::FmControlData(const Reference< XFormComponent >& _rxComponent, FmFormData* _pParent) +: FmEntryData( _pParent, _rxComponent ), + m_xFormComponent( _rxComponent ) +{ + + // set images + m_aNormalImage = GetImage(); + + + // set title + Reference< XPropertySet > xSet(m_xFormComponent, UNO_QUERY); + if( xSet.is() ) + { + SetText( ::comphelper::getString(xSet->getPropertyValue( FM_PROP_NAME ))); + } +} + + +FmControlData::~FmControlData() +{ +} + + +FmControlData::FmControlData( const FmControlData& rControlData ) + :FmEntryData( rControlData ) +{ + m_xFormComponent = rControlData.GetFormComponent(); +} + + +std::unique_ptr<FmEntryData> FmControlData::Clone() +{ + return std::unique_ptr<FmEntryData>(new FmControlData( *this )); +} + + +OUString FmControlData::GetImage() const +{ + // Default-Image + OUString aImage(RID_SVXBMP_CONTROL); + + Reference< XServiceInfo > xInfo( m_xFormComponent, UNO_QUERY ); + if (!m_xFormComponent.is()) + return aImage; + + + // Spezielle Control-Images + SdrObjKind nObjectType = getControlTypeByObject(xInfo); + switch (nObjectType) + { + case SdrObjKind::FormButton: + aImage = RID_SVXBMP_BUTTON; + break; + + case SdrObjKind::FormFixedText: + aImage = RID_SVXBMP_FIXEDTEXT; + break; + + case SdrObjKind::FormEdit: + aImage = RID_SVXBMP_EDITBOX; + break; + + case SdrObjKind::FormRadioButton: + aImage = RID_SVXBMP_RADIOBUTTON; + break; + + case SdrObjKind::FormCheckbox: + aImage = RID_SVXBMP_CHECKBOX; + break; + + case SdrObjKind::FormListbox: + aImage = RID_SVXBMP_LISTBOX; + break; + + case SdrObjKind::FormCombobox: + aImage = RID_SVXBMP_COMBOBOX; + break; + + case SdrObjKind::FormNavigationBar: + aImage = RID_SVXBMP_NAVIGATIONBAR; + break; + + case SdrObjKind::FormGroupBox: + aImage = RID_SVXBMP_GROUPBOX; + break; + + case SdrObjKind::FormImageButton: + aImage = RID_SVXBMP_IMAGEBUTTON; + break; + + case SdrObjKind::FormFileControl: + aImage = RID_SVXBMP_FILECONTROL; + break; + + case SdrObjKind::FormHidden: + aImage = RID_SVXBMP_HIDDEN; + break; + + case SdrObjKind::FormDateField: + aImage = RID_SVXBMP_DATEFIELD; + break; + + case SdrObjKind::FormTimeField: + aImage = RID_SVXBMP_TIMEFIELD; + break; + + case SdrObjKind::FormNumericField: + aImage = RID_SVXBMP_NUMERICFIELD; + break; + + case SdrObjKind::FormCurrencyField: + aImage = RID_SVXBMP_CURRENCYFIELD; + break; + + case SdrObjKind::FormPatternField: + aImage = RID_SVXBMP_PATTERNFIELD; + break; + + case SdrObjKind::FormImageControl: + aImage = RID_SVXBMP_IMAGECONTROL; + break; + + case SdrObjKind::FormFormattedField: + aImage = RID_SVXBMP_FORMATTEDFIELD; + break; + + case SdrObjKind::FormGrid: + aImage = RID_SVXBMP_GRID; + break; + + case SdrObjKind::FormScrollbar: + aImage = RID_SVXBMP_SCROLLBAR; + break; + + case SdrObjKind::FormSpinButton: + aImage = RID_SVXBMP_SPINBUTTON; + break; + + default:; + } + + return aImage; +} + +bool FmControlData::IsEqualWithoutChildren( FmEntryData* pEntryData ) +{ + if(this == pEntryData) + return true; + + FmControlData* pControlData = dynamic_cast<FmControlData*>(pEntryData); + if( !pControlData ) + return false; + + if( m_xFormComponent.get() != pControlData->GetFormComponent().get() ) + return false; + + return FmEntryData::IsEqualWithoutChildren( pControlData ); +} + +void FmControlData::ModelReplaced(const Reference< XFormComponent >& _rxNew) +{ + m_xFormComponent = _rxNew; + newObject( m_xFormComponent ); + // set images anew + m_aNormalImage = GetImage(); +} + +namespace svxform +{ + + NavigatorFrame::NavigatorFrame( SfxBindings* _pBindings, SfxChildWindow* _pMgr, + vcl::Window* _pParent ) + : SfxDockingWindow(_pBindings, _pMgr, _pParent, "FormNavigator", "svx/ui/formnavigator.ui") + , SfxControllerItem( SID_FM_FMEXPLORER_CONTROL, *_pBindings ) + , m_xNavigatorTree(new NavigatorTree(m_xBuilder->weld_tree_view("treeview"))) + { + SetHelpId( HID_FORM_NAVIGATOR_WIN ); + + SetText( SvxResId(RID_STR_FMEXPLORER) ); + SfxDockingWindow::SetFloatingSize( Size(200,200) ); + } + + NavigatorFrame::~NavigatorFrame() + { + disposeOnce(); + } + + void NavigatorFrame::dispose() + { + m_xNavigatorTree.reset(); + ::SfxControllerItem::dispose(); + SfxDockingWindow::dispose(); + } + + void NavigatorFrame::UpdateContent( FmFormShell* pFormShell ) + { + m_xNavigatorTree->UpdateContent(pFormShell); + } + + void NavigatorFrame::StateChangedAtToolBoxControl( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState ) + { + if( !pState || SID_FM_FMEXPLORER_CONTROL != nSID ) + return; + + if( eState >= SfxItemState::DEFAULT ) + { + FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() ); + UpdateContent( pShell ); + } + else + UpdateContent( nullptr ); + } + + void NavigatorFrame::GetFocus() + { + if (m_xNavigatorTree ) + m_xNavigatorTree->GrabFocus(); + else + SfxDockingWindow::GetFocus(); + } + + bool NavigatorFrame::Close() + { + UpdateContent( nullptr ); + return SfxDockingWindow::Close(); + } + + void NavigatorFrame::FillInfo( SfxChildWinInfo& rInfo ) const + { + SfxDockingWindow::FillInfo( rInfo ); + rInfo.bVisible = false; + } + + Size NavigatorFrame::CalcDockingSize( SfxChildAlignment eAlign ) + { + if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) ) + return Size(); + + return SfxDockingWindow::CalcDockingSize( eAlign ); + } + + SfxChildAlignment NavigatorFrame::CheckAlignment( SfxChildAlignment _eActAlign, SfxChildAlignment _eAlign ) + { + if ( ( _eAlign == SfxChildAlignment::LEFT ) || ( _eAlign == SfxChildAlignment::RIGHT ) || ( _eAlign == SfxChildAlignment::NOALIGNMENT ) ) + return _eAlign; + return _eActAlign; + } + + SFX_IMPL_DOCKINGWINDOW( NavigatorFrameManager, SID_FM_SHOW_FMEXPLORER ) + + NavigatorFrameManager::NavigatorFrameManager( vcl::Window* _pParent, sal_uInt16 _nId, + SfxBindings* _pBindings, SfxChildWinInfo* _pInfo ) + :SfxChildWindow( _pParent, _nId ) + { + SetWindow( VclPtr<NavigatorFrame>::Create( _pBindings, this, _pParent ) ); + static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmmodel.cxx b/svx/source/form/fmmodel.cxx new file mode 100644 index 000000000..e518319aa --- /dev/null +++ b/svx/source/form/fmmodel.cxx @@ -0,0 +1,209 @@ +/* -*- 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 <fmundo.hxx> +#include <fmdocumentclassification.hxx> +#include <fmcontrollayout.hxx> + +#include <com/sun/star/form/XForms.hpp> +#include <svx/fmmodel.hxx> +#include <svx/fmpage.hxx> + +#include <sfx2/objsh.hxx> +#include <osl/diagnose.h> + +#include <optional> + +using ::com::sun::star::uno::Reference; +using ::com::sun::star::container::XNameContainer; +using namespace svxform; + + +struct FmFormModelImplData +{ + rtl::Reference<FmXUndoEnvironment> mxUndoEnv; + bool bOpenInDesignIsDefaulted; + std::optional<bool> aControlsUseRefDevice; + + FmFormModelImplData() + :bOpenInDesignIsDefaulted( true ) + { + } +}; + +FmFormModel::FmFormModel( + SfxItemPool* pPool, + SfxObjectShell* pPers) +: SdrModel( + pPool, + pPers) + , m_pObjShell(nullptr) + , m_bOpenInDesignMode(false) + , m_bAutoControlFocus(false) +{ + m_pImpl.reset( new FmFormModelImplData ); + m_pImpl->mxUndoEnv = new FmXUndoEnvironment(*this); +} + +FmFormModel::~FmFormModel() +{ + if (m_pObjShell && m_pImpl->mxUndoEnv->IsListening(*m_pObjShell)) + SetObjectShell(nullptr); + + ClearUndoBuffer(); + // minimum limit for undos + SetMaxUndoActionCount(1); +} + +rtl::Reference<SdrPage> FmFormModel::AllocPage(bool bMasterPage) +{ + return new FmFormPage(*this, bMasterPage); +} + +void FmFormModel::InsertPage(SdrPage* pPage, sal_uInt16 nPos) +{ + // hack for as long as the method is internal + if (m_pObjShell && !m_pImpl->mxUndoEnv->IsListening( *m_pObjShell )) + SetObjectShell(m_pObjShell); + + SdrModel::InsertPage( pPage, nPos ); +} + +rtl::Reference<SdrPage> FmFormModel::RemovePage(sal_uInt16 nPgNum) +{ + FmFormPage* pToBeRemovedPage = dynamic_cast< FmFormPage* >( GetPage( nPgNum ) ); + OSL_ENSURE( pToBeRemovedPage, "FmFormModel::RemovePage: *which page*?" ); + + if ( pToBeRemovedPage ) + { + Reference< XNameContainer > xForms( pToBeRemovedPage->GetForms( false ) ); + if ( xForms.is() ) + m_pImpl->mxUndoEnv->RemoveForms( xForms ); + } + + rtl::Reference<FmFormPage> pRemovedPage = static_cast<FmFormPage*>(SdrModel::RemovePage(nPgNum).get()); + OSL_ENSURE( pRemovedPage == pToBeRemovedPage, "FmFormModel::RemovePage: inconsistency!" ); + return pRemovedPage; +} + +void FmFormModel::InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos) +{ + // hack for as long as the method is internal + if (m_pObjShell && !m_pImpl->mxUndoEnv->IsListening( *m_pObjShell )) + SetObjectShell(m_pObjShell); + + SdrModel::InsertMasterPage(pPage, nPos); +} + +rtl::Reference<SdrPage> FmFormModel::RemoveMasterPage(sal_uInt16 nPgNum) +{ + rtl::Reference<FmFormPage> pPage = static_cast<FmFormPage*>(SdrModel::RemoveMasterPage(nPgNum).get()); + + if ( pPage ) + { + Reference< XNameContainer > xForms( pPage->GetForms( false ) ); + if ( xForms.is() ) + m_pImpl->mxUndoEnv->RemoveForms( xForms ); + } + + return pPage; +} + + +void FmFormModel::implSetOpenInDesignMode( bool _bOpenDesignMode ) +{ + if( _bOpenDesignMode != m_bOpenInDesignMode ) + { + m_bOpenInDesignMode = _bOpenDesignMode; + + if ( m_pObjShell ) + m_pObjShell->SetModified(); + } + // no matter if we really did it or not - from now on, it does not count as defaulted anymore + m_pImpl->bOpenInDesignIsDefaulted = false; +} + + +void FmFormModel::SetOpenInDesignMode( bool bOpenDesignMode ) +{ + implSetOpenInDesignMode( bOpenDesignMode ); +} + + +bool FmFormModel::OpenInDesignModeIsDefaulted( ) +{ + return m_pImpl->bOpenInDesignIsDefaulted; +} + + +bool FmFormModel::ControlsUseRefDevice() const +{ + if ( !m_pImpl->aControlsUseRefDevice ) + { + DocumentType eDocType = eUnknownDocumentType; + if ( m_pObjShell ) + eDocType = DocumentClassification::classifyHostDocument( m_pObjShell->GetModel() ); + m_pImpl->aControlsUseRefDevice = ControlLayouter::useDocumentReferenceDevice(eDocType); + } + return *m_pImpl->aControlsUseRefDevice; +} + + +void FmFormModel::SetAutoControlFocus( bool _bAutoControlFocus ) +{ + if( _bAutoControlFocus != m_bAutoControlFocus ) + { + m_bAutoControlFocus = _bAutoControlFocus; + m_pObjShell->SetModified(); + } +} + + +void FmFormModel::SetObjectShell( SfxObjectShell* pShell ) +{ + if (pShell == m_pObjShell) + return; + + if (m_pObjShell) + { + m_pImpl->mxUndoEnv->EndListening( *this ); + m_pImpl->mxUndoEnv->EndListening( *m_pObjShell ); + } + + m_pObjShell = pShell; + + if (m_pObjShell) + { + m_pImpl->mxUndoEnv->SetReadOnly( m_pObjShell->IsReadOnly() || m_pObjShell->IsReadOnlyUI(), FmXUndoEnvironment::Accessor() ); + + if (!m_pImpl->mxUndoEnv->IsReadOnly()) + m_pImpl->mxUndoEnv->StartListening(*this); + + m_pImpl->mxUndoEnv->StartListening( *m_pObjShell ); + } +} + + +FmXUndoEnvironment& FmFormModel::GetUndoEnv() +{ + return *m_pImpl->mxUndoEnv; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmobj.cxx b/svx/source/form/fmobj.cxx new file mode 100644 index 000000000..e337f79d7 --- /dev/null +++ b/svx/source/form/fmobj.cxx @@ -0,0 +1,653 @@ +/* -*- 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 <fmobj.hxx> +#include <fmprop.hxx> +#include <fmvwimp.hxx> +#include <fmpgeimp.hxx> +#include <o3tl/string_view.hxx> +#include <svx/fmview.hxx> +#include <svx/fmpage.hxx> +#include <svx/svdovirt.hxx> +#include <svx/fmmodel.hxx> + +#include <com/sun/star/awt/XDevice.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/form/Forms.hpp> +#include <com/sun/star/script/XEventAttacherManager.hpp> +#include <svx/fmtools.hxx> + +#include <comphelper/property.hxx> +#include <comphelper/processfactory.hxx> +#include <toolkit/awt/vclxdevice.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> + +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::script; +using namespace ::com::sun::star::container; +using namespace ::svxform; + + +FmFormObj::FmFormObj( + SdrModel& rSdrModel, + const OUString& rModelName) +: SdrUnoObj(rSdrModel, rModelName) + ,m_nPos(-1) + ,m_pLastKnownRefDevice(nullptr) +{ + // normally, this is done in SetUnoControlModel, but if the call happened in the base class ctor, + // then our incarnation of it was not called (since we were not constructed at this time). + impl_checkRefDevice_nothrow( true ); +} + +FmFormObj::FmFormObj(SdrModel& rSdrModel) +: SdrUnoObj(rSdrModel, "") + ,m_nPos(-1) + ,m_pLastKnownRefDevice(nullptr) +{ + // Stuff that old SetModel also did: + impl_checkRefDevice_nothrow(); +} + +FmFormObj::FmFormObj(SdrModel& rSdrModel, FmFormObj const & rSource) +: SdrUnoObj(rSdrModel, rSource) + ,m_nPos(-1) + ,m_pLastKnownRefDevice(nullptr) +{ + // Stuff that old SetModel also did: + impl_checkRefDevice_nothrow(); + + // If UnoControlModel is part of an event environment, + // events may assigned to it. + Reference< XFormComponent > xContent(rSource.xUnoControlModel, UNO_QUERY); + if (xContent.is()) + { + Reference< XEventAttacherManager > xManager(xContent->getParent(), UNO_QUERY); + Reference< XIndexAccess > xManagerAsIndex(xManager, UNO_QUERY); + if (xManagerAsIndex.is()) + { + sal_Int32 nPos = getElementPos( xManagerAsIndex, xContent ); + if ( nPos >= 0 ) + aEvts = xManager->getScriptEvents( nPos ); + } + } + else + aEvts = rSource.aEvts; + + Reference< XChild > xSourceAsChild(rSource.GetUnoControlModel(), UNO_QUERY); + if (!xSourceAsChild.is()) + return; + + Reference< XInterface > xSourceContainer = xSourceAsChild->getParent(); + + m_xEnvironmentHistory = css::form::Forms::create( comphelper::getProcessComponentContext() ); + + ensureModelEnv(xSourceContainer, m_xEnvironmentHistory); + m_aEventsHistory = aEvts; + // if we were clone there was a call to operator=, so aEvts are exactly the events we need here... +} + +FmFormObj::~FmFormObj() +{ + + if (m_xEnvironmentHistory.is()) + m_xEnvironmentHistory->dispose(); + + m_xEnvironmentHistory = nullptr; + m_aEventsHistory.realloc(0); +} + + +void FmFormObj::SetObjEnv(const Reference< XIndexContainer > & xForm, const sal_Int32 nIdx, + const Sequence< ScriptEventDescriptor >& rEvts) +{ + m_xParent = xForm; + aEvts = rEvts; + m_nPos = nIdx; +} + + +void FmFormObj::ClearObjEnv() +{ + m_xParent.clear(); + aEvts.realloc( 0 ); + m_nPos = -1; +} + + +void FmFormObj::impl_checkRefDevice_nothrow( bool _force ) +{ + const FmFormModel* pFormModel = dynamic_cast<FmFormModel*>(&getSdrModelFromSdrObject()); + if ( !pFormModel || !pFormModel->ControlsUseRefDevice() ) + return; + + OutputDevice* pCurrentRefDevice = pFormModel->GetRefDevice(); + if ( ( m_pLastKnownRefDevice.get() == pCurrentRefDevice ) && !_force ) + return; + + Reference< XControlModel > xControlModel( GetUnoControlModel() ); + if ( !xControlModel.is() ) + return; + + m_pLastKnownRefDevice = pCurrentRefDevice; + if ( !m_pLastKnownRefDevice ) + return; + + try + { + Reference< XPropertySet > xModelProps( GetUnoControlModel(), UNO_QUERY_THROW ); + Reference< XPropertySetInfo > xPropertyInfo( xModelProps->getPropertySetInfo(), UNO_SET_THROW ); + + static constexpr OUStringLiteral sRefDevicePropName = u"ReferenceDevice"; + if ( xPropertyInfo->hasPropertyByName( sRefDevicePropName ) ) + { + rtl::Reference<VCLXDevice> pUnoRefDevice = new VCLXDevice; + pUnoRefDevice->SetOutputDevice( m_pLastKnownRefDevice ); + Reference< XDevice > xRefDevice( pUnoRefDevice ); + xModelProps->setPropertyValue( sRefDevicePropName, Any( xRefDevice ) ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FmFormObj::impl_isolateControlModel_nothrow() +{ + try + { + Reference< XChild > xControlModel( GetUnoControlModel(), UNO_QUERY ); + if ( xControlModel.is() ) + { + Reference< XIndexContainer> xParent( xControlModel->getParent(), UNO_QUERY ); + if ( xParent.is() ) + { + sal_Int32 nPos = getElementPos( xParent, xControlModel ); + xParent->removeByIndex( nPos ); + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FmFormObj::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage) +{ + FmFormPage* pOldFormPage(dynamic_cast< FmFormPage* >(getSdrPageFromSdrObject())); + if ( pOldFormPage ) + pOldFormPage->GetImpl().formObjectRemoved( *this ); + + FmFormPage* pNewFormPage = dynamic_cast<FmFormPage*>( pNewPage ); + if ( !pNewFormPage ) + { + // Maybe it makes sense to create an environment history here : if somebody set's our page to NULL, and we have a valid page before, + // me may want to remember our place within the old page. For this we could create a new m_xEnvironmentHistory to store it. + // So the next SetPage with a valid new page would restore that environment within the new page. + // But for the original Bug (#57300#) we don't need that, so I omit it here. Maybe this will be implemented later. + impl_isolateControlModel_nothrow(); + SdrUnoObj::handlePageChange(pOldPage, pNewPage); + return; + } + + Reference< css::form::XForms > xNewPageForms = pNewFormPage->GetForms(); + Reference< XIndexContainer > xNewParent; + Sequence< ScriptEventDescriptor> aNewEvents; + + // calc the new parent for my model (within the new page's forms hierarchy) + // do we have a history ? (from :Clone) + if ( m_xEnvironmentHistory.is() ) + { + // the element in m_xEnvironmentHistory which is equivalent to my new parent (which (perhaps) has to be created within pNewPage->GetForms) + // is the right-most element in the tree. + Reference< XIndexContainer > xRightMostLeaf( m_xEnvironmentHistory, UNO_QUERY_THROW ); + try + { + while ( xRightMostLeaf->getCount() ) + { + xRightMostLeaf.set( + xRightMostLeaf->getByIndex( xRightMostLeaf->getCount() - 1 ), + UNO_QUERY_THROW + ); + } + + xNewParent.set( ensureModelEnv( xRightMostLeaf, xNewPageForms ), UNO_QUERY_THROW ); + + // we successfully cloned the environment in m_xEnvironmentHistory, so we can use m_aEventsHistory + // (which describes the events of our model at the moment m_xEnvironmentHistory was created) + aNewEvents = m_aEventsHistory; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + if ( !xNewParent.is() ) + { + // are we a valid part of our current page forms ? + Reference< XIndexContainer > xOldForms; + if ( pOldFormPage ) + xOldForms.set( pOldFormPage->GetForms(), UNO_QUERY_THROW ); + + if ( xOldForms.is() ) + { + // search (upward from our model) for xOldForms + Reference< XChild > xSearch( GetUnoControlModel(), UNO_QUERY ); + while (xSearch.is()) + { + if ( xSearch == xOldForms ) + break; + xSearch.set( xSearch->getParent(), UNO_QUERY ); + } + if ( xSearch.is() ) // implies xSearch == xOldForms, which means we're a valid part of our current page forms hierarchy + { + Reference< XChild > xMeAsChild( GetUnoControlModel(), UNO_QUERY ); + xNewParent.set( ensureModelEnv( xMeAsChild->getParent(), xNewPageForms ), UNO_QUERY ); + + if ( xNewParent.is() ) + { + try + { + // transfer the events from our (model's) parent to the new (model's) parent, too + Reference< XEventAttacherManager > xEventManager(xMeAsChild->getParent(), UNO_QUERY); + Reference< XIndexAccess > xManagerAsIndex(xEventManager, UNO_QUERY); + if (xManagerAsIndex.is()) + { + sal_Int32 nPos = getElementPos(xManagerAsIndex, xMeAsChild); + if (nPos >= 0) + aNewEvents = xEventManager->getScriptEvents(nPos); + } + else + aNewEvents = aEvts; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + } + } + + // now set the page + SdrUnoObj::handlePageChange(pOldPage, pNewPage); + + // place my model within the new parent container + if (xNewParent.is()) + { + Reference< XFormComponent > xMeAsFormComp(GetUnoControlModel(), UNO_QUERY); + if (xMeAsFormComp.is()) + { + // check if I have another parent (and remove me, if necessary) + Reference< XIndexContainer > xOldParent(xMeAsFormComp->getParent(), UNO_QUERY); + if (xOldParent.is()) + { + sal_Int32 nPos = getElementPos(xOldParent, xMeAsFormComp); + if (nPos > -1) + xOldParent->removeByIndex(nPos); + } + + // and insert into the new container + xNewParent->insertByIndex(xNewParent->getCount(), Any(xMeAsFormComp)); + + // transfer the events + if (aNewEvents.hasElements()) + { + try + { + Reference< XEventAttacherManager > xEventManager(xNewParent, UNO_QUERY); + Reference< XIndexAccess > xManagerAsIndex(xEventManager, UNO_QUERY); + if (xManagerAsIndex.is()) + { + sal_Int32 nPos = getElementPos(xManagerAsIndex, xMeAsFormComp); + DBG_ASSERT(nPos >= 0, "FmFormObj::SetPage : inserted but not present ?"); + xEventManager->registerScriptEvents(nPos, aNewEvents); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + } + } + } + + // delete my history + if (m_xEnvironmentHistory.is()) + m_xEnvironmentHistory->dispose(); + + m_xEnvironmentHistory = nullptr; + m_aEventsHistory.realloc(0); + + pNewFormPage->GetImpl().formObjectInserted( *this ); +} + +SdrInventor FmFormObj::GetObjInventor() const +{ + return SdrInventor::FmForm; +} + +SdrObjKind FmFormObj::GetObjIdentifier() const +{ + return SdrObjKind::UNO; +} + +FmFormObj* FmFormObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new FmFormObj(rTargetModel, *this); +} + +void FmFormObj::NbcReformatText() +{ + impl_checkRefDevice_nothrow(); + SdrUnoObj::NbcReformatText(); +} + + +namespace +{ + OUString lcl_getFormComponentAccessPath(const Reference< XInterface >& _xElement, Reference< XInterface >& _rTopLevelElement) + { + Reference< css::form::XFormComponent> xChild(_xElement, UNO_QUERY); + Reference< css::container::XIndexAccess> xParent; + if (xChild.is()) + xParent.set(xChild->getParent(), UNO_QUERY); + + // while the current content is a form + OUString sReturn; + while (xChild.is()) + { + // get the content's relative pos within its parent container + sal_Int32 nPos = getElementPos(xParent, xChild); + + // prepend this current relative pos + OUString sCurrentIndex = OUString::number(nPos); + if (!sReturn.isEmpty()) + { + sCurrentIndex += "\\" + sReturn; + } + + sReturn = sCurrentIndex; + + // travel up + xChild.set(xParent, css::uno::UNO_QUERY); + if (xChild.is()) + xParent.set(xChild->getParent(), UNO_QUERY); + } + + _rTopLevelElement = xParent; + return sReturn; + } +} + + +Reference< XInterface > FmFormObj::ensureModelEnv(const Reference< XInterface > & _rSourceContainer, const Reference<css::form::XForms>& _rTopLevelDestContainer) +{ + Reference< XInterface > xTopLevelSource; + OUString sAccessPath = lcl_getFormComponentAccessPath(_rSourceContainer, xTopLevelSource); + if (!xTopLevelSource.is()) + // something went wrong, maybe _rSourceContainer isn't part of a valid forms hierarchy + return Reference< XInterface > (); + + Reference< XIndexContainer > xDestContainer(_rTopLevelDestContainer, UNO_QUERY_THROW); + Reference< XIndexContainer > xSourceContainer(xTopLevelSource, UNO_QUERY); + DBG_ASSERT(xSourceContainer.is(), "FmFormObj::ensureModelEnv : the top level source is invalid !"); + + sal_Int32 nTokIndex = 0; + do + { + std::u16string_view aToken = o3tl::getToken(sAccessPath, 0, '\\', nTokIndex ); + sal_uInt16 nIndex = static_cast<sal_uInt16>(o3tl::toInt32(aToken)); + + // get the DSS of the source form (we have to find an equivalent for) + DBG_ASSERT(nIndex<xSourceContainer->getCount(), "FmFormObj::ensureModelEnv : invalid access path !"); + Reference< XPropertySet > xSourceForm; + xSourceContainer->getByIndex(nIndex) >>= xSourceForm; + DBG_ASSERT(xSourceForm.is(), "FmFormObj::ensureModelEnv : invalid source form !"); + + Any aSrcCursorSource, aSrcCursorSourceType, aSrcDataSource; + DBG_ASSERT(::comphelper::hasProperty(FM_PROP_COMMAND, xSourceForm) && ::comphelper::hasProperty(FM_PROP_COMMANDTYPE, xSourceForm) + && ::comphelper::hasProperty(FM_PROP_DATASOURCE, xSourceForm), "FmFormObj::ensureModelEnv : invalid access path or invalid form (missing props) !"); + // the parent access path should refer to a row set + try + { + aSrcCursorSource = xSourceForm->getPropertyValue(FM_PROP_COMMAND); + aSrcCursorSourceType = xSourceForm->getPropertyValue(FM_PROP_COMMANDTYPE); + aSrcDataSource = xSourceForm->getPropertyValue(FM_PROP_DATASOURCE); + } + catch(Exception&) + { + OSL_FAIL("FmFormObj::ensureModelEnv : could not retrieve a source DSS !"); + } + + + // calc the number of (source) form siblings with the same DSS + Reference< XPropertySet > xCurrentSourceForm, xCurrentDestForm; + sal_Int16 nCurrentSourceIndex = 0; + sal_Int32 nCurrentDestIndex = 0; + while (nCurrentSourceIndex <= nIndex) + { + bool bEqualDSS = false; + while (!bEqualDSS) // (we don't have to check nCurrentSourceIndex here : it's bound by nIndex) + { + xSourceContainer->getByIndex(nCurrentSourceIndex) >>= xCurrentSourceForm; + DBG_ASSERT(xCurrentSourceForm.is(), "FmFormObj::ensureModelEnv : invalid form ancestor (2) !"); + bEqualDSS = false; + if (::comphelper::hasProperty(FM_PROP_DATASOURCE, xCurrentSourceForm)) + { // it is a form + try + { + if ( xCurrentSourceForm->getPropertyValue(FM_PROP_COMMAND) == aSrcCursorSource + && xCurrentSourceForm->getPropertyValue(FM_PROP_COMMANDTYPE) == aSrcCursorSourceType + && xCurrentSourceForm->getPropertyValue(FM_PROP_DATASOURCE) == aSrcDataSource + ) + { + bEqualDSS = true; + } + } + catch(Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", + "exception while getting a sibling's DSS !"); + } + + } + ++nCurrentSourceIndex; + } + + DBG_ASSERT(bEqualDSS, "FmFormObj::ensureModelEnv : found no source form !"); + // ??? at least the nIndex-th one should have been found ??? + + // now search the next one with the given DSS (within the destination container) + bEqualDSS = false; + while (!bEqualDSS && (nCurrentDestIndex < xDestContainer->getCount())) + { + xDestContainer->getByIndex(nCurrentDestIndex) >>= xCurrentDestForm; + DBG_ASSERT(xCurrentDestForm.is(), "FmFormObj::ensureModelEnv : invalid destination form !"); + bEqualDSS = false; + if (::comphelper::hasProperty(FM_PROP_DATASOURCE, xCurrentDestForm)) + { // it is a form + try + { + if ( xCurrentDestForm->getPropertyValue(FM_PROP_COMMAND) == aSrcCursorSource + && xCurrentDestForm->getPropertyValue(FM_PROP_COMMANDTYPE) == aSrcCursorSourceType + && xCurrentDestForm->getPropertyValue(FM_PROP_DATASOURCE) == aSrcDataSource + ) + { + bEqualDSS = true; + } + } + catch(Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", + "exception while getting a destination DSS !"); + } + + } + ++nCurrentDestIndex; + } + + if (!bEqualDSS) + { // There is at least one more source form with the given DSS than destination forms are. + // correct this ... + try + { + // create and insert (into the destination) a copy of the form + xCurrentDestForm.set( + ::comphelper::getProcessServiceFactory()->createInstance("com.sun.star.form.component.DataForm"), + UNO_QUERY_THROW ); + ::comphelper::copyProperties( xCurrentSourceForm, xCurrentDestForm ); + + DBG_ASSERT(nCurrentDestIndex == xDestContainer->getCount(), "FmFormObj::ensureModelEnv : something went wrong with the numbers !"); + xDestContainer->insertByIndex(nCurrentDestIndex, Any(xCurrentDestForm)); + + ++nCurrentDestIndex; + // like nCurrentSourceIndex, nCurrentDestIndex now points 'behind' the form it actually means + } + catch(Exception&) + { + OSL_FAIL("FmFormObj::ensureModelEnv : something went seriously wrong while creating a new form !"); + // no more options anymore ... + return Reference< XInterface > (); + } + + } + } + + // now xCurrentDestForm is a form equivalent to xSourceForm (which means they have the same DSS and the same number + // of left siblings with the same DSS, which counts for all their ancestors, too) + + // go down + xDestContainer.set(xCurrentDestForm, UNO_QUERY); + xSourceContainer.set(xSourceForm, UNO_QUERY); + DBG_ASSERT(xDestContainer.is() && xSourceContainer.is(), "FmFormObj::ensureModelEnv : invalid container !"); + } + while ( nTokIndex >= 0 ); + + return Reference<XInterface>( xDestContainer, UNO_QUERY ); +} + +FmFormObj* FmFormObj::GetFormObject( SdrObject* _pSdrObject ) +{ + FmFormObj* pFormObject = dynamic_cast< FmFormObj* >( _pSdrObject ); + if ( !pFormObject ) + { + SdrVirtObj* pVirtualObject = dynamic_cast< SdrVirtObj* >( _pSdrObject ); + if ( pVirtualObject ) + pFormObject = dynamic_cast< FmFormObj* >( &pVirtualObject->ReferencedObj() ); + } + return pFormObject; +} + + +const FmFormObj* FmFormObj::GetFormObject( const SdrObject* _pSdrObject ) +{ + const FmFormObj* pFormObject = dynamic_cast< const FmFormObj* >( _pSdrObject ); + if ( !pFormObject ) + { + const SdrVirtObj* pVirtualObject = dynamic_cast< const SdrVirtObj* >( _pSdrObject ); + if ( pVirtualObject ) + pFormObject = dynamic_cast< const FmFormObj* >( &pVirtualObject->GetReferencedObj() ); + } + return pFormObject; +} + + +void FmFormObj::SetUnoControlModel( const Reference< css::awt::XControlModel >& _rxModel ) +{ + SdrUnoObj::SetUnoControlModel( _rxModel ); + + FmFormPage* pFormPage(dynamic_cast< FmFormPage* >(getSdrPageFromSdrObject())); + if ( pFormPage ) + pFormPage->GetImpl().formModelAssigned( *this ); + + impl_checkRefDevice_nothrow( true ); +} + + +bool FmFormObj::EndCreate( SdrDragStat& rStat, SdrCreateCmd eCmd ) +{ + bool bResult = SdrUnoObj::EndCreate(rStat, eCmd); + if ( bResult && SdrCreateCmd::ForceEnd == eCmd && rStat.GetView() ) + { + FmFormPage* pFormPage(dynamic_cast< FmFormPage* >(getSdrPageFromSdrObject())); + + if (nullptr != pFormPage) + { + try + { + Reference< XFormComponent > xContent( xUnoControlModel, UNO_QUERY_THROW ); + Reference< XForm > xParentForm( xContent->getParent(), UNO_QUERY ); + + Reference< XIndexContainer > xFormToInsertInto; + + if ( !xParentForm.is() ) + { // model is not yet part of a form component hierarchy + xParentForm.set( pFormPage->GetImpl().findPlaceInFormComponentHierarchy( xContent ), UNO_SET_THROW ); + xFormToInsertInto.set( xParentForm, UNO_QUERY_THROW ); + } + + FmFormPageImpl::setUniqueName( xContent, xParentForm ); + + if ( xFormToInsertInto.is() ) + xFormToInsertInto->insertByIndex( xFormToInsertInto->getCount(), Any( xContent ) ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + FmFormView* pView( dynamic_cast< FmFormView* >( rStat.GetView() ) ); + FmXFormView* pViewImpl = pView ? pView->GetImpl() : nullptr; + OSL_ENSURE( pViewImpl, "FmFormObj::EndCreate: no view!?" ); + if ( pViewImpl ) + pViewImpl->onCreatedFormObject( *this ); + } + return bResult; +} + + +void FmFormObj::BrkCreate( SdrDragStat& rStat ) +{ + SdrUnoObj::BrkCreate( rStat ); + impl_isolateControlModel_nothrow(); + + FmFormView* pView( dynamic_cast< FmFormView* >( rStat.GetView() ) ); + FmXFormView* pViewImpl = pView ? pView->GetImpl() : nullptr; + OSL_ENSURE( pViewImpl, "FmFormObj::EndCreate: no view!?" ); + if ( pViewImpl ) + pViewImpl->breakCreateFormObject(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmobjfac.cxx b/svx/source/form/fmobjfac.cxx new file mode 100644 index 000000000..7bdf2d4cc --- /dev/null +++ b/svx/source/form/fmobjfac.cxx @@ -0,0 +1,231 @@ +/* -*- 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 <config_fuzzers.h> + +#include <tools/diagnose_ex.h> +#include <svx/svdobj.hxx> +#include <svx/fmtools.hxx> +#include <fmservs.hxx> + +#include <svx/fmobjfac.hxx> + +#include <svx/svdobjkind.hxx> + +#include <fmobj.hxx> + +#include <svx/fmshell.hxx> + +#include <svx/svxids.hrc> +#include <tbxform.hxx> + +#include <tabwin.hxx> +#include <fmexpl.hxx> +#include <filtnav.hxx> + +#include <fmprop.hxx> +#include <fmPropBrw.hxx> +#include <datanavi.hxx> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::svxform; + +static bool bInit = false; + +FmFormObjFactory::FmFormObjFactory() +{ + if ( bInit ) + return; + + SdrObjFactory::InsertMakeObjectHdl(LINK(this, FmFormObjFactory, MakeObject)); + + + // register the configuration css::frame::Controller and the NavigationBar + SvxFmTbxCtlAbsRec::RegisterControl( SID_FM_RECORD_ABSOLUTE ); + SvxFmTbxCtlRecText::RegisterControl( SID_FM_RECORD_TEXT ); + SvxFmTbxCtlRecFromText::RegisterControl( SID_FM_RECORD_FROM_TEXT ); + SvxFmTbxCtlRecTotal::RegisterControl( SID_FM_RECORD_TOTAL ); + SvxFmTbxPrevRec::RegisterControl( SID_FM_RECORD_PREV ); + SvxFmTbxNextRec::RegisterControl( SID_FM_RECORD_NEXT ); + + // registering global windows + FmFieldWinMgr::RegisterChildWindow(); + FmPropBrwMgr::RegisterChildWindow(); + NavigatorFrameManager::RegisterChildWindow(); + DataNavigatorManager::RegisterChildWindow(); +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + FmFilterNavigatorWinMgr::RegisterChildWindow(); +#endif + + // register the interface for the Formshell + FmFormShell::RegisterInterface(); + + ImplSmartRegisterUnoServices(); + bInit = true; +} + +// create css::form::Form objects +namespace +{ + void lcl_initProperty( FmFormObj const * _pObject, const OUString& _rPropName, const Any& _rValue ) + { + try + { + Reference< XPropertySet > xModelSet( _pObject->GetUnoControlModel(), UNO_QUERY ); + if ( xModelSet.is() ) + xModelSet->setPropertyValue( _rPropName, _rValue ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "lcl_initProperty" ); + } + } +} + +IMPL_STATIC_LINK(FmFormObjFactory, MakeObject, SdrObjCreatorParams, aParams, SdrObject*) +{ + SdrObject* pNewObj = nullptr; + + if (aParams.nInventor == SdrInventor::FmForm) + { + OUString sServiceSpecifier; + + typedef ::std::vector< ::std::pair< OUString, Any > > PropertyValueArray; + PropertyValueArray aInitialProperties; + + switch ( aParams.nObjIdentifier ) + { + case SdrObjKind::FormEdit: + sServiceSpecifier = FM_COMPONENT_EDIT; + break; + + case SdrObjKind::FormButton: + sServiceSpecifier = FM_COMPONENT_COMMANDBUTTON; + break; + + case SdrObjKind::FormFixedText: + sServiceSpecifier = FM_COMPONENT_FIXEDTEXT; + break; + + case SdrObjKind::FormListbox: + sServiceSpecifier = FM_COMPONENT_LISTBOX; + break; + + case SdrObjKind::FormCheckbox: + sServiceSpecifier = FM_COMPONENT_CHECKBOX; + break; + + case SdrObjKind::FormRadioButton: + sServiceSpecifier = FM_COMPONENT_RADIOBUTTON; + break; + + case SdrObjKind::FormGroupBox: + sServiceSpecifier = FM_COMPONENT_GROUPBOX; + break; + + case SdrObjKind::FormCombobox: + sServiceSpecifier = FM_COMPONENT_COMBOBOX; + break; + + case SdrObjKind::FormGrid: + sServiceSpecifier = FM_COMPONENT_GRID; + break; + + case SdrObjKind::FormImageButton: + sServiceSpecifier = FM_COMPONENT_IMAGEBUTTON; + break; + + case SdrObjKind::FormFileControl: + sServiceSpecifier = FM_COMPONENT_FILECONTROL; + break; + + case SdrObjKind::FormDateField: + sServiceSpecifier = FM_COMPONENT_DATEFIELD; + break; + + case SdrObjKind::FormTimeField: + sServiceSpecifier = FM_COMPONENT_TIMEFIELD; + aInitialProperties.emplace_back( FM_PROP_TIMEMAX, Any( tools::Time( 23, 59, 59, 999999999 ).GetUNOTime() ) ); + break; + + case SdrObjKind::FormNumericField: + sServiceSpecifier = FM_COMPONENT_NUMERICFIELD; + break; + + case SdrObjKind::FormCurrencyField: + sServiceSpecifier = FM_COMPONENT_CURRENCYFIELD; + break; + + case SdrObjKind::FormPatternField: + sServiceSpecifier = FM_COMPONENT_PATTERNFIELD; + break; + + case SdrObjKind::FormHidden: + sServiceSpecifier = FM_COMPONENT_HIDDEN; + break; + + case SdrObjKind::FormImageControl: + sServiceSpecifier = FM_COMPONENT_IMAGECONTROL; + break; + + case SdrObjKind::FormFormattedField: + sServiceSpecifier = FM_COMPONENT_FORMATTEDFIELD; + break; + + case SdrObjKind::FormNavigationBar: + sServiceSpecifier = FM_SUN_COMPONENT_NAVIGATIONBAR; + break; + + case SdrObjKind::FormScrollbar: + sServiceSpecifier = FM_SUN_COMPONENT_SCROLLBAR; + aInitialProperties.emplace_back( FM_PROP_BORDER, Any( sal_Int16(0) ) ); + break; + + case SdrObjKind::FormSpinButton: + sServiceSpecifier = FM_SUN_COMPONENT_SPINBUTTON; + aInitialProperties.emplace_back( FM_PROP_BORDER, Any( sal_Int16(0) ) ); + break; + + default: + break; + } + + // create the actual object + if ( !sServiceSpecifier.isEmpty() ) + pNewObj = new FmFormObj(aParams.rSdrModel, sServiceSpecifier); + else + pNewObj = new FmFormObj(aParams.rSdrModel); + + // initialize some properties which we want to differ from the defaults + for (const auto& rInitProp : aInitialProperties) + { + lcl_initProperty( + static_cast< FmFormObj* >( pNewObj ), + rInitProp.first, + rInitProp.second + ); + } + } + return pNewObj; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmpage.cxx b/svx/source/form/fmpage.cxx new file mode 100644 index 000000000..c4f0bcad5 --- /dev/null +++ b/svx/source/form/fmpage.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 <svx/fmpage.hxx> +#include <com/sun/star/beans/XPropertySet.hpp> + +#include <svx/fmmodel.hxx> + +#include <fmobj.hxx> + +#include <fmpgeimp.hxx> + +#include <svx/svdview.hxx> +#include <tools/urlobj.hxx> +#include <vcl/help.hxx> +#include <vcl/window.hxx> +#include <osl/diagnose.h> + + +#include <fmprop.hxx> +#include <fmundo.hxx> +using namespace ::svxform; +#include <comphelper/property.hxx> +#include <comphelper/types.hxx> + +using com::sun::star::uno::Reference; +using com::sun::star::uno::UNO_QUERY; + + +FmFormPage::FmFormPage(FmFormModel& rModel, bool bMasterPage) +: SdrPage(rModel, bMasterPage) + ,m_pImpl( new FmFormPageImpl( *this ) ) +{ +} + +void FmFormPage::lateInit(const FmFormPage& rPage) +{ + // call parent + SdrPage::lateInit( rPage ); + + // copy local variables (former stuff from copy constructor) + m_pImpl->initFrom( rPage.GetImpl() ); + m_sPageName = rPage.m_sPageName; +} + + +FmFormPage::~FmFormPage() +{ +} + +rtl::Reference<SdrPage> FmFormPage::CloneSdrPage(SdrModel& rTargetModel) const +{ + FmFormModel& rFmFormModel(static_cast< FmFormModel& >(rTargetModel)); + rtl::Reference<FmFormPage> pClonedFmFormPage = + new FmFormPage( + rFmFormModel, + IsMasterPage()); + pClonedFmFormPage->lateInit(*this); + return pClonedFmFormPage; +} + + +void FmFormPage::InsertObject(SdrObject* pObj, size_t nPos) +{ + SdrPage::InsertObject( pObj, nPos ); + static_cast< FmFormModel& >(getSdrModelFromSdrPage()).GetUndoEnv().Inserted(pObj); +} + + +const Reference< css::form::XForms > & FmFormPage::GetForms( bool _bForceCreate ) const +{ + const SdrPage& rMasterPage( *this ); + const FmFormPage* pFormPage = dynamic_cast< const FmFormPage* >( &rMasterPage ); + OSL_ENSURE( pFormPage, "FmFormPage::GetForms: referenced page is no FmFormPage - is this allowed?!" ); + if ( !pFormPage ) + pFormPage = this; + + return pFormPage->m_pImpl->getForms( _bForceCreate ); +} + + +bool FmFormPage::RequestHelp( vcl::Window* pWindow, SdrView const * pView, + const HelpEvent& rEvt ) +{ + if( pView->IsAction() ) + return false; + + Point aPos = rEvt.GetMousePosPixel(); + aPos = pWindow->ScreenToOutputPixel( aPos ); + aPos = pWindow->PixelToLogic( aPos ); + + SdrPageView* pPV = nullptr; + SdrObject* pObj = pView->PickObj(aPos, 0, pPV, SdrSearchOptions::DEEP); + if (!pObj) + return false; + + FmFormObj* pFormObject = FmFormObj::GetFormObject( pObj ); + if ( !pFormObject ) + return false; + + OUString aHelpText; + css::uno::Reference< css::beans::XPropertySet > xSet( pFormObject->GetUnoControlModel(), css::uno::UNO_QUERY ); + if (xSet.is()) + { + if (::comphelper::hasProperty(FM_PROP_HELPTEXT, xSet)) + aHelpText = ::comphelper::getString(xSet->getPropertyValue(FM_PROP_HELPTEXT)); + + if (aHelpText.isEmpty() && ::comphelper::hasProperty(FM_PROP_TARGET_URL, xSet)) + { + OUString aText = ::comphelper::getString(xSet->getPropertyValue(FM_PROP_TARGET_URL)); + INetURLObject aUrl(aText); + + // test if it is a protocol type that I want to display + INetProtocol aProtocol = aUrl.GetProtocol(); + static const INetProtocol s_aQuickHelpSupported[] = + { INetProtocol::Ftp, INetProtocol::Http, INetProtocol::File, INetProtocol::Mailto, + INetProtocol::Https, INetProtocol::Javascript, + INetProtocol::Ldap + }; + for (const INetProtocol& i : s_aQuickHelpSupported) + if (i == aProtocol) + { + aHelpText = aUrl.GetURLNoPass(INetURLObject::DecodeMechanism::Unambiguous); + break; + } + } + } + if ( !aHelpText.isEmpty() ) + { + // display the help + tools::Rectangle aItemRect = pObj->GetCurrentBoundRect(); + aItemRect = pWindow->LogicToPixel( aItemRect ); + Point aPt = pWindow->OutputToScreenPixel( aItemRect.TopLeft() ); + aItemRect.SetLeft( aPt.X() ); + aItemRect.SetTop( aPt.Y() ); + aPt = pWindow->OutputToScreenPixel( aItemRect.BottomRight() ); + aItemRect.SetRight( aPt.X() ); + aItemRect.SetBottom( aPt.Y() ); + if( rEvt.GetMode() == HelpEventMode::BALLOON ) + Help::ShowBalloon( pWindow, aItemRect.Center(), aItemRect, aHelpText); + else + Help::ShowQuickHelp( pWindow, aItemRect, aHelpText ); + } + return true; +} + + +SdrObject* FmFormPage::RemoveObject(size_t nObjNum) +{ + SdrObject* pObj = SdrPage::RemoveObject(nObjNum); + if (pObj) + static_cast< FmFormModel& >(getSdrModelFromSdrPage()).GetUndoEnv().Removed(pObj); + return pObj; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmpgeimp.cxx b/svx/source/form/fmpgeimp.cxx new file mode 100644 index 000000000..5e8c2027d --- /dev/null +++ b/svx/source/form/fmpgeimp.cxx @@ -0,0 +1,713 @@ +/* -*- 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 <fmpgeimp.hxx> +#include <fmundo.hxx> +#include <svx/fmtools.hxx> +#include <fmprop.hxx> +#include <fmservs.hxx> +#include <fmobj.hxx> +#include <formcontrolfactory.hxx> +#include <svx/svditer.hxx> +#include <svx/strings.hrc> +#include <treevisitor.hxx> + +#include <com/sun/star/sdb/CommandType.hpp> +#include <com/sun/star/sdbc/XRowSet.hpp> +#include <com/sun/star/container/EnumerableMap.hpp> +#include <com/sun/star/drawing/XControlShape.hpp> +#include <com/sun/star/form/Forms.hpp> +#include <com/sun/star/form/FormComponentType.hpp> + +#include <sal/log.hxx> +#include <sfx2/objsh.hxx> +#include <svx/fmpage.hxx> +#include <svx/fmmodel.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <svx/dialmgr.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/types.hxx> +#include <connectivity/dbtools.hxx> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdb; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::form; +using ::com::sun::star::awt::XControlModel; +using ::com::sun::star::container::XMap; +using ::com::sun::star::container::EnumerableMap; +using ::com::sun::star::drawing::XControlShape; +using namespace ::svxform; +using namespace ::dbtools; + + +FmFormPageImpl::FmFormPageImpl( FmFormPage& _rPage ) + :m_rPage( _rPage ) + ,m_bFirstActivation( true ) + ,m_bAttemptedFormCreation( false ) +{ +} + + +namespace +{ + class FormComponentInfo + { + public: + static size_t childCount( const Reference< XInterface >& _component ) + { + Reference< XIndexAccess > xContainer( _component, UNO_QUERY ); + if ( xContainer.is() ) + return xContainer->getCount(); + return 0; + } + + static Reference< XInterface > getChild( const Reference< XInterface >& _component, size_t _index ) + { + Reference< XIndexAccess > xContainer( _component, UNO_QUERY_THROW ); + return Reference< XInterface >( xContainer->getByIndex( _index ), UNO_QUERY ); + } + }; + + typedef ::std::pair< Reference< XInterface >, Reference< XInterface > > FormComponentPair; + + class FormHierarchyComparator + { + public: + FormHierarchyComparator() + { + } + + static size_t childCount( const FormComponentPair& _components ) + { + size_t lhsCount = FormComponentInfo::childCount( _components.first ); + size_t rhsCount = FormComponentInfo::childCount( _components.second ); + if ( lhsCount != rhsCount ) + throw RuntimeException( "Found inconsistent form component hierarchies (1)!" ); + return lhsCount; + } + + static FormComponentPair getChild( const FormComponentPair& _components, size_t _index ) + { + return FormComponentPair( + FormComponentInfo::getChild( _components.first, _index ), + FormComponentInfo::getChild( _components.second, _index ) + ); + } + }; + + typedef ::std::map< Reference< XControlModel >, Reference< XControlModel > > MapControlModels; + + class FormComponentAssignment + { + public: + explicit FormComponentAssignment( MapControlModels& _out_controlModelMap ) + :m_rControlModelMap( _out_controlModelMap ) + { + } + + void process( const FormComponentPair& _component ) + { + Reference< XControlModel > lhsControlModel( _component.first, UNO_QUERY ); + Reference< XControlModel > rhsControlModel( _component.second, UNO_QUERY ); + if ( lhsControlModel.is() != rhsControlModel.is() ) + throw RuntimeException( "Found inconsistent form component hierarchies (2)!" ); + + if ( lhsControlModel.is() ) + m_rControlModelMap[ lhsControlModel ] = rhsControlModel; + } + + private: + MapControlModels& m_rControlModelMap; + }; +} + + +void FmFormPageImpl::initFrom( FmFormPageImpl& i_foreignImpl ) +{ + // clone the Forms collection + const Reference< css::form::XForms > xForeignForms( i_foreignImpl.getForms( false ) ); + + if ( !xForeignForms.is() ) + return; + + try + { + m_xForms.set( xForeignForms->createClone(), UNO_QUERY_THROW ); + + // create a mapping between the original control models and their clones + MapControlModels aModelAssignment; + + typedef TreeVisitor< FormComponentPair, FormHierarchyComparator, FormComponentAssignment > FormComponentVisitor; + FormComponentVisitor aVisitor{ FormHierarchyComparator() }; + + FormComponentAssignment aAssignmentProcessor( aModelAssignment ); + aVisitor.process( FormComponentPair( xForeignForms, m_xForms ), aAssignmentProcessor ); + + // assign the cloned models to their SdrObjects + SdrObjListIter aForeignIter( &i_foreignImpl.m_rPage ); + SdrObjListIter aOwnIter( &m_rPage ); + + OSL_ENSURE( aForeignIter.IsMore() == aOwnIter.IsMore(), "FmFormPageImpl::FmFormPageImpl: inconsistent number of objects (1)!" ); + while ( aForeignIter.IsMore() && aOwnIter.IsMore() ) + { + FmFormObj* pForeignObj = dynamic_cast< FmFormObj* >( aForeignIter.Next() ); + FmFormObj* pOwnObj = dynamic_cast< FmFormObj* >( aOwnIter.Next() ); + + bool bForeignIsForm = pForeignObj && ( pForeignObj->GetObjInventor() == SdrInventor::FmForm ); + bool bOwnIsForm = pOwnObj && ( pOwnObj->GetObjInventor() == SdrInventor::FmForm ); + + if ( bForeignIsForm != bOwnIsForm ) + { + // if this fires, don't attempt to do further assignments, something's completely messed up + SAL_WARN( "svx.form", "FmFormPageImpl::FmFormPageImpl: inconsistent ordering of objects!" ); + break; + } + + if ( !bForeignIsForm ) + // no form control -> next round + continue; + + Reference< XControlModel > xForeignModel( pForeignObj->GetUnoControlModel() ); + if ( !xForeignModel.is() ) + { + // if this fires, the SdrObject does not have a UNO Control Model. This is pathological, but well ... + // So the cloned SdrObject will also not have a UNO Control Model. + SAL_WARN( "svx.form", "FmFormPageImpl::FmFormPageImpl: control shape without control!" ); + continue; + } + + MapControlModels::const_iterator assignment = aModelAssignment.find( xForeignModel ); + if ( assignment == aModelAssignment.end() ) + { + // if this fires, the source SdrObject has a model, but it is not part of the model hierarchy in + // i_foreignImpl.getForms(). + // Pathological, too ... + SAL_WARN( "svx.form", "FmFormPageImpl::FmFormPageImpl: no clone found for this model!" ); + continue; + } + + pOwnObj->SetUnoControlModel( assignment->second ); + } + OSL_ENSURE( aForeignIter.IsMore() == aOwnIter.IsMore(), "FmFormPageImpl::FmFormPageImpl: inconsistent number of objects (2)!" ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +Reference< XMap > FmFormPageImpl::getControlToShapeMap() +{ + Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); + if ( xControlShapeMap.is() ) + return xControlShapeMap; + + xControlShapeMap = impl_createControlShapeMap_nothrow(); + m_aControlShapeMap = xControlShapeMap; + return xControlShapeMap; +} + + +namespace +{ + void lcl_insertFormObject_throw( const FmFormObj& _object, const Reference< XMap >& _map ) + { + // the control model + Reference< XControlModel > xControlModel = _object.GetUnoControlModel(); + OSL_ENSURE( xControlModel.is(), "lcl_insertFormObject_throw: suspicious: no control model!" ); + if ( !xControlModel.is() ) + return; + + Reference< XControlShape > xControlShape( const_cast< FmFormObj& >( _object ).getUnoShape(), UNO_QUERY ); + OSL_ENSURE( xControlShape.is(), "lcl_insertFormObject_throw: suspicious: no control shape!" ); + if ( !xControlShape.is() ) + return; + + _map->put( Any( xControlModel ), Any( xControlShape ) ); + } + + void lcl_removeFormObject_throw( const FmFormObj& _object, const Reference< XMap >& _map ) + { + // the control model + Reference< XControlModel > xControlModel = _object.GetUnoControlModel(); + OSL_ENSURE( xControlModel.is(), "lcl_removeFormObject: suspicious: no control model!" ); + if ( !xControlModel.is() ) + { + return; + } + + Any aOldAssignment = _map->remove( Any( xControlModel ) ); + OSL_ENSURE( + aOldAssignment == Any( Reference< XControlShape >( const_cast< FmFormObj& >( _object ).getUnoShape(), UNO_QUERY ) ), + "lcl_removeFormObject: map was inconsistent!" ); + } +} + + +Reference< XMap > FmFormPageImpl::impl_createControlShapeMap_nothrow() +{ + Reference< XMap > xMap; + + try + { + xMap = EnumerableMap::create( comphelper::getProcessComponentContext(), + ::cppu::UnoType< XControlModel >::get(), + ::cppu::UnoType< XControlShape >::get() + ); + + SdrObjListIter aPageIter( &m_rPage ); + while ( aPageIter.IsMore() ) + { + // only FmFormObjs are what we're interested in + FmFormObj* pCurrent = FmFormObj::GetFormObject( aPageIter.Next() ); + if ( !pCurrent ) + continue; + + lcl_insertFormObject_throw( *pCurrent, xMap ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return xMap; +} + + +const Reference< css::form::XForms >& FmFormPageImpl::getForms( bool _bForceCreate ) +{ + if ( m_xForms.is() || !_bForceCreate ) + return m_xForms; + + if ( !m_bAttemptedFormCreation ) + { + m_bAttemptedFormCreation = true; + + Reference<XComponentContext> xContext = comphelper::getProcessComponentContext(); + m_xForms = css::form::Forms::create( xContext ); + + if ( m_aFormsCreationHdl.IsSet() ) + { + m_aFormsCreationHdl.Call( *this ); + } + + FmFormModel& rFmFormModel(dynamic_cast< FmFormModel& >(m_rPage.getSdrModelFromSdrPage())); + + // give the newly created collection a place in the universe + SfxObjectShell* pObjShell(rFmFormModel.GetObjectShell()); + if ( pObjShell ) + m_xForms->setParent( pObjShell->GetModel() ); + + // tell the UNDO environment that we have a new forms collection + rFmFormModel.GetUndoEnv().AddForms( Reference<XNameContainer>(m_xForms,UNO_QUERY_THROW) ); + } + return m_xForms; +} + + +FmFormPageImpl::~FmFormPageImpl() +{ + xCurrentForm = nullptr; + + ::comphelper::disposeComponent( m_xForms ); +} + + +bool FmFormPageImpl::validateCurForm() +{ + if ( !xCurrentForm.is() ) + return false; + + if ( !xCurrentForm->getParent().is() ) + xCurrentForm.clear(); + + return xCurrentForm.is(); +} + + +void FmFormPageImpl::setCurForm(const Reference< css::form::XForm >& xForm) +{ + xCurrentForm = xForm; +} + + +Reference< XForm > FmFormPageImpl::getDefaultForm() +{ + Reference< XForm > xForm; + + Reference< XForms > xForms( getForms() ); + + // by default, we use our "current form" + if ( !validateCurForm() ) + { + // check whether there is a "standard" form + if ( Reference<XNameAccess>(xForms,UNO_QUERY_THROW)->hasElements() ) + { + // find the standard form + OUString sStandardFormname = SvxResId(RID_STR_STDFORMNAME); + + try + { + if ( xForms->hasByName( sStandardFormname ) ) + xForm.set( xForms->getByName( sStandardFormname ), UNO_QUERY_THROW ); + else + { + xForm.set( xForms->getByIndex(0), UNO_QUERY_THROW ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + else + { + xForm = xCurrentForm; + } + + // did not find an existing suitable form -> create a new one + if ( !xForm.is() ) + { + SdrModel& rModel(m_rPage.getSdrModelFromSdrPage()); + + if( rModel.IsUndoEnabled() ) + { + OUString aStr(SvxResId(RID_STR_FORM)); + OUString aUndoStr(SvxResId(RID_STR_UNDO_CONTAINER_INSERT)); + rModel.BegUndo(aUndoStr.replaceFirst("'#'", aStr)); + } + + try + { + xForm.set( ::comphelper::getProcessServiceFactory()->createInstance( FM_SUN_COMPONENT_FORM ), UNO_QUERY ); + + // a form should always have the command type table as default + Reference< XPropertySet > xFormProps( xForm, UNO_QUERY_THROW ); + xFormProps->setPropertyValue( FM_PROP_COMMANDTYPE, Any( sal_Int32( CommandType::TABLE ) ) ); + + // and the "Standard" name + OUString sName = SvxResId(RID_STR_STDFORMNAME); + xFormProps->setPropertyValue( FM_PROP_NAME, Any( sName ) ); + + if( rModel.IsUndoEnabled() ) + { + rModel.AddUndo( + std::make_unique<FmUndoContainerAction>( + static_cast< FmFormModel& >(rModel), + FmUndoContainerAction::Inserted, + xForms, + xForm, + xForms->getCount())); + } + xForms->insertByName( sName, Any( xForm ) ); + xCurrentForm = xForm; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + xForm.clear(); + } + + if( rModel.IsUndoEnabled() ) + rModel.EndUndo(); + } + + return xForm; +} + + +Reference< css::form::XForm > FmFormPageImpl::findPlaceInFormComponentHierarchy( + const Reference< XFormComponent > & rContent, const Reference< XDataSource > & rDatabase, + const OUString& rDBTitle, const OUString& rCursorSource, sal_Int32 nCommandType ) +{ + // if the control already is child of a form, don't do anything + if (!rContent.is() || rContent->getParent().is()) + return nullptr; + + Reference< XForm > xForm; + + // If database and CursorSource are set, the form is searched for using + // these criteria, otherwise only current and the DefaultForm. + if (rDatabase.is() && !rCursorSource.isEmpty()) + { + validateCurForm(); + + // first search in the current form + xForm = findFormForDataSource( xCurrentForm, rDatabase, rCursorSource, nCommandType ); + + Reference< css::container::XIndexAccess > xFormsByIndex = getForms(); + DBG_ASSERT(xFormsByIndex.is(), "FmFormPageImpl::findPlaceInFormComponentHierarchy : no index access for my forms collection !"); + sal_Int32 nCount = xFormsByIndex->getCount(); + for (sal_Int32 i = 0; !xForm.is() && i < nCount; i++) + { + Reference< css::form::XForm > xToSearch; + xFormsByIndex->getByIndex(i) >>= xToSearch; + xForm = findFormForDataSource( xToSearch, rDatabase, rCursorSource, nCommandType ); + } + + // If no css::form found, then create a new one + if (!xForm.is()) + { + SdrModel& rModel(m_rPage.getSdrModelFromSdrPage()); + const bool bUndo(rModel.IsUndoEnabled()); + + if( bUndo ) + { + OUString aStr(SvxResId(RID_STR_FORM)); + OUString aUndoStr(SvxResId(RID_STR_UNDO_CONTAINER_INSERT)); + aUndoStr = aUndoStr.replaceFirst("#", aStr); + rModel.BegUndo(aUndoStr); + } + + xForm.set(::comphelper::getProcessServiceFactory()->createInstance(FM_SUN_COMPONENT_FORM), UNO_QUERY); + // a form should always have the command type table as default + Reference< css::beans::XPropertySet > xFormProps(xForm, UNO_QUERY); + try { xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, Any(sal_Int32(CommandType::TABLE))); } + catch(Exception&) { } + + if (!rDBTitle.isEmpty()) + xFormProps->setPropertyValue(FM_PROP_DATASOURCE,Any(rDBTitle)); + else + { + Reference< css::beans::XPropertySet > xDatabaseProps(rDatabase, UNO_QUERY); + Any aDatabaseUrl = xDatabaseProps->getPropertyValue(FM_PROP_URL); + xFormProps->setPropertyValue(FM_PROP_URL, aDatabaseUrl); + } + + xFormProps->setPropertyValue(FM_PROP_COMMAND,Any(rCursorSource)); + xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, Any(nCommandType)); + + Reference< css::container::XNameAccess > xNamedSet = getForms(); + + const bool bTableOrQuery = ( CommandType::TABLE == nCommandType ) || ( CommandType::QUERY == nCommandType ); + OUString sName = FormControlFactory::getUniqueName( xNamedSet, + bTableOrQuery ? rCursorSource : SvxResId(RID_STR_STDFORMNAME) ); + + xFormProps->setPropertyValue( FM_PROP_NAME, Any( sName ) ); + + if( bUndo ) + { + Reference< css::container::XIndexContainer > xContainer = getForms(); + rModel.AddUndo( + std::make_unique<FmUndoContainerAction>( + static_cast< FmFormModel& >(rModel), + FmUndoContainerAction::Inserted, + xContainer, + xForm, + xContainer->getCount())); + } + + getForms()->insertByName( sName, Any( xForm ) ); + + if( bUndo ) + rModel.EndUndo(); + } + xCurrentForm = xForm; + } + + xForm = getDefaultForm(); + return xForm; +} + + +Reference< XForm > FmFormPageImpl::findFormForDataSource( + const Reference< XForm > & rForm, const Reference< XDataSource > & _rxDatabase, + const OUString& _rCursorSource, sal_Int32 nCommandType) +{ + Reference< XForm > xResultForm; + Reference< XRowSet > xDBForm(rForm, UNO_QUERY); + Reference< XPropertySet > xFormProps(rForm, UNO_QUERY); + if (!xDBForm.is() || !xFormProps.is()) + return xResultForm; + + OSL_ENSURE(_rxDatabase.is(), "FmFormPageImpl::findFormForDataSource: invalid data source!"); + OUString sLookupName; // the name of the data source we're looking for + OUString sFormDataSourceName; // the name of the data source the current connection in the form is based on + try + { + Reference< XPropertySet > xDSProps(_rxDatabase, UNO_QUERY); + if (xDSProps.is()) + xDSProps->getPropertyValue(FM_PROP_NAME) >>= sLookupName; + + xFormProps->getPropertyValue(FM_PROP_DATASOURCE) >>= sFormDataSourceName; + // if there's no DataSourceName set at the form, check whether we can deduce one from its + // ActiveConnection + if (sFormDataSourceName.isEmpty()) + { + Reference< XConnection > xFormConnection; + xFormProps->getPropertyValue( FM_PROP_ACTIVE_CONNECTION ) >>= xFormConnection; + if ( !xFormConnection.is() ) + isEmbeddedInDatabase( xFormProps, xFormConnection ); + if (xFormConnection.is()) + { + Reference< XChild > xConnAsChild(xFormConnection, UNO_QUERY); + if (xConnAsChild.is()) + { + Reference< XDataSource > xFormDS(xConnAsChild->getParent(), UNO_QUERY); + if (xFormDS.is()) + { + xDSProps.set(xFormDS, css::uno::UNO_QUERY); + if (xDSProps.is()) + xDSProps->getPropertyValue(FM_PROP_NAME) >>= sFormDataSourceName; + } + } + } + } + } + catch(const Exception&) + { + TOOLS_WARN_EXCEPTION("svx", "FmFormPageImpl::findFormForDataSource"); + } + + if (sLookupName == sFormDataSourceName) + { + // now check whether CursorSource and type match + OUString aCursorSource = ::comphelper::getString(xFormProps->getPropertyValue(FM_PROP_COMMAND)); + sal_Int32 nType = ::comphelper::getINT32(xFormProps->getPropertyValue(FM_PROP_COMMANDTYPE)); + if (aCursorSource.isEmpty() || ((nType == nCommandType) && (aCursorSource == _rCursorSource))) // found the form + { + xResultForm = rForm; + // if no data source is set yet, it is done here + if (aCursorSource.isEmpty()) + { + xFormProps->setPropertyValue(FM_PROP_COMMAND, Any(_rCursorSource)); + xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, Any(nCommandType)); + } + } + } + + // as long as xResultForm is NULL, search the child forms of rForm + Reference< XIndexAccess > xComponents(rForm, UNO_QUERY); + sal_Int32 nCount = xComponents->getCount(); + for (sal_Int32 i = 0; !xResultForm.is() && i < nCount; ++i) + { + Reference< css::form::XForm > xSearchForm; + xComponents->getByIndex(i) >>= xSearchForm; + // continue searching in the sub form + if (xSearchForm.is()) + xResultForm = findFormForDataSource( xSearchForm, _rxDatabase, _rCursorSource, nCommandType ); + } + return xResultForm; +} + + +OUString FmFormPageImpl::setUniqueName(const Reference< XFormComponent > & xFormComponent, const Reference< XForm > & xControls) +{ +#if OSL_DEBUG_LEVEL > 0 + try + { + OSL_ENSURE( !xFormComponent->getParent().is(), "FmFormPageImpl::setUniqueName: to be called before insertion!" ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +#endif + OUString sName; + Reference< css::beans::XPropertySet > xSet(xFormComponent, UNO_QUERY); + if (xSet.is()) + { + sName = ::comphelper::getString( xSet->getPropertyValue( FM_PROP_NAME ) ); + Reference< css::container::XNameAccess > xNameAcc(xControls, UNO_QUERY); + + if (sName.isEmpty() || xNameAcc->hasByName(sName)) + { + // set a default name via the ClassId + sal_Int16 nClassId( FormComponentType::CONTROL ); + xSet->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId; + + OUString sDefaultName = FormControlFactory::getDefaultUniqueName_ByComponentType( + Reference< XNameAccess >( xControls, UNO_QUERY ), xSet ); + + // do not overwrite the name of radio buttons that have it! + if (sName.isEmpty() || nClassId != css::form::FormComponentType::RADIOBUTTON) + { + xSet->setPropertyValue(FM_PROP_NAME, Any(sDefaultName)); + } + + sName = sDefaultName; + } + } + return sName; +} + + +void FmFormPageImpl::formModelAssigned( const FmFormObj& _object ) +{ + Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); + if ( !xControlShapeMap.is() ) + // our map does not exist -> not interested in this event + return; + + try + { + lcl_removeFormObject_throw( _object, xControlShapeMap ); + lcl_insertFormObject_throw( _object, xControlShapeMap ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FmFormPageImpl::formObjectInserted( const FmFormObj& _object ) +{ + Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); + if ( !xControlShapeMap.is() ) + // our map does not exist -> not interested in this event + return; + + try + { + lcl_insertFormObject_throw( _object, xControlShapeMap ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FmFormPageImpl::formObjectRemoved( const FmFormObj& _object ) +{ + Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); + if ( !xControlShapeMap.is() ) + // our map does not exist -> not interested in this event + return; + + try + { + lcl_removeFormObject_throw( _object, xControlShapeMap ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmscriptingenv.cxx b/svx/source/form/fmscriptingenv.cxx new file mode 100644 index 000000000..31de56304 --- /dev/null +++ b/svx/source/form/fmscriptingenv.cxx @@ -0,0 +1,928 @@ +/* -*- 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 <fmscriptingenv.hxx> +#include <svx/fmmodel.hxx> + +#include <com/sun/star/awt/XControl.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/lang/DisposedException.hpp> +#include <com/sun/star/lang/EventObject.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/script/XScriptListener.hpp> + +#include <tools/diagnose_ex.h> +#include <tools/debug.hxx> +#include <cppuhelper/implbase.hxx> +#include <vcl/svapp.hxx> +#include <mutex> +#include <o3tl/sorted_vector.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/app.hxx> +#include <basic/basmgr.hxx> + +#include <memory> +#include <utility> + +using std::pair; + +namespace svxform +{ + + + using ::com::sun::star::uno::Reference; + using ::com::sun::star::script::XEventAttacherManager; + using ::com::sun::star::lang::IllegalArgumentException; + using ::com::sun::star::script::XScriptListener; + using ::com::sun::star::script::ScriptEvent; + using ::com::sun::star::lang::EventObject; + using ::com::sun::star::uno::Any; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::lang::DisposedException; + using ::com::sun::star::uno::RuntimeException; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::awt::XControl; + using ::com::sun::star::beans::XPropertySet; + + //= FormScriptListener + + typedef ::cppu::WeakImplHelper < XScriptListener + > FormScriptListener_Base; + + /** implements the XScriptListener interface, is used by FormScriptingEnvironment + */ + class FormScriptListener :public FormScriptListener_Base + { + private: + std::mutex m_aMutex; + FormScriptingEnvironment *m_pScriptExecutor; + + public: + explicit FormScriptListener( FormScriptingEnvironment * pScriptExecutor ); + + // XScriptListener + virtual void SAL_CALL firing( const ScriptEvent& aEvent ) override; + virtual Any SAL_CALL approveFiring( const ScriptEvent& aEvent ) override; + // XEventListener + virtual void SAL_CALL disposing( const EventObject& Source ) override; + + // lifetime control + void dispose(); + + protected: + virtual ~FormScriptListener() override; + + private: + /** determines whether calling a given method at a given listener interface can be done asynchronously + + @param _rListenerType + the name of the UNO type whose method is to be checked + @param _rMethodName + the name of the method at the interface determined by _rListenerType + + @return + <TRUE/> if and only if the method is declared <code>oneway</code>, i.e. can be called asynchronously + */ + static bool impl_allowAsynchronousCall_nothrow( const OUString& _rListenerType, const OUString& _rMethodName ); + + /** determines whether the instance is already disposed + */ + bool impl_isDisposed_nothrow() const { return !m_pScriptExecutor; } + + /** fires the given script event in a thread-safe manner + + This methods calls our script executor's doFireScriptEvent, with previously releasing the given mutex guard, + but ensuring that our script executor is not deleted between this release and the actual call. + + @param _rGuard + a clearable guard to our mutex. Must be the only active guard to our mutex. + @param _rEvent + the event to fire + @param _pSynchronousResult + a place to take a possible result of the script call. + + @precond + m_pScriptExecutor is not <NULL/>. + */ + void impl_doFireScriptEvent_nothrow( std::unique_lock<std::mutex>& _rGuard, const ScriptEvent& _rEvent, Any* _pSynchronousResult ); + + private: + DECL_LINK( OnAsyncScriptEvent, void*, void ); + }; + + FormScriptListener::FormScriptListener( FormScriptingEnvironment* pScriptExecutor ) + :m_pScriptExecutor( pScriptExecutor ) + { + } + + + FormScriptListener::~FormScriptListener() + { + } + + + bool FormScriptListener::impl_allowAsynchronousCall_nothrow( const OUString& _rListenerType, const OUString& _rMethodName ) + { + // This used to be implemented as: + // is (_rListenerType + "::" + _rMethodName) a oneway function? + // since we got rid of the notion of oneway, this is the list + // of oneway methods, autogenerated by postprocessing of + // commitdiff 90eac3e69749a9227c4b6902b1f3cef1e338c6d1 + static const o3tl::sorted_vector<pair<OUString, OUString>> delayed_event_listeners{ + pair<OUString,OUString>("com.sun.star.accessibility.XAccessibleComponent","grabFocus"), + pair<OUString,OUString>("com.sun.star.accessibility.XAccessibleEventBroadcaster","addAccessibleEventListener"), + pair<OUString,OUString>("com.sun.star.accessibility.XAccessibleEventBroadcaster","removeAccessibleEventListener"), + pair<OUString,OUString>("com.sun.star.accessibility.XAccessibleSelection","clearAccessibleSelection"), + pair<OUString,OUString>("com.sun.star.accessibility.XAccessibleSelection","selectAllAccessibleChildren"), + pair<OUString,OUString>("com.sun.star.awt.XActionListener","actionPerformed"), + pair<OUString,OUString>("com.sun.star.awt.XActivateListener","windowActivated"), + pair<OUString,OUString>("com.sun.star.awt.XActivateListener","windowDeactivated"), + pair<OUString,OUString>("com.sun.star.awt.XAdjustmentListener","adjustmentValueChanged"), + pair<OUString,OUString>("com.sun.star.awt.XButton","addActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XButton","removeActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XButton","setLabel"), + pair<OUString,OUString>("com.sun.star.awt.XButton","setActionCommand"), + pair<OUString,OUString>("com.sun.star.awt.XCheckBox","addItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XCheckBox","removeItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XCheckBox","setState"), + pair<OUString,OUString>("com.sun.star.awt.XCheckBox","setLabel"), + pair<OUString,OUString>("com.sun.star.awt.XCheckBox","enableTriState"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","addItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","removeItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","addActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","removeActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","addItem"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","addItems"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","removeItems"), + pair<OUString,OUString>("com.sun.star.awt.XComboBox","setDropDownLineCount"), + pair<OUString,OUString>("com.sun.star.awt.XControl","setContext"), + pair<OUString,OUString>("com.sun.star.awt.XControl","createPeer"), + pair<OUString,OUString>("com.sun.star.awt.XControl","setDesignMode"), + pair<OUString,OUString>("com.sun.star.awt.XControlContainer","setStatusText"), + pair<OUString,OUString>("com.sun.star.awt.XControlContainer","addControl"), + pair<OUString,OUString>("com.sun.star.awt.XControlContainer","removeControl"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setValue"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setMin"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setMax"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setFirst"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setLast"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setSpinSize"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setDecimalDigits"), + pair<OUString,OUString>("com.sun.star.awt.XCurrencyField","setStrictFormat"), + pair<OUString,OUString>("com.sun.star.awt.XDateField","setDate"), + pair<OUString,OUString>("com.sun.star.awt.XDateField","setMin"), + pair<OUString,OUString>("com.sun.star.awt.XDateField","setMax"), + pair<OUString,OUString>("com.sun.star.awt.XDateField","setFirst"), + pair<OUString,OUString>("com.sun.star.awt.XDateField","setLast"), + pair<OUString,OUString>("com.sun.star.awt.XDateField","setLongFormat"), + pair<OUString,OUString>("com.sun.star.awt.XDateField","setStrictFormat"), + pair<OUString,OUString>("com.sun.star.awt.XDialog","setTitle"), + pair<OUString,OUString>("com.sun.star.awt.XDisplayConnection","addEventHandler"), + pair<OUString,OUString>("com.sun.star.awt.XDisplayConnection","removeEventHandler"), + pair<OUString,OUString>("com.sun.star.awt.XDisplayConnection","addErrorHandler"), + pair<OUString,OUString>("com.sun.star.awt.XDisplayConnection","removeErrorHandler"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","addTopWindowListener"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","removeTopWindowListener"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","addKeyHandler"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","removeKeyHandler"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","addFocusListener"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","removeFocusListener"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","fireFocusGained"), + pair<OUString,OUString>("com.sun.star.awt.XExtendedToolkit","fireFocusLost"), + pair<OUString,OUString>("com.sun.star.awt.XFileDialog","setPath"), + pair<OUString,OUString>("com.sun.star.awt.XFileDialog","setFilters"), + pair<OUString,OUString>("com.sun.star.awt.XFileDialog","setCurrentFilter"), + pair<OUString,OUString>("com.sun.star.awt.XFixedHyperlink","setText"), + pair<OUString,OUString>("com.sun.star.awt.XFixedHyperlink","setURL"), + pair<OUString,OUString>("com.sun.star.awt.XFixedHyperlink","setAlignment"), + pair<OUString,OUString>("com.sun.star.awt.XFixedHyperlink","addActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XFixedHyperlink","removeActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XFixedText","setText"), + pair<OUString,OUString>("com.sun.star.awt.XFixedText","setAlignment"), + pair<OUString,OUString>("com.sun.star.awt.XFocusListener","focusGained"), + pair<OUString,OUString>("com.sun.star.awt.XFocusListener","focusLost"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","setFont"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","selectFont"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","setTextColor"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","setTextFillColor"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","setLineColor"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","setFillColor"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","setRasterOp"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","setClipRegion"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","intersectClipRegion"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","push"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","pop"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","copy"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","draw"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawPixel"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawLine"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawRect"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawRoundedRect"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawPolyLine"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawPolygon"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawPolyPolygon"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawEllipse"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawArc"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawPie"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawChord"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawGradient"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawText"), + pair<OUString,OUString>("com.sun.star.awt.XGraphics","drawTextArray"), + pair<OUString,OUString>("com.sun.star.awt.XImageButton","addActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XImageButton","removeActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XImageButton","setActionCommand"), + pair<OUString,OUString>("com.sun.star.awt.XImageConsumer","init"), + pair<OUString,OUString>("com.sun.star.awt.XImageConsumer","setColorModel"), + pair<OUString,OUString>("com.sun.star.awt.XImageConsumer","setPixelsByBytes"), + pair<OUString,OUString>("com.sun.star.awt.XImageConsumer","setPixelsByLongs"), + pair<OUString,OUString>("com.sun.star.awt.XImageConsumer","complete"), + pair<OUString,OUString>("com.sun.star.awt.XImageProducer","addConsumer"), + pair<OUString,OUString>("com.sun.star.awt.XImageProducer","removeConsumer"), + pair<OUString,OUString>("com.sun.star.awt.XImageProducer","startProduction"), + pair<OUString,OUString>("com.sun.star.awt.XItemEventBroadcaster","addItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XItemEventBroadcaster","removeItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XItemListener","itemStateChanged"), + pair<OUString,OUString>("com.sun.star.awt.XKeyListener","keyPressed"), + pair<OUString,OUString>("com.sun.star.awt.XKeyListener","keyReleased"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","addItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","removeItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","addActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","removeActionListener"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","addItem"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","addItems"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","removeItems"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","selectItemPos"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","selectItemsPos"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","selectItem"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","setMultipleMode"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","setDropDownLineCount"), + pair<OUString,OUString>("com.sun.star.awt.XListBox","makeVisible"), + pair<OUString,OUString>("com.sun.star.awt.XMenu","addMenuListener"), + pair<OUString,OUString>("com.sun.star.awt.XMenu","removeMenuListener"), + pair<OUString,OUString>("com.sun.star.awt.XMenu","insertItem"), + pair<OUString,OUString>("com.sun.star.awt.XMenu","removeItem"), + pair<OUString,OUString>("com.sun.star.awt.XMenu","enableItem"), + pair<OUString,OUString>("com.sun.star.awt.XMenu","setItemText"), + pair<OUString,OUString>("com.sun.star.awt.XMenu","setPopupMenu"), + pair<OUString,OUString>("com.sun.star.awt.XMenuListener","highlight"), + pair<OUString,OUString>("com.sun.star.awt.XMenuListener","select"), + pair<OUString,OUString>("com.sun.star.awt.XMenuListener","activate"), + pair<OUString,OUString>("com.sun.star.awt.XMenuListener","deactivate"), + pair<OUString,OUString>("com.sun.star.awt.XMessageBox","setCaptionText"), + pair<OUString,OUString>("com.sun.star.awt.XMessageBox","setMessageText"), + pair<OUString,OUString>("com.sun.star.awt.XMouseListener","mousePressed"), + pair<OUString,OUString>("com.sun.star.awt.XMouseListener","mouseReleased"), + pair<OUString,OUString>("com.sun.star.awt.XMouseListener","mouseEntered"), + pair<OUString,OUString>("com.sun.star.awt.XMouseListener","mouseExited"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setValue"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setMin"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setMax"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setFirst"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setLast"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setSpinSize"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setDecimalDigits"), + pair<OUString,OUString>("com.sun.star.awt.XNumericField","setStrictFormat"), + pair<OUString,OUString>("com.sun.star.awt.XPaintListener","windowPaint"), + pair<OUString,OUString>("com.sun.star.awt.XPatternField","setMasks"), + pair<OUString,OUString>("com.sun.star.awt.XPatternField","setString"), + pair<OUString,OUString>("com.sun.star.awt.XPatternField","setStrictFormat"), + pair<OUString,OUString>("com.sun.star.awt.XPointer","setType"), + pair<OUString,OUString>("com.sun.star.awt.XPopupMenu","insertSeparator"), + pair<OUString,OUString>("com.sun.star.awt.XPopupMenu","setDefaultItem"), + pair<OUString,OUString>("com.sun.star.awt.XPopupMenu","checkItem"), + pair<OUString,OUString>("com.sun.star.awt.XProgressBar","setForegroundColor"), + pair<OUString,OUString>("com.sun.star.awt.XProgressBar","setBackgroundColor"), + pair<OUString,OUString>("com.sun.star.awt.XProgressBar","setRange"), + pair<OUString,OUString>("com.sun.star.awt.XProgressBar","setValue"), + pair<OUString,OUString>("com.sun.star.awt.XProgressMonitor","addText"), + pair<OUString,OUString>("com.sun.star.awt.XProgressMonitor","removeText"), + pair<OUString,OUString>("com.sun.star.awt.XProgressMonitor","updateText"), + pair<OUString,OUString>("com.sun.star.awt.XRadioButton","addItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XRadioButton","removeItemListener"), + pair<OUString,OUString>("com.sun.star.awt.XRadioButton","setState"), + pair<OUString,OUString>("com.sun.star.awt.XRadioButton","setLabel"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","clear"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","move"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","unionRectangle"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","intersectRectangle"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","excludeRectangle"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","xOrRectangle"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","unionRegion"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","intersectRegion"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","excludeRegion"), + pair<OUString,OUString>("com.sun.star.awt.XRegion","xOrRegion"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","addAdjustmentListener"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","removeAdjustmentListener"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","setValue"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","setValues"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","setMaximum"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","setLineIncrement"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","setBlockIncrement"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","setVisibleSize"), + pair<OUString,OUString>("com.sun.star.awt.XScrollBar","setOrientation"), + pair<OUString,OUString>("com.sun.star.awt.XSpinField","addSpinListener"), + pair<OUString,OUString>("com.sun.star.awt.XSpinField","removeSpinListener"), + pair<OUString,OUString>("com.sun.star.awt.XSpinField","up"), + pair<OUString,OUString>("com.sun.star.awt.XSpinField","down"), + pair<OUString,OUString>("com.sun.star.awt.XSpinField","first"), + pair<OUString,OUString>("com.sun.star.awt.XSpinField","last"), + pair<OUString,OUString>("com.sun.star.awt.XSpinField","enableRepeat"), + pair<OUString,OUString>("com.sun.star.awt.XSpinListener","up"), + pair<OUString,OUString>("com.sun.star.awt.XSpinListener","down"), + pair<OUString,OUString>("com.sun.star.awt.XSpinListener","first"), + pair<OUString,OUString>("com.sun.star.awt.XSpinListener","last"), + pair<OUString,OUString>("com.sun.star.awt.XSpinValue","addAdjustmentListener"), + pair<OUString,OUString>("com.sun.star.awt.XSpinValue","removeAdjustmentListener"), + pair<OUString,OUString>("com.sun.star.awt.XSpinValue","setValue"), + pair<OUString,OUString>("com.sun.star.awt.XSpinValue","setValues"), + pair<OUString,OUString>("com.sun.star.awt.XSpinValue","setMinimum"), + pair<OUString,OUString>("com.sun.star.awt.XSpinValue","setMaximum"), + pair<OUString,OUString>("com.sun.star.awt.XSpinValue","setSpinIncrement"), + pair<OUString,OUString>("com.sun.star.awt.XTabController","setModel"), + pair<OUString,OUString>("com.sun.star.awt.XTabController","setContainer"), + pair<OUString,OUString>("com.sun.star.awt.XTabController","autoTabOrder"), + pair<OUString,OUString>("com.sun.star.awt.XTabController","activateTabOrder"), + pair<OUString,OUString>("com.sun.star.awt.XTabController","activateFirst"), + pair<OUString,OUString>("com.sun.star.awt.XTabController","activateLast"), + pair<OUString,OUString>("com.sun.star.awt.XTabControllerModel","setGroupControl"), + pair<OUString,OUString>("com.sun.star.awt.XTabControllerModel","setControlModels"), + pair<OUString,OUString>("com.sun.star.awt.XTabControllerModel","setGroup"), + pair<OUString,OUString>("com.sun.star.awt.XTextComponent","addTextListener"), + pair<OUString,OUString>("com.sun.star.awt.XTextComponent","removeTextListener"), + pair<OUString,OUString>("com.sun.star.awt.XTextComponent","setText"), + pair<OUString,OUString>("com.sun.star.awt.XTextComponent","insertText"), + pair<OUString,OUString>("com.sun.star.awt.XTextComponent","setSelection"), + pair<OUString,OUString>("com.sun.star.awt.XTextComponent","setEditable"), + pair<OUString,OUString>("com.sun.star.awt.XTextComponent","setMaxTextLen"), + pair<OUString,OUString>("com.sun.star.awt.XTextEditField","setEchoChar"), + pair<OUString,OUString>("com.sun.star.awt.XTextListener","textChanged"), + pair<OUString,OUString>("com.sun.star.awt.XTimeField","setTime"), + pair<OUString,OUString>("com.sun.star.awt.XTimeField","setMin"), + pair<OUString,OUString>("com.sun.star.awt.XTimeField","setMax"), + pair<OUString,OUString>("com.sun.star.awt.XTimeField","setFirst"), + pair<OUString,OUString>("com.sun.star.awt.XTimeField","setLast"), + pair<OUString,OUString>("com.sun.star.awt.XTimeField","setStrictFormat"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindow","addTopWindowListener"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindow","removeTopWindowListener"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindow","toFront"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindow","toBack"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindow","setMenuBar"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindowListener","windowOpened"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindowListener","windowClosing"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindowListener","windowClosed"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindowListener","windowMinimized"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindowListener","windowNormalized"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindowListener","windowActivated"), + pair<OUString,OUString>("com.sun.star.awt.XTopWindowListener","windowDeactivated"), + pair<OUString,OUString>("com.sun.star.awt.XUnoControlContainer","setTabControllers"), + pair<OUString,OUString>("com.sun.star.awt.XUnoControlContainer","addTabController"), + pair<OUString,OUString>("com.sun.star.awt.XUnoControlContainer","removeTabController"), + pair<OUString,OUString>("com.sun.star.awt.XUserInputInterception","addKeyHandler"), + pair<OUString,OUString>("com.sun.star.awt.XUserInputInterception","removeKeyHandler"), + pair<OUString,OUString>("com.sun.star.awt.XUserInputInterception","addMouseClickHandler"), + pair<OUString,OUString>("com.sun.star.awt.XUserInputInterception","removeMouseClickHandler"), + pair<OUString,OUString>("com.sun.star.awt.XVclContainer","addVclContainerListener"), + pair<OUString,OUString>("com.sun.star.awt.XVclContainer","removeVclContainerListener"), + pair<OUString,OUString>("com.sun.star.awt.XVclContainerListener","windowAdded"), + pair<OUString,OUString>("com.sun.star.awt.XVclContainerListener","windowRemoved"), + pair<OUString,OUString>("com.sun.star.awt.XVclContainerPeer","enableDialogControl"), + pair<OUString,OUString>("com.sun.star.awt.XVclContainerPeer","setTabOrder"), + pair<OUString,OUString>("com.sun.star.awt.XVclContainerPeer","setGroup"), + pair<OUString,OUString>("com.sun.star.awt.XVclWindowPeer","setDesignMode"), + pair<OUString,OUString>("com.sun.star.awt.XVclWindowPeer","enableClipSiblings"), + pair<OUString,OUString>("com.sun.star.awt.XVclWindowPeer","setForeground"), + pair<OUString,OUString>("com.sun.star.awt.XVclWindowPeer","setControlFont"), + pair<OUString,OUString>("com.sun.star.awt.XView","draw"), + pair<OUString,OUString>("com.sun.star.awt.XView","setZoom"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","setPosSize"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","setVisible"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","setEnable"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","setFocus"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","addWindowListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","removeWindowListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","addFocusListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","removeFocusListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","addKeyListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","removeKeyListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","addMouseListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","removeMouseListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","addMouseMotionListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","removeMouseMotionListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","addPaintListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindow","removePaintListener"), + pair<OUString,OUString>("com.sun.star.awt.XWindowListener","windowResized"), + pair<OUString,OUString>("com.sun.star.awt.XWindowListener","windowMoved"), + pair<OUString,OUString>("com.sun.star.awt.XWindowListener","windowShown"), + pair<OUString,OUString>("com.sun.star.awt.XWindowListener","windowHidden"), + pair<OUString,OUString>("com.sun.star.awt.XWindowListener2","windowEnabled"), + pair<OUString,OUString>("com.sun.star.awt.XWindowListener2","windowDisabled"), + pair<OUString,OUString>("com.sun.star.awt.XWindowPeer","setPointer"), + pair<OUString,OUString>("com.sun.star.awt.XWindowPeer","setBackground"), + pair<OUString,OUString>("com.sun.star.awt.XWindowPeer","invalidate"), + pair<OUString,OUString>("com.sun.star.awt.XWindowPeer","invalidateRect"), + pair<OUString,OUString>("com.sun.star.awt.grid.XGridSelectionListener","selectionChanged"), + pair<OUString,OUString>("com.sun.star.awt.tab.XTabPageContainer","addTabPageContainerListener"), + pair<OUString,OUString>("com.sun.star.awt.tab.XTabPageContainer","removeTabPageContainerListener"), + pair<OUString,OUString>("com.sun.star.awt.tab.XTabPageContainerListener","tabPageActivated"), + pair<OUString,OUString>("com.sun.star.configuration.backend.XBackendChangesNotifier","addChangesListener"), + pair<OUString,OUString>("com.sun.star.configuration.backend.XBackendChangesNotifier","removeChangesListener"), + pair<OUString,OUString>("com.sun.star.datatransfer.clipboard.XClipboard","setContents"), + pair<OUString,OUString>("com.sun.star.datatransfer.clipboard.XClipboardListener","changedContents"), + pair<OUString,OUString>("com.sun.star.datatransfer.clipboard.XClipboardNotifier","addClipboardListener"), + pair<OUString,OUString>("com.sun.star.datatransfer.clipboard.XClipboardNotifier","removeClipboardListener"), + pair<OUString,OUString>("com.sun.star.datatransfer.clipboard.XClipboardOwner","lostOwnership"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XAutoscroll","autoscroll"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragGestureListener","dragGestureRecognized"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragGestureRecognizer","addDragGestureListener"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragGestureRecognizer","removeDragGestureListener"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSource","startDrag"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceContext","setCursor"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceContext","setImage"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceContext","transferablesFlavorsChanged"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceListener","dragDropEnd"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceListener","dragEnter"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceListener","dragExit"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceListener","dragOver"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDragSourceListener","dropActionChanged"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTarget","addDropTargetListener"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTarget","removeDropTargetListener"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTarget","setDefaultActions"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetDragContext","acceptDrag"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetDragContext","rejectDrag"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetDropContext","acceptDrop"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetDropContext","rejectDrop"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetDropContext","dropComplete"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetListener","dragEnter"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetListener","dragExit"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetListener","dragOver"), + pair<OUString,OUString>("com.sun.star.datatransfer.dnd.XDropTargetListener","dropActionChanged"), + pair<OUString,OUString>("com.sun.star.document.XEventBroadcaster","addEventListener"), + pair<OUString,OUString>("com.sun.star.document.XEventBroadcaster","removeEventListener"), + pair<OUString,OUString>("com.sun.star.document.XEventListener","notifyEvent"), + pair<OUString,OUString>("com.sun.star.document.XStorageChangeListener","notifyStorageChange"), + pair<OUString,OUString>("com.sun.star.drawing.XControlShape","setControl"), + pair<OUString,OUString>("com.sun.star.form.XApproveActionBroadcaster","addApproveActionListener"), + pair<OUString,OUString>("com.sun.star.form.XApproveActionBroadcaster","removeApproveActionListener"), + pair<OUString,OUString>("com.sun.star.form.XBoundControl","setLock"), + pair<OUString,OUString>("com.sun.star.form.XChangeBroadcaster","addChangeListener"), + pair<OUString,OUString>("com.sun.star.form.XChangeBroadcaster","removeChangeListener"), + pair<OUString,OUString>("com.sun.star.form.XChangeListener","changed"), + pair<OUString,OUString>("com.sun.star.form.XConfirmDeleteBroadcaster","addConfirmDeleteListener"), + pair<OUString,OUString>("com.sun.star.form.XConfirmDeleteBroadcaster","removeConfirmDeleteListener"), + pair<OUString,OUString>("com.sun.star.form.XDatabaseParameterBroadcaster","addParameterListener"), + pair<OUString,OUString>("com.sun.star.form.XDatabaseParameterBroadcaster","removeParameterListener"), + pair<OUString,OUString>("com.sun.star.form.XDatabaseParameterBroadcaster2","addDatabaseParameterListener"), + pair<OUString,OUString>("com.sun.star.form.XDatabaseParameterBroadcaster2","removeDatabaseParameterListener"), + pair<OUString,OUString>("com.sun.star.form.XErrorBroadcaster","addErrorListener"), + pair<OUString,OUString>("com.sun.star.form.XErrorBroadcaster","removeErrorListener"), + pair<OUString,OUString>("com.sun.star.form.XFormController","addActivateListener"), + pair<OUString,OUString>("com.sun.star.form.XFormController","removeActivateListener"), + pair<OUString,OUString>("com.sun.star.form.XFormControllerListener","formActivated"), + pair<OUString,OUString>("com.sun.star.form.XFormControllerListener","formDeactivated"), + pair<OUString,OUString>("com.sun.star.form.XGrid","setCurrentColumnPosition"), + pair<OUString,OUString>("com.sun.star.form.XGridPeer","setColumns"), + pair<OUString,OUString>("com.sun.star.form.XLoadListener","loaded"), + pair<OUString,OUString>("com.sun.star.form.XLoadListener","unloading"), + pair<OUString,OUString>("com.sun.star.form.XLoadListener","unloaded"), + pair<OUString,OUString>("com.sun.star.form.XLoadListener","reloading"), + pair<OUString,OUString>("com.sun.star.form.XLoadListener","reloaded"), + pair<OUString,OUString>("com.sun.star.form.XLoadable","load"), + pair<OUString,OUString>("com.sun.star.form.XLoadable","unload"), + pair<OUString,OUString>("com.sun.star.form.XLoadable","reload"), + pair<OUString,OUString>("com.sun.star.form.XLoadable","addLoadListener"), + pair<OUString,OUString>("com.sun.star.form.XLoadable","removeLoadListener"), + pair<OUString,OUString>("com.sun.star.form.XPositioningListener","positioned"), + pair<OUString,OUString>("com.sun.star.form.XReset","reset"), + pair<OUString,OUString>("com.sun.star.form.XReset","addResetListener"), + pair<OUString,OUString>("com.sun.star.form.XReset","removeResetListener"), + pair<OUString,OUString>("com.sun.star.form.XResetListener","resetted"), + pair<OUString,OUString>("com.sun.star.form.XSubmit","submit"), + pair<OUString,OUString>("com.sun.star.form.XSubmit","addSubmitListener"), + pair<OUString,OUString>("com.sun.star.form.XSubmit","removeSubmitListener"), + pair<OUString,OUString>("com.sun.star.form.XUpdateBroadcaster","addUpdateListener"), + pair<OUString,OUString>("com.sun.star.form.XUpdateBroadcaster","removeUpdateListener"), + pair<OUString,OUString>("com.sun.star.frame.XBrowseHistoryRegistry","updateViewData"), + pair<OUString,OUString>("com.sun.star.frame.XBrowseHistoryRegistry","createNewEntry"), + pair<OUString,OUString>("com.sun.star.frame.XConfigManager","addPropertyChangeListener"), + pair<OUString,OUString>("com.sun.star.frame.XConfigManager","removePropertyChangeListener"), + pair<OUString,OUString>("com.sun.star.frame.XConfigManager","flush"), + pair<OUString,OUString>("com.sun.star.frame.XDesktop","addTerminateListener"), + pair<OUString,OUString>("com.sun.star.frame.XDesktop","removeTerminateListener"), + pair<OUString,OUString>("com.sun.star.frame.XDispatch","dispatch"), + pair<OUString,OUString>("com.sun.star.frame.XDispatch","addStatusListener"), + pair<OUString,OUString>("com.sun.star.frame.XDispatch","removeStatusListener"), + pair<OUString,OUString>("com.sun.star.frame.XDocumentTemplates","update"), + pair<OUString,OUString>("com.sun.star.frame.XFrame","setCreator"), + pair<OUString,OUString>("com.sun.star.frame.XFrame","setName"), + pair<OUString,OUString>("com.sun.star.frame.XFrame","activate"), + pair<OUString,OUString>("com.sun.star.frame.XFrame","deactivate"), + pair<OUString,OUString>("com.sun.star.frame.XFrame","addFrameActionListener"), + pair<OUString,OUString>("com.sun.star.frame.XFrame","removeFrameActionListener"), + pair<OUString,OUString>("com.sun.star.frame.XFrameActionListener","frameAction"), + pair<OUString,OUString>("com.sun.star.frame.XFrameLoader","load"), + pair<OUString,OUString>("com.sun.star.frame.XFrameLoader","cancel"), + pair<OUString,OUString>("com.sun.star.frame.XLoadEventListener","loadFinished"), + pair<OUString,OUString>("com.sun.star.frame.XLoadEventListener","loadCancelled"), + pair<OUString,OUString>("com.sun.star.frame.XModel","connectController"), + pair<OUString,OUString>("com.sun.star.frame.XModel","disconnectController"), + pair<OUString,OUString>("com.sun.star.frame.XModel","lockControllers"), + pair<OUString,OUString>("com.sun.star.frame.XModel","unlockControllers"), + pair<OUString,OUString>("com.sun.star.frame.XNotifyingDispatch","dispatchWithNotification"), + pair<OUString,OUString>("com.sun.star.frame.XRecordableDispatch","dispatchAndRecord"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerClient","addSessionManagerListener"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerClient","removeSessionManagerListener"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerClient","queryInteraction"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerClient","interactionDone"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerClient","saveDone"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerListener","doSave"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerListener","approveInteraction"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerListener","shutdownCanceled"), + pair<OUString,OUString>("com.sun.star.frame.XSessionManagerListener2","doQuit"), + pair<OUString,OUString>("com.sun.star.frame.XStatusListener","statusChanged"), + pair<OUString,OUString>("com.sun.star.frame.XTask","tileWindows"), + pair<OUString,OUString>("com.sun.star.frame.XTask","arrangeWindowsVertical"), + pair<OUString,OUString>("com.sun.star.frame.XTask","arrangeWindowsHorizontal"), + pair<OUString,OUString>("com.sun.star.frame.XWindowArranger","arrange"), + pair<OUString,OUString>("com.sun.star.inspection.XPropertyControlContext","activateNextControl"), + pair<OUString,OUString>("com.sun.star.inspection.XPropertyControlObserver","focusGained"), + pair<OUString,OUString>("com.sun.star.inspection.XPropertyControlObserver","valueChanged"), + pair<OUString,OUString>("com.sun.star.mozilla.XCloseSessionListener","sessionClosed"), + pair<OUString,OUString>("com.sun.star.mozilla.XMenuProxy","addMenuProxyListener"), + pair<OUString,OUString>("com.sun.star.mozilla.XMenuProxy","removeMenuProxyListener"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstance","start"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstance","stop"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstance","destroy"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstance","createWindow"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstance","newStream"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstance","newURL"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstanceNotifySink","notifyURL"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstancePeer","showStatusMessage"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstancePeer","enableScripting"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstancePeer","newStream"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstancePeer","getURL"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginInstancePeer","postURL"), + pair<OUString,OUString>("com.sun.star.mozilla.XPluginWindowPeer","setChildWindow"), + pair<OUString,OUString>("com.sun.star.script.vba.XVBACompatibility","addVBAScriptListener"), + pair<OUString,OUString>("com.sun.star.script.vba.XVBACompatibility","removeVBAScriptListener"), + pair<OUString,OUString>("com.sun.star.sdb.XDatabaseAccess","addDatabaseAccessListener"), + pair<OUString,OUString>("com.sun.star.sdb.XDatabaseAccess","removeDatabaseAccessListener"), + pair<OUString,OUString>("com.sun.star.sdb.XDatabaseAccessListener","connectionChanged"), + pair<OUString,OUString>("com.sun.star.sdb.XDatabaseAccessListener","connectionClosing"), + pair<OUString,OUString>("com.sun.star.sdb.XRowSetApproveBroadcaster","addRowSetApproveListener"), + pair<OUString,OUString>("com.sun.star.sdb.XRowSetApproveBroadcaster","removeRowSetApproveListener"), + pair<OUString,OUString>("com.sun.star.sdb.XRowSetChangeListener","onRowSetChanged"), + pair<OUString,OUString>("com.sun.star.sdb.XRowSetSupplier","setRowSet"), + pair<OUString,OUString>("com.sun.star.sdb.XRowsChangeListener","rowsChanged"), + pair<OUString,OUString>("com.sun.star.sdb.XSQLErrorBroadcaster","addSQLErrorListener"), + pair<OUString,OUString>("com.sun.star.sdb.XSQLErrorBroadcaster","removeSQLErrorListener"), + pair<OUString,OUString>("com.sun.star.sdbc.XRowSet","addRowSetListener"), + pair<OUString,OUString>("com.sun.star.sdbc.XRowSet","removeRowSetListener"), + pair<OUString,OUString>("com.sun.star.sdbc.XRowSetListener","cursorMoved"), + pair<OUString,OUString>("com.sun.star.sdbc.XRowSetListener","rowChanged"), + pair<OUString,OUString>("com.sun.star.sdbc.XRowSetListener","rowSetChanged"), + pair<OUString,OUString>("com.sun.star.sheet.XCalculatable","enableAutomaticCalculation"), + pair<OUString,OUString>("com.sun.star.sheet.XVolatileResult","addResultListener"), + pair<OUString,OUString>("com.sun.star.sheet.XVolatileResult","removeResultListener"), + pair<OUString,OUString>("com.sun.star.task.XJobExecutor","trigger"), + pair<OUString,OUString>("com.sun.star.task.XStatusIndicator","start"), + pair<OUString,OUString>("com.sun.star.task.XStatusIndicator","end"), + pair<OUString,OUString>("com.sun.star.task.XStatusIndicator","setText"), + pair<OUString,OUString>("com.sun.star.task.XStatusIndicator","setValue"), + pair<OUString,OUString>("com.sun.star.task.XStatusIndicator","reset"), + pair<OUString,OUString>("com.sun.star.text.XSimpleText","insertString"), + pair<OUString,OUString>("com.sun.star.text.XTextCursor","collapseToStart"), + pair<OUString,OUString>("com.sun.star.text.XTextCursor","collapseToEnd"), + pair<OUString,OUString>("com.sun.star.text.XTextRange","setString"), + pair<OUString,OUString>("com.sun.star.text.XTextViewCursor","setVisible"), + pair<OUString,OUString>("com.sun.star.ucb.XCommandProcessor","abort"), + pair<OUString,OUString>("com.sun.star.ucb.XCommandProcessor2","releaseCommandIdentifier"), + pair<OUString,OUString>("com.sun.star.ucb.XContent","addContentEventListener"), + pair<OUString,OUString>("com.sun.star.ucb.XContent","removeContentEventListener"), + pair<OUString,OUString>("com.sun.star.ucb.XContentProviderManager","deregisterContentProvider"), + pair<OUString,OUString>("com.sun.star.ucb.XContentTransmitter","transmit"), + pair<OUString,OUString>("com.sun.star.ucb.XPropertySetRegistry","removePropertySet"), + pair<OUString,OUString>("com.sun.star.ui.XUIConfigurationListener","elementInserted"), + pair<OUString,OUString>("com.sun.star.ui.XUIConfigurationListener","elementRemoved"), + pair<OUString,OUString>("com.sun.star.ui.XUIConfigurationListener","elementReplaced"), + pair<OUString,OUString>("com.sun.star.ui.dialogs.XFilePickerNotifier","addFilePickerListener"), + pair<OUString,OUString>("com.sun.star.ui.dialogs.XFilePickerNotifier","removeFilePickerListener"), + pair<OUString,OUString>("com.sun.star.util.XBroadcaster","lockBroadcasts"), + pair<OUString,OUString>("com.sun.star.util.XBroadcaster","unlockBroadcasts"), + pair<OUString,OUString>("com.sun.star.util.XChangesListener","changesOccurred"), + pair<OUString,OUString>("com.sun.star.util.XChangesNotifier","addChangesListener"), + pair<OUString,OUString>("com.sun.star.util.XChangesNotifier","removeChangesListener"), + pair<OUString,OUString>("com.sun.star.util.XCloseBroadcaster","addCloseListener"), + pair<OUString,OUString>("com.sun.star.util.XCloseBroadcaster","removeCloseListener"), + pair<OUString,OUString>("com.sun.star.util.XFlushable","addFlushListener"), + pair<OUString,OUString>("com.sun.star.util.XFlushable","removeFlushListener"), + pair<OUString,OUString>("com.sun.star.util.XModeChangeListener","modeChanged"), + pair<OUString,OUString>("com.sun.star.util.XModifyBroadcaster","addModifyListener"), + pair<OUString,OUString>("com.sun.star.util.XModifyBroadcaster","removeModifyListener"), + pair<OUString,OUString>("com.sun.star.util.XRefreshable","addRefreshListener"), + pair<OUString,OUString>("com.sun.star.util.XRefreshable","removeRefreshListener"), + pair<OUString,OUString>("com.sun.star.util.XSearchDescriptor","setSearchString"), + pair<OUString,OUString>("com.sun.star.view.XPrintJobBroadcaster","addPrintJobListener"), + pair<OUString,OUString>("com.sun.star.view.XPrintJobBroadcaster","removePrintJobListener"), + pair<OUString,OUString>("com.sun.star.view.XPrintJobListener","printJobEvent"), + pair<OUString,OUString>("com.sun.star.view.XPrintableBroadcaster","addPrintableListener"), + pair<OUString,OUString>("com.sun.star.view.XPrintableBroadcaster","removePrintableListener"), + pair<OUString,OUString>("com.sun.star.view.XPrintableListener","stateChanged"), + pair<OUString,OUString>("com.sun.star.view.XSelectionChangeListener","selectionChanged"), + pair<OUString,OUString>("com.sun.star.beans.XMultiPropertySet","addPropertiesChangeListener"), + pair<OUString,OUString>("com.sun.star.beans.XMultiPropertySet","removePropertiesChangeListener"), + pair<OUString,OUString>("com.sun.star.beans.XMultiPropertySet","firePropertiesChangeEvent"), + pair<OUString,OUString>("com.sun.star.beans.XPropertiesChangeNotifier","addPropertiesChangeListener"), + pair<OUString,OUString>("com.sun.star.beans.XPropertiesChangeNotifier","removePropertiesChangeListener"), + pair<OUString,OUString>("com.sun.star.container.XContainer","addContainerListener"), + pair<OUString,OUString>("com.sun.star.container.XContainer","removeContainerListener"), + pair<OUString,OUString>("com.sun.star.container.XContainerListener","elementInserted"), + pair<OUString,OUString>("com.sun.star.container.XContainerListener","elementRemoved"), + pair<OUString,OUString>("com.sun.star.container.XContainerListener","elementReplaced"), + pair<OUString,OUString>("com.sun.star.container.XNamed","setName"), + pair<OUString,OUString>("com.sun.star.io.XDataExporter","exportData"), + pair<OUString,OUString>("com.sun.star.io.XDataExporter","cancel"), + pair<OUString,OUString>("com.sun.star.io.XDataImporter","importData"), + pair<OUString,OUString>("com.sun.star.io.XDataImporter","cancel"), + pair<OUString,OUString>("com.sun.star.io.XDataTransferEventListener","finished"), + pair<OUString,OUString>("com.sun.star.io.XDataTransferEventListener","cancelled"), + pair<OUString,OUString>("com.sun.star.lang.XConnectionPointContainer","advise"), + pair<OUString,OUString>("com.sun.star.lang.XConnectionPointContainer","unadvise"), + pair<OUString,OUString>("com.sun.star.script.XAllListener","firing"), + pair<OUString,OUString>("com.sun.star.uno.XInterface","acquire"), + pair<OUString,OUString>("com.sun.star.uno.XInterface","release"), + pair<OUString,OUString>("com.sun.star.uno.XReference","dispose")}; + + pair<OUString,OUString> k(_rListenerType, _rMethodName); + return delayed_event_listeners.find(k) != delayed_event_listeners.end(); + } + + + void FormScriptListener::impl_doFireScriptEvent_nothrow( std::unique_lock<std::mutex>& _rGuard, const ScriptEvent& _rEvent, Any* _pSynchronousResult ) + { + OSL_PRECOND( m_pScriptExecutor, "FormScriptListener::impl_doFireScriptEvent_nothrow: this will crash!" ); + + _rGuard.unlock(); + m_pScriptExecutor->doFireScriptEvent( _rEvent, _pSynchronousResult ); + } + + + void SAL_CALL FormScriptListener::firing( const ScriptEvent& _rEvent ) + { + if ( _rEvent.ScriptType == "VBAInterop" ) + return; // not handled here + + std::unique_lock aGuard( m_aMutex ); + + if ( impl_isDisposed_nothrow() ) + return; + + if ( !impl_allowAsynchronousCall_nothrow( _rEvent.ListenerType.getTypeName(), _rEvent.MethodName ) ) + { + impl_doFireScriptEvent_nothrow( aGuard, _rEvent, nullptr ); + return; + } + + acquire(); + Application::PostUserEvent( LINK( this, FormScriptListener, OnAsyncScriptEvent ), new ScriptEvent( _rEvent ) ); + } + + + Any SAL_CALL FormScriptListener::approveFiring( const ScriptEvent& _rEvent ) + { + Any aResult; + + std::unique_lock aGuard( m_aMutex ); + if ( !impl_isDisposed_nothrow() ) + impl_doFireScriptEvent_nothrow( aGuard, _rEvent, &aResult ); + + return aResult; + } + + + void SAL_CALL FormScriptListener::disposing( const EventObject& /*Source*/ ) + { + // not interested in + } + + + void FormScriptListener::dispose() + { + std::unique_lock aGuard( m_aMutex ); + m_pScriptExecutor = nullptr; + } + + IMPL_LINK( FormScriptListener, OnAsyncScriptEvent, void*, p, void ) + { + ScriptEvent* _pEvent = static_cast<ScriptEvent*>(p); + OSL_PRECOND( _pEvent != nullptr, "FormScriptListener::OnAsyncScriptEvent: invalid event!" ); + if ( !_pEvent ) + return; + + { + std::unique_lock aGuard( m_aMutex ); + + if ( !impl_isDisposed_nothrow() ) + impl_doFireScriptEvent_nothrow( aGuard, *_pEvent, nullptr ); + } + + delete _pEvent; + // we acquired ourself immediately before posting the event + release(); + } + + FormScriptingEnvironment::FormScriptingEnvironment( FmFormModel& _rModel ) + :m_rFormModel( _rModel ) + ,m_bDisposed( false ) + { + m_pScriptListener = new FormScriptListener( this ); + // note that this is a cyclic reference between the FormScriptListener and the FormScriptingEnvironment + // This cycle is broken up when our instance is disposed. + } + + void FormScriptingEnvironment::impl_registerOrRevoke_throw( const Reference< XEventAttacherManager >& _rxManager, bool _bRegister ) + { + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( !_rxManager.is() ) + throw IllegalArgumentException(); + if ( m_bDisposed ) + throw DisposedException(); + + try + { + if ( _bRegister ) + _rxManager->addScriptListener( m_pScriptListener ); + else + _rxManager->removeScriptListener( m_pScriptListener ); + } + catch( const RuntimeException& ) { throw; } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void FormScriptingEnvironment::registerEventAttacherManager( const Reference< XEventAttacherManager >& _rxManager ) + { + impl_registerOrRevoke_throw( _rxManager, true ); + } + + + void FormScriptingEnvironment::revokeEventAttacherManager( const Reference< XEventAttacherManager >& _rxManager ) + { + impl_registerOrRevoke_throw( _rxManager, false ); + } + +#if HAVE_FEATURE_SCRIPTING + namespace + { + class NewStyleUNOScript + { + SfxObjectShell& m_rObjectShell; + const OUString m_sScriptCode; + + public: + NewStyleUNOScript( SfxObjectShell& _rObjectShell, const OUString& _rScriptCode ) + :m_rObjectShell( _rObjectShell ) + ,m_sScriptCode( _rScriptCode ) + { + } + + void invoke( const Sequence< Any >& _rArguments, Any& _rSynchronousResult ); + }; + + + void NewStyleUNOScript::invoke( const Sequence< Any >& _rArguments, Any& _rSynchronousResult ) + { + Sequence< sal_Int16 > aOutArgsIndex; + Sequence< Any > aOutArgs; + EventObject aEvent; + Any aCaller; + if ( _rArguments.hasElements() && ( _rArguments[ 0 ] >>= aEvent ) ) + { + try + { + Reference< XControl > xControl( aEvent.Source, UNO_QUERY_THROW ); + Reference< XPropertySet > xProps( xControl->getModel(), UNO_QUERY_THROW ); + aCaller = xProps->getPropertyValue("Name"); + } + catch( Exception& ) {} + } + m_rObjectShell.CallXScript( m_sScriptCode, _rArguments, _rSynchronousResult, aOutArgsIndex, aOutArgs, true, aCaller.hasValue() ? &aCaller : nullptr ); + } + } +#endif + + void FormScriptingEnvironment::doFireScriptEvent( const ScriptEvent& _rEvent, Any* _pSynchronousResult ) + { +#if !HAVE_FEATURE_SCRIPTING + (void) _rEvent; + (void) _pSynchronousResult; + (void) m_rFormModel; +#else + SolarMutexClearableGuard aSolarGuard; + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + + if ( m_bDisposed ) + return; + + // SfxObjectShellRef is good here since the model controls the lifetime of the object + SfxObjectShellRef xObjectShell = m_rFormModel.GetObjectShell(); + if( !xObjectShell.is() ) + return; + + // the script to execute + std::shared_ptr< NewStyleUNOScript > pScript; + + if ( _rEvent.ScriptType != "StarBasic" ) + { + pScript = std::make_shared<NewStyleUNOScript>( *xObjectShell, _rEvent.ScriptCode ); + } + else + { + OUString sScriptCode = _rEvent.ScriptCode; + OUString sMacroLocation; + + // is there a location in the script name ("application" or "document")? + sal_Int32 nPrefixLen = sScriptCode.indexOf( ':' ); + DBG_ASSERT( 0 <= nPrefixLen, "FormScriptingEnvironment::doFireScriptEvent: Basic script name in old format encountered!" ); + + if ( 0 <= nPrefixLen ) + { + // and it has such a prefix + sMacroLocation = sScriptCode.copy( 0, nPrefixLen ); + DBG_ASSERT( sMacroLocation == "document" + || sMacroLocation == "application", + "FormScriptingEnvironment::doFireScriptEvent: invalid (unknown) prefix!" ); + + // strip the prefix: the SfxObjectShell::CallScript knows nothing about such prefixes + sScriptCode = sScriptCode.copy( nPrefixLen + 1 ); + } + + if ( sMacroLocation.isEmpty() ) + { + // legacy format: use the app-wide Basic, if it has a respective method, otherwise fall back to the doc's Basic + if ( SfxApplication::GetBasicManager()->HasMacro( sScriptCode ) ) + sMacroLocation = "application"; + else + sMacroLocation = "document"; + } + + OUString sScriptURI = "vnd.sun.star.script:" + + sScriptCode + + "?language=Basic&location=" + + sMacroLocation; + + pScript = std::make_shared<NewStyleUNOScript>( *xObjectShell, sScriptURI ); + } + + assert(pScript && "FormScriptingEnvironment::doFireScriptEvent: no script to execute!"); + + aGuard.clear(); + aSolarGuard.clear(); + + Any aIgnoreResult; + pScript->invoke( _rEvent.Arguments, _pSynchronousResult ? *_pSynchronousResult : aIgnoreResult ); + pScript.reset(); + + { + // object shells are not thread safe, so guard the destruction + SolarMutexGuard aSolarGuarsReset; + xObjectShell = nullptr; + } +#endif + } + + + void FormScriptingEnvironment::dispose() + { + ::osl::MutexGuard aGuard( m_aMutex ); + m_bDisposed = true; + m_pScriptListener->dispose(); + m_pScriptListener.clear(); + } + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmservs.cxx b/svx/source/form/fmservs.cxx new file mode 100644 index 000000000..a6c0daf5d --- /dev/null +++ b/svx/source/form/fmservs.cxx @@ -0,0 +1,74 @@ +/* -*- 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 <com/sun/star/container/XSet.hpp> +#include <cppuhelper/factory.hxx> +#include <comphelper/processfactory.hxx> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <fmservs.hxx> + +using namespace com::sun::star; + +#define REGISTER_SERVICE(ImplName, ServiceName) \ + sString = (ServiceName); \ + xSingleFactory = ::cppu::createSingleFactory(xServiceFactory, \ + OUString(), ImplName##_NewInstance_Impl, \ + uno::Sequence< OUString>(&sString, 1)); \ + if (xSingleFactory.is()) \ + xSet->insert(uno::Any(xSingleFactory)); + +namespace svxform +{ + void ImplSmartRegisterUnoServices() + { + uno::Reference< lang::XMultiServiceFactory > xServiceFactory = ::comphelper::getProcessServiceFactory(); + uno::Reference< container::XSet > xSet(xServiceFactory, uno::UNO_QUERY); + if (!xSet.is()) + return; + + uno::Reference< lang::XSingleServiceFactory > xSingleFactory; + + OUString sString; + + + // FormController + REGISTER_SERVICE( FormController, "com.sun.star.form.runtime.FormController" ); + REGISTER_SERVICE( LegacyFormController, "com.sun.star.form.FormController" ); + + + // FormController - register selfaware service + xSingleFactory = ::cppu::createSingleFactory( xServiceFactory, + OAddConditionDialog_GetImplementationName(), + OAddConditionDialog_Create, + OAddConditionDialog_GetSupportedServiceNames() + ); + if ( xSingleFactory.is() ) + xSet->insert( uno::Any( xSingleFactory ) ); + + + // DBGridControl + REGISTER_SERVICE(FmXGridControl, FM_CONTROL_GRID); // compatibility + REGISTER_SERVICE(FmXGridControl, FM_CONTROL_GRIDCONTROL); + REGISTER_SERVICE(FmXGridControl, FM_SUN_CONTROL_GRIDCONTROL); + }; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmshell.cxx b/svx/source/form/fmshell.cxx new file mode 100644 index 000000000..5ffa29917 --- /dev/null +++ b/svx/source/form/fmshell.cxx @@ -0,0 +1,1417 @@ +/* -*- 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 <fmvwimp.hxx> +#include <svx/fmshell.hxx> +#include <svx/fmtools.hxx> +#include <fmprop.hxx> +#include <fmundo.hxx> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/awt/XTabControllerModel.hpp> +#include <sfx2/viewfrm.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <svl/whiter.hxx> +#include <sfx2/app.hxx> +#include <svl/intitem.hxx> +#include <svl/stritem.hxx> +#include <svl/visitem.hxx> +#include <unotools/moduleoptions.hxx> +#include <sfx2/objface.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/svdobj.hxx> +#include <svx/fmpage.hxx> +#include <svx/svditer.hxx> + +#include <svx/svxids.hrc> + +#include <svx/svdobjkind.hxx> +#include <svl/eitem.hxx> +#include <tools/diagnose_ex.h> +#include <svx/svdpage.hxx> +#include <svx/fmmodel.hxx> +#include <fmshimp.hxx> +#include <svx/svdpagv.hxx> +#include <sfx2/objitem.hxx> +#include <sfx2/viewsh.hxx> +#include <fmexpl.hxx> +#include <formcontrolling.hxx> +#include <comphelper/types.hxx> +#include <fmdocumentclassification.hxx> +#include <formtoolbars.hxx> + +#include <svx/svxdlg.hxx> + +#include <svx/sdrobjectfilter.hxx> + +#define ShellClass_FmFormShell +#include <svxslots.hxx> + +#include <memory> + +// is used for Invalidate -> maintain it as well +// sort ascending !!!!!! +sal_uInt16 const ControllerSlotMap[] = // slots of the controller +{ + SID_FM_CONFIG, + SID_FM_PUSHBUTTON, + SID_FM_RADIOBUTTON, + SID_FM_CHECKBOX, + SID_FM_FIXEDTEXT, + SID_FM_GROUPBOX, + SID_FM_EDIT, + SID_FM_LISTBOX, + SID_FM_COMBOBOX, + SID_FM_DBGRID, + SID_FM_IMAGEBUTTON, + SID_FM_FILECONTROL, + SID_FM_NAVIGATIONBAR, + SID_FM_CTL_PROPERTIES, + SID_FM_PROPERTIES, + SID_FM_TAB_DIALOG, + SID_FM_ADD_FIELD, + SID_FM_DESIGN_MODE, + SID_FM_SHOW_FMEXPLORER, + SID_FM_SHOW_PROPERTIES, + SID_FM_FMEXPLORER_CONTROL, + SID_FM_DATEFIELD, + SID_FM_TIMEFIELD, + SID_FM_NUMERICFIELD, + SID_FM_CURRENCYFIELD, + SID_FM_PATTERNFIELD, + SID_FM_OPEN_READONLY, + SID_FM_IMAGECONTROL, + SID_FM_USE_WIZARDS, + SID_FM_FORMATTEDFIELD, + SID_FM_FILTER_NAVIGATOR, + SID_FM_AUTOCONTROLFOCUS, + SID_FM_SCROLLBAR, + SID_FM_SPINBUTTON, + SID_FM_SHOW_DATANAVIGATOR, + SID_FM_DATANAVIGATOR_CONTROL, + + 0 +}; + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::form::runtime; +using namespace ::svxform; + +FmDesignModeChangedHint::FmDesignModeChangedHint( bool bDesMode ) + :m_bDesignMode( bDesMode ) +{ +} + + +FmDesignModeChangedHint::~FmDesignModeChangedHint() +{ +} + +SFX_IMPL_INTERFACE(FmFormShell, SfxShell) + +void FmFormShell::InitInterface_Impl() +{ + GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION, SfxVisibilityFlags::Standard|SfxVisibilityFlags::ReadonlyDoc, + ToolbarId::SvxTbx_Form_Navigation, + SfxShellFeature::FormShowDatabaseBar); + + GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION, SfxVisibilityFlags::Standard|SfxVisibilityFlags::ReadonlyDoc, + ToolbarId::SvxTbx_Form_Filter, + SfxShellFeature::FormShowFilterBar); + + GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, SfxVisibilityFlags::Standard | SfxVisibilityFlags::ReadonlyDoc, + ToolbarId::SvxTbx_Text_Control_Attributes, + SfxShellFeature::FormShowTextControlBar); + + GetStaticInterface()->RegisterChildWindow(SID_FM_ADD_FIELD, false, SfxShellFeature::FormShowField); + GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_PROPERTIES, false, SfxShellFeature::FormShowProperties); + GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_FMEXPLORER, false, SfxShellFeature::FormShowExplorer); + GetStaticInterface()->RegisterChildWindow(SID_FM_FILTER_NAVIGATOR, false, SfxShellFeature::FormShowFilterNavigator); + GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_DATANAVIGATOR, false, SfxShellFeature::FormShowDataNavigator); + + GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, SfxVisibilityFlags::Standard, + ToolbarId::SvxTbx_Controls, + SfxShellFeature::FormTBControls); + + GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, SfxVisibilityFlags::Standard, + ToolbarId::SvxTbx_FormDesign, + SfxShellFeature::FormTBDesign); +} + + +FmFormShell::FmFormShell( SfxViewShell* _pParent, FmFormView* pView ) + :SfxShell(_pParent) + ,m_pImpl(new FmXFormShell(*this, _pParent->GetViewFrame())) + ,m_pFormView( pView ) + ,m_pFormModel( nullptr ) + ,m_nLastSlot( 0 ) + ,m_bDesignMode( true ) + ,m_bHasForms(false) +{ + SetPool( &SfxGetpApp()->GetPool() ); + SetName( "Form" ); + + SetView(m_pFormView); +} + + +FmFormShell::~FmFormShell() +{ + if ( m_pFormView ) + SetView( nullptr ); + + m_pImpl->dispose(); +} + + +void FmFormShell::NotifyMarkListChanged(FmFormView* pWhichView) +{ + FmNavViewMarksChanged aChangeNotification(pWhichView); + Broadcast(aChangeNotification); +} + + +bool FmFormShell::PrepareClose(bool bUI) +{ + if (GetImpl()->didPrepareClose_Lock()) + // we already made a PrepareClose for the current modifications of the current form + return true; + + bool bResult = true; + // Save the data records, not in DesignMode and FilterMode + if (!m_bDesignMode && !GetImpl()->isInFilterMode_Lock() && + m_pFormView && m_pFormView->GetActualOutDev() && + m_pFormView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW) + { + SdrPageView* pCurPageView = m_pFormView->GetSdrPageView(); + + // sal_uInt16 nPos = pCurPageView ? pCurPageView->GetWinList().Find((OutputDevice*)m_pFormView->GetActualOutDev()) : SDRPAGEVIEWWIN_NOTFOUND; + SdrPageWindow* pWindow = pCurPageView ? pCurPageView->FindPageWindow(*const_cast<OutputDevice*>(m_pFormView->GetActualOutDev())) : nullptr; + + if(pWindow) + { + // First, the current contents of the controls are stored. + // If everything has gone smoothly, the modified records are stored. + if (GetImpl()->getActiveController_Lock().is()) + { + const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures_Lock(); + if ( rController->commitCurrentControl() ) + { + const bool bModified = rController->isModifiedRow(); + + if ( bModified && bUI ) + { + SfxViewShell* pShell = GetViewShell(); + vcl::Window* pShellWnd = pShell ? pShell->GetWindow() : nullptr; + weld::Widget* pFrameWeld = pShellWnd ? pShellWnd->GetFrameWeld() : nullptr; + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pFrameWeld, "svx/ui/savemodifieddialog.ui")); + std::unique_ptr<weld::MessageDialog> xQry(xBuilder->weld_message_dialog("SaveModifiedDialog")); + switch (xQry->run()) + { + case RET_YES: + bResult = rController->commitCurrentRecord( ); + [[fallthrough]]; + case RET_NO: + GetImpl()->didPrepareClose_Lock(true); + break; + + case RET_CANCEL: + return false; + } + } + } + } + } + } + return bResult; +} + + +void FmFormShell::impl_setDesignMode(bool bDesign) +{ + if (m_pFormView) + { + if (!bDesign) + m_nLastSlot = SID_FM_DESIGN_MODE; + + GetImpl()->SetDesignMode_Lock(bDesign); + // my m_bDesignMode is also set by the Impl ... + } + else + { + m_bHasForms = false; + m_bDesignMode = bDesign; + UIFeatureChanged(); + } + + GetViewShell()->GetViewFrame()->GetBindings().Invalidate(ControllerSlotMap); +} + + +bool FmFormShell::HasUIFeature(SfxShellFeature nFeature) const +{ + assert((nFeature & ~SfxShellFeature::FormMask) == SfxShellFeature::NONE); + bool bResult = false; + if (nFeature & SfxShellFeature::FormShowDatabaseBar) + { + // only if forms are also available + bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && !GetImpl()->isInFilterMode_Lock(); + } + else if (nFeature & SfxShellFeature::FormShowFilterBar) + { + // only if forms are also available + bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && GetImpl()->isInFilterMode_Lock(); + } + else if (nFeature & SfxShellFeature::FormShowFilterNavigator) + { + bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && GetImpl()->isInFilterMode_Lock(); + } + else if (nFeature & SfxShellFeature::FormShowField) + { + bResult = m_bDesignMode && m_pFormView && m_bHasForms; + } + else if (nFeature & SfxShellFeature::FormShowProperties) + { + bResult = m_bDesignMode && m_pFormView && m_bHasForms; + } + else if (nFeature & SfxShellFeature::FormShowExplorer) + { + bResult = m_bDesignMode; // OJ #101593# && m_pFormView && m_bHasForms; + } + else if (nFeature & SfxShellFeature::FormShowTextControlBar) + { + bResult = !GetImpl()->IsReadonlyDoc_Lock() && m_pImpl->IsActiveControl_Lock(true); + } + else if (nFeature & SfxShellFeature::FormShowDataNavigator) + { + bResult = GetImpl()->isEnhancedForm_Lock(); + } + else if ( (nFeature & SfxShellFeature::FormTBControls) + || (nFeature & SfxShellFeature::FormTBDesign) + ) + { + bResult = true; + } + + return bResult; +} + + +void FmFormShell::Execute(SfxRequest &rReq) +{ + sal_uInt16 nSlot = rReq.GetSlot(); + + + // set MasterSlot + switch( nSlot ) + { + case SID_FM_PUSHBUTTON: + case SID_FM_RADIOBUTTON: + case SID_FM_CHECKBOX: + case SID_FM_FIXEDTEXT: + case SID_FM_GROUPBOX: + case SID_FM_LISTBOX: + case SID_FM_COMBOBOX: + case SID_FM_NAVIGATIONBAR: + case SID_FM_EDIT: + case SID_FM_DBGRID: + case SID_FM_IMAGEBUTTON: + case SID_FM_IMAGECONTROL: + case SID_FM_FILECONTROL: + case SID_FM_DATEFIELD: + case SID_FM_TIMEFIELD: + case SID_FM_NUMERICFIELD: + case SID_FM_CURRENCYFIELD: + case SID_FM_PATTERNFIELD: + case SID_FM_FORMATTEDFIELD: + case SID_FM_SCROLLBAR: + case SID_FM_SPINBUTTON: + m_nLastSlot = nSlot; + break; + } + + + // set the Identifier and Inventor of the Uno control + SdrObjKind nIdentifier = SdrObjKind::NONE; + switch( nSlot ) + { + case SID_FM_CHECKBOX: + nIdentifier = SdrObjKind::FormCheckbox; + break; + case SID_FM_PUSHBUTTON: + nIdentifier = SdrObjKind::FormButton; + break; + case SID_FM_FIXEDTEXT: + nIdentifier = SdrObjKind::FormFixedText; + break; + case SID_FM_LISTBOX: + nIdentifier = SdrObjKind::FormListbox; + break; + case SID_FM_EDIT: + nIdentifier = SdrObjKind::FormEdit; + break; + case SID_FM_RADIOBUTTON: + nIdentifier = SdrObjKind::FormRadioButton; + break; + case SID_FM_GROUPBOX: + nIdentifier = SdrObjKind::FormGroupBox; + break; + case SID_FM_COMBOBOX: + nIdentifier = SdrObjKind::FormCombobox; + break; + case SID_FM_NAVIGATIONBAR: + nIdentifier = SdrObjKind::FormNavigationBar; + break; + case SID_FM_DBGRID: + nIdentifier = SdrObjKind::FormGrid; + break; + case SID_FM_IMAGEBUTTON: + nIdentifier = SdrObjKind::FormImageButton; + break; + case SID_FM_IMAGECONTROL: + nIdentifier = SdrObjKind::FormImageControl; + break; + case SID_FM_FILECONTROL: + nIdentifier = SdrObjKind::FormFileControl; + break; + case SID_FM_DATEFIELD: + nIdentifier = SdrObjKind::FormDateField; + break; + case SID_FM_TIMEFIELD: + nIdentifier = SdrObjKind::FormTimeField; + break; + case SID_FM_NUMERICFIELD: + nIdentifier = SdrObjKind::FormNumericField; + break; + case SID_FM_CURRENCYFIELD: + nIdentifier = SdrObjKind::FormCurrencyField; + break; + case SID_FM_PATTERNFIELD: + nIdentifier = SdrObjKind::FormPatternField; + break; + case SID_FM_FORMATTEDFIELD: + nIdentifier = SdrObjKind::FormFormattedField; + break; + case SID_FM_SCROLLBAR: + nIdentifier = SdrObjKind::FormScrollbar; + break; + case SID_FM_SPINBUTTON: + nIdentifier = SdrObjKind::FormSpinButton; + break; + } + + switch ( nSlot ) + { + case SID_FM_CHECKBOX: + case SID_FM_PUSHBUTTON: + case SID_FM_FIXEDTEXT: + case SID_FM_LISTBOX: + case SID_FM_EDIT: + case SID_FM_RADIOBUTTON: + case SID_FM_COMBOBOX: + case SID_FM_NAVIGATIONBAR: + case SID_FM_GROUPBOX: + case SID_FM_DBGRID: + case SID_FM_IMAGEBUTTON: + case SID_FM_IMAGECONTROL: + case SID_FM_FILECONTROL: + case SID_FM_DATEFIELD: + case SID_FM_TIMEFIELD: + case SID_FM_NUMERICFIELD: + case SID_FM_CURRENCYFIELD: + case SID_FM_PATTERNFIELD: + case SID_FM_FORMATTEDFIELD: + case SID_FM_SCROLLBAR: + case SID_FM_SPINBUTTON: + { + const SfxBoolItem* pGrabFocusItem = rReq.GetArg<SfxBoolItem>(SID_FM_TOGGLECONTROLFOCUS); + if ( pGrabFocusItem && pGrabFocusItem->GetValue() ) + { // see below + SfxViewShell* pShell = GetViewShell(); + vcl::Window* pShellWnd = pShell ? pShell->GetWindow() : nullptr; + if ( pShellWnd ) + pShellWnd->GrabFocus(); + break; + } + + SfxUInt16Item aIdentifierItem( SID_FM_CONTROL_IDENTIFIER, static_cast<sal_uInt16>(nIdentifier) ); + SfxUInt32Item aInventorItem( SID_FM_CONTROL_INVENTOR, sal_uInt32(SdrInventor::FmForm) ); + const SfxPoolItem* pArgs[] = + { + &aIdentifierItem, &aInventorItem, nullptr + }; + const SfxPoolItem* pInternalArgs[] = + { + nullptr + }; + + GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_CREATE_CONTROL, SfxCallMode::ASYNCHRON, + pArgs, rReq.GetModifier(), pInternalArgs ); + + if ( rReq.GetModifier() & KEY_MOD1 ) + { + // #99013# if selected with control key, return focus to current view + // do this asynchron, so that the creation can be finished first + // reusing the SID_FM_TOGGLECONTROLFOCUS is somewhat hacky... which it wouldn't if it would have another + // name, so I do not really have a big problem with this... + SfxBoolItem aGrabFocusIndicatorItem( SID_FM_TOGGLECONTROLFOCUS, true ); + GetViewShell()->GetViewFrame()->GetDispatcher()->ExecuteList( + nSlot, SfxCallMode::ASYNCHRON, + { &aGrabFocusIndicatorItem }); + } + + rReq.Done(); + } break; + } + + // individual actions + switch( nSlot ) + { + case SID_FM_FORM_DESIGN_TOOLS: + { + FormToolboxes aToolboxAccess(GetImpl()->getHostFrame_Lock()); + aToolboxAccess.toggleToolbox( nSlot ); + rReq.Done(); + } + break; + + case SID_FM_TOGGLECONTROLFOCUS: + { + FmFormView* pFormView = GetFormView(); + if ( !pFormView ) + break; + + // if we execute this ourself, then either the application does not implement an own handling for this, + // of we're on the top of the dispatcher stack, which means a control has the focus. + // In the latter case, we put the focus to the document window, otherwise, we focus the first control + const bool bHasControlFocus = GetImpl()->HasControlFocus_Lock(); + if ( bHasControlFocus ) + { + if (m_pFormView) + { + const OutputDevice* pDevice = m_pFormView->GetActualOutDev(); + vcl::Window* pWindow = pDevice->GetOwnerWindow(); + if ( pWindow ) + pWindow->GrabFocus(); + } + } + else + { + pFormView->GrabFirstControlFocus( ); + } + } + break; + + case SID_FM_VIEW_AS_GRID: + GetImpl()->CreateExternalView_Lock(); + break; + case SID_FM_CONVERTTO_EDIT : + case SID_FM_CONVERTTO_BUTTON : + case SID_FM_CONVERTTO_FIXEDTEXT : + case SID_FM_CONVERTTO_LISTBOX : + case SID_FM_CONVERTTO_CHECKBOX : + case SID_FM_CONVERTTO_RADIOBUTTON : + case SID_FM_CONVERTTO_GROUPBOX : + case SID_FM_CONVERTTO_COMBOBOX : + case SID_FM_CONVERTTO_IMAGEBUTTON : + case SID_FM_CONVERTTO_FILECONTROL : + case SID_FM_CONVERTTO_DATE : + case SID_FM_CONVERTTO_TIME : + case SID_FM_CONVERTTO_NUMERIC : + case SID_FM_CONVERTTO_CURRENCY : + case SID_FM_CONVERTTO_PATTERN : + case SID_FM_CONVERTTO_IMAGECONTROL : + case SID_FM_CONVERTTO_FORMATTED : + case SID_FM_CONVERTTO_SCROLLBAR : + case SID_FM_CONVERTTO_SPINBUTTON : + case SID_FM_CONVERTTO_NAVIGATIONBAR : + GetImpl()->executeControlConversionSlot_Lock(FmXFormShell::SlotToIdent(nSlot)); + // after the conversion, re-determine the selection, since the + // selected object has changed + GetImpl()->SetSelection_Lock(GetFormView()->GetMarkedObjectList()); + break; + case SID_FM_LEAVE_CREATE: + m_nLastSlot = 0; + rReq.Done(); + break; + case SID_FM_SHOW_PROPERTY_BROWSER: + { + const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(SID_FM_SHOW_PROPERTIES); + bool bShow = true; + if ( pShowItem ) + bShow = pShowItem->GetValue(); + GetImpl()->ShowSelectionProperties_Lock(bShow); + + rReq.Done(); + } break; + + case SID_FM_PROPERTIES: + { + // display the PropertyBrowser + const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(nSlot); + bool bShow = pShowItem == nullptr || pShowItem->GetValue(); + + InterfaceBag aOnlyTheForm; + aOnlyTheForm.insert(Reference<XInterface>(GetImpl()->getCurrentForm_Lock(), UNO_QUERY)); + GetImpl()->setCurrentSelection_Lock(std::move(aOnlyTheForm)); + + GetImpl()->ShowSelectionProperties_Lock(bShow); + + rReq.Done(); + } break; + + case SID_FM_CTL_PROPERTIES: + { + const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(nSlot); + bool bShow = pShowItem == nullptr || pShowItem->GetValue(); + + OSL_ENSURE( GetImpl()->onlyControlsAreMarked_Lock(), "FmFormShell::Execute: ControlProperties should be disabled!" ); + if ( bShow ) + GetImpl()->selectLastMarkedControls_Lock(); + GetImpl()->ShowSelectionProperties_Lock(bShow); + + rReq.Done(); + } break; + case SID_FM_SHOW_PROPERTIES: + case SID_FM_ADD_FIELD: + case SID_FM_FILTER_NAVIGATOR: + case SID_FM_SHOW_DATANAVIGATOR : + { + GetViewShell()->GetViewFrame()->ToggleChildWindow(nSlot); + rReq.Done(); + } break; + case SID_FM_SHOW_FMEXPLORER: + { + if (!m_pFormView) // force setting the view + GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_CREATE_SW_DRAWVIEW); + + GetViewShell()->GetViewFrame()->ChildWindowExecute(rReq); + rReq.Done(); + } + break; + + case SID_FM_TAB_DIALOG: + { + GetImpl()->ExecuteTabOrderDialog_Lock( + Reference<XTabControllerModel>(GetImpl()->getCurrentForm_Lock(), UNO_QUERY)); + rReq.Done(); + } + break; + + case SID_FM_DESIGN_MODE: + { + const SfxBoolItem* pDesignItem = rReq.GetArg<SfxBoolItem>(nSlot); + bool bDesignMode = pDesignItem ? pDesignItem->GetValue() : !m_bDesignMode; + SetDesignMode( bDesignMode ); + if ( m_bDesignMode == bDesignMode ) + rReq.Done(); + + m_nLastSlot = SID_FM_DESIGN_MODE; + } + break; + + case SID_FM_AUTOCONTROLFOCUS: + { + FmFormModel* pModel = GetFormModel(); + DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !"); + // should have been disabled in GetState if we don't have a FormModel + pModel->SetAutoControlFocus( !pModel->GetAutoControlFocus() ); + GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_AUTOCONTROLFOCUS); + } + break; + case SID_FM_OPEN_READONLY: + { + FmFormModel* pModel = GetFormModel(); + DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !"); + // should have been disabled in GetState if we don't have a FormModel + pModel->SetOpenInDesignMode( !pModel->GetOpenInDesignMode() ); + GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_OPEN_READONLY); + } + break; + case SID_FM_USE_WIZARDS: + { + GetImpl()->SetWizardUsing_Lock(!GetImpl()->GetWizardUsing_Lock()); + GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_USE_WIZARDS); + } + break; + case SID_FM_SEARCH: + { + const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures_Lock(); + if ( rController->commitCurrentControl() && rController->commitCurrentRecord() ) + GetImpl()->ExecuteSearch_Lock(); + rReq.Done(); + } + break; + + case SID_FM_RECORD_FIRST: + case SID_FM_RECORD_PREV: + case SID_FM_RECORD_NEXT: + case SID_FM_RECORD_LAST: + case SID_FM_RECORD_NEW: + case SID_FM_REFRESH: + case SID_FM_REFRESH_FORM_CONTROL: + case SID_FM_RECORD_DELETE: + case SID_FM_RECORD_UNDO: + case SID_FM_RECORD_SAVE: + case SID_FM_REMOVE_FILTER_SORT: + case SID_FM_SORTDOWN: + case SID_FM_SORTUP: + case SID_FM_AUTOFILTER: + case SID_FM_ORDERCRIT: + case SID_FM_FORM_FILTERED: + { + GetImpl()->ExecuteFormSlot_Lock(nSlot); + rReq.Done(); + } + break; + + case SID_FM_RECORD_ABSOLUTE: + { + const svx::ControllerFeatures& rController = GetImpl()->getNavControllerFeatures_Lock(); + sal_Int32 nRecord = -1; + + const SfxItemSet* pArgs = rReq.GetArgs(); + if ( pArgs ) + { + const SfxPoolItem* pItem; + if ( ( pArgs->GetItemState( FN_PARAM_1, true, &pItem ) ) == SfxItemState::SET ) + { + const SfxInt32Item* pTypedItem = dynamic_cast<const SfxInt32Item* >( pItem ); + if ( pTypedItem ) + nRecord = std::max( pTypedItem->GetValue(), sal_Int32(0) ); + } + } + else + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractFmInputRecordNoDialog> dlg(pFact->CreateFmInputRecordNoDialog(rReq.GetFrameWeld())); + dlg->SetValue( rController->getCursor()->getRow() ); + if ( dlg->Execute() == RET_OK ) + nRecord = dlg->GetValue(); + + rReq.AppendItem( SfxInt32Item( FN_PARAM_1, nRecord ) ); + } + + if ( nRecord != -1 ) + rController->execute( nSlot, "Position", Any( nRecord ) ); + + rReq.Done(); + } break; + case SID_FM_FILTER_EXECUTE: + case SID_FM_FILTER_EXIT: + { + bool bCancelled = ( SID_FM_FILTER_EXIT == nSlot ); + bool bReopenNavigator = false; + + if ( !bCancelled ) + { + // if the filter navigator is still open, we need to close it, so it can possibly + // commit it's most recent changes + if ( GetViewShell() && GetViewShell()->GetViewFrame() ) + if ( GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR ) ) + { + GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR ); + bReopenNavigator = true; + } + + Reference<runtime::XFormController> const xController(GetImpl()->getActiveController_Lock()); + + if ( GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR ) + // closing the window was denied, for instance because of an invalid criterion + + || ( xController.is() + && !GetImpl()->getActiveControllerFeatures_Lock()->commitCurrentControl() + ) + // committing the controller was denied + ) + { + rReq.Done(); + break; + } + } + + GetImpl()->stopFiltering_Lock(!bCancelled); + rReq.Done(); + + if ( bReopenNavigator ) + // we closed the navigator only to implicitly commit it (as we do not have another + // direct wire to it), but to the user, it should look as it was always open + GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR ); + } + break; + + case SID_FM_FILTER_START: + { + GetImpl()->startFiltering_Lock(); + rReq.Done(); + + // initially open the filter navigator, the whole form based filter is pretty useless without it + SfxBoolItem aIdentifierItem( SID_FM_FILTER_NAVIGATOR, true ); + GetViewShell()->GetViewFrame()->GetDispatcher()->ExecuteList( + SID_FM_FILTER_NAVIGATOR, SfxCallMode::ASYNCHRON, + { &aIdentifierItem }); + } break; + } +} + + +void FmFormShell::GetState(SfxItemSet &rSet) +{ + SfxWhichIter aIter( rSet ); + sal_uInt16 nWhich = aIter.FirstWhich(); + while ( nWhich ) + { + switch( nWhich ) + { + case SID_FM_FORM_DESIGN_TOOLS: + { + FormToolboxes aToolboxAccess(GetImpl()->getHostFrame_Lock()); + rSet.Put( SfxBoolItem( nWhich, aToolboxAccess.isToolboxVisible( nWhich ) ) ); + } + break; + + case SID_FM_FILTER_EXECUTE: + case SID_FM_FILTER_EXIT: + if (!GetImpl()->isInFilterMode_Lock()) + rSet.DisableItem( nWhich ); + break; + + case SID_FM_USE_WIZARDS: + if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) ) + rSet.Put( SfxVisibilityItem( nWhich, false ) ); + else if (!GetFormModel()) + rSet.DisableItem( nWhich ); + else + rSet.Put(SfxBoolItem(nWhich, GetImpl()->GetWizardUsing_Lock())); + break; + case SID_FM_AUTOCONTROLFOCUS: + if (!GetFormModel()) + rSet.DisableItem( nWhich ); + else + rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetAutoControlFocus() ) ); + break; + case SID_FM_OPEN_READONLY: + if (!GetFormModel()) + rSet.DisableItem( nWhich ); + else + rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetOpenInDesignMode() ) ); + break; + + case SID_FM_NAVIGATIONBAR: + case SID_FM_DBGRID: + if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) ) + { + rSet.Put( SfxVisibilityItem( nWhich, false ) ); + break; + } + [[fallthrough]]; + + case SID_FM_SCROLLBAR: + case SID_FM_IMAGECONTROL: + case SID_FM_FILECONTROL: + case SID_FM_CURRENCYFIELD: + case SID_FM_PATTERNFIELD: + case SID_FM_IMAGEBUTTON: + case SID_FM_RADIOBUTTON: + case SID_FM_COMBOBOX: + case SID_FM_GROUPBOX: + case SID_FM_CHECKBOX: + case SID_FM_PUSHBUTTON: + case SID_FM_FIXEDTEXT: + case SID_FM_LISTBOX: + case SID_FM_EDIT: + case SID_FM_DATEFIELD: + case SID_FM_TIMEFIELD: + case SID_FM_NUMERICFIELD: + case SID_FM_FORMATTEDFIELD: + case SID_FM_SPINBUTTON: + if (!m_bDesignMode) + rSet.DisableItem( nWhich ); + else + { + bool bLayerLocked = false; + if (m_pFormView) + { + // If the css::drawing::Layer is locked, the slots must be disabled. #36897 + SdrPageView* pPV = m_pFormView->GetSdrPageView(); + if (pPV != nullptr) + bLayerLocked = pPV->IsLayerLocked(m_pFormView->GetActiveLayer()); + } + if (bLayerLocked) + rSet.DisableItem( nWhich ); + else + rSet.Put( SfxBoolItem(nWhich, (nWhich==m_nLastSlot)) ); + } + break; + case SID_FM_FILTER_NAVIGATOR_CONTROL: + { + if (GetImpl()->isInFilterMode_Lock()) + rSet.Put(SfxObjectItem(nWhich, this)); + else + rSet.Put(SfxObjectItem(nWhich)); + } break; + case SID_FM_FIELDS_CONTROL: + case SID_FM_PROPERTY_CONTROL: + { + if (!m_bDesignMode || !m_pFormView || !m_bHasForms) + rSet.Put(SfxObjectItem(nWhich)); + else + rSet.Put(SfxObjectItem(nWhich, this)); + + } break; + case SID_FM_FMEXPLORER_CONTROL: + case SID_FM_DATANAVIGATOR_CONTROL : + { + if (!m_bDesignMode || !m_pFormView) + rSet.Put(SfxObjectItem(nWhich)); + else + rSet.Put(SfxObjectItem(nWhich, this)); + + } break; + case SID_FM_ADD_FIELD: + case SID_FM_SHOW_FMEXPLORER: + case SID_FM_SHOW_PROPERTIES: + case SID_FM_FILTER_NAVIGATOR: + case SID_FM_SHOW_DATANAVIGATOR: + { + if ( GetViewShell()->GetViewFrame()->KnowsChildWindow(nWhich) ) + rSet.Put( SfxBoolItem( nWhich, GetViewShell()->GetViewFrame()->HasChildWindow(nWhich)) ); + else + rSet.DisableItem(nWhich); + } break; + + case SID_FM_SHOW_PROPERTY_BROWSER: + { + rSet.Put(SfxBoolItem(nWhich, GetImpl()->IsPropBrwOpen_Lock())); + } + break; + + case SID_FM_CTL_PROPERTIES: + { + // potentially, give the Impl the opportunity to update its + // current objects which are aligned with the current MarkList + if (GetImpl()->IsSelectionUpdatePending_Lock()) + GetImpl()->ForceUpdateSelection_Lock(); + + if (!m_pFormView || !m_bDesignMode || !GetImpl()->onlyControlsAreMarked_Lock()) + rSet.DisableItem( nWhich ); + else + { + bool const bChecked = GetImpl()->IsPropBrwOpen_Lock() && !GetImpl()->isSolelySelected_Lock(GetImpl()->getCurrentForm_Lock()); + // if the property browser is open, and only controls are marked, and the current selection + // does not consist of only the current form, then the current selection is the (composition of) + // the currently marked controls + rSet.Put( SfxBoolItem( nWhich, bChecked ) ); + } + } break; + + case SID_FM_PROPERTIES: + { + // potentially, give the Impl the opportunity to update its + // current objects which are aligned with the current MarkList + if (GetImpl()->IsSelectionUpdatePending_Lock()) + GetImpl()->ForceUpdateSelection_Lock(); + + if (!m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm_Lock().is()) + rSet.DisableItem( nWhich ); + else + { + bool const bChecked = GetImpl()->IsPropBrwOpen_Lock() && GetImpl()->isSolelySelected_Lock(GetImpl()->getCurrentForm_Lock()); + rSet.Put(SfxBoolItem(nWhich, bChecked)); + } + } break; + case SID_FM_TAB_DIALOG: + // potentially, give the Impl the opportunity to update its + // current objects which are aligned with the current MarkList + if (GetImpl()->IsSelectionUpdatePending_Lock()) + GetImpl()->ForceUpdateSelection_Lock(); + + if (!m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm_Lock().is() ) + rSet.DisableItem( nWhich ); + break; + case SID_FM_DESIGN_MODE: + if (!m_pFormView || GetImpl()->IsReadonlyDoc_Lock()) + rSet.DisableItem( nWhich ); + else + rSet.Put( SfxBoolItem(nWhich, m_bDesignMode) ); + break; + case SID_FM_SEARCH: + case SID_FM_RECORD_FIRST: + case SID_FM_RECORD_NEXT: + case SID_FM_RECORD_PREV: + case SID_FM_RECORD_LAST: + case SID_FM_RECORD_NEW: + case SID_FM_RECORD_DELETE: + case SID_FM_RECORD_ABSOLUTE: + case SID_FM_RECORD_TOTAL: + case SID_FM_RECORD_SAVE: + case SID_FM_RECORD_UNDO: + case SID_FM_FORM_FILTERED: + case SID_FM_REMOVE_FILTER_SORT: + case SID_FM_SORTUP: + case SID_FM_SORTDOWN: + case SID_FM_ORDERCRIT: + case SID_FM_FILTER_START: + case SID_FM_AUTOFILTER: + case SID_FM_REFRESH: + case SID_FM_REFRESH_FORM_CONTROL: + case SID_FM_VIEW_AS_GRID: + GetFormState(rSet,nWhich); + break; + + case SID_FM_CHANGECONTROLTYPE: + { + if ( !m_pFormView || !m_bDesignMode ) + rSet.DisableItem( nWhich ); + else + { + if (!GetImpl()->canConvertCurrentSelectionToControl_Lock("ConvertToFixed")) + // if it cannot be converted to a fixed text, it is no single control + rSet.DisableItem( nWhich ); + } + } break; + + case SID_FM_CONVERTTO_FILECONTROL : + case SID_FM_CONVERTTO_CURRENCY : + case SID_FM_CONVERTTO_PATTERN : + case SID_FM_CONVERTTO_IMAGECONTROL : + case SID_FM_CONVERTTO_SCROLLBAR : + case SID_FM_CONVERTTO_NAVIGATIONBAR : + case SID_FM_CONVERTTO_IMAGEBUTTON : + case SID_FM_CONVERTTO_EDIT : + case SID_FM_CONVERTTO_BUTTON : + case SID_FM_CONVERTTO_FIXEDTEXT : + case SID_FM_CONVERTTO_LISTBOX : + case SID_FM_CONVERTTO_CHECKBOX : + case SID_FM_CONVERTTO_RADIOBUTTON : + case SID_FM_CONVERTTO_GROUPBOX : + case SID_FM_CONVERTTO_COMBOBOX : + case SID_FM_CONVERTTO_DATE : + case SID_FM_CONVERTTO_TIME : + case SID_FM_CONVERTTO_NUMERIC : + case SID_FM_CONVERTTO_FORMATTED : + case SID_FM_CONVERTTO_SPINBUTTON : + { + if (!m_pFormView || !m_bDesignMode || !GetImpl()->canConvertCurrentSelectionToControl_Lock(FmXFormShell::SlotToIdent(nWhich))) + rSet.DisableItem( nWhich ); + else + { + rSet.Put( SfxBoolItem( nWhich, false ) ); + // just to have a defined state (available and not checked) + } + } + break; + } + nWhich = aIter.NextWhich(); + } +} + + +void FmFormShell::GetFormState(SfxItemSet &rSet, sal_uInt16 nWhich) +{ + if ( !GetImpl()->getNavController_Lock().is() + || !isRowSetAlive(GetImpl()->getNavController_Lock()->getModel()) + || !m_pFormView + || m_bDesignMode + || !GetImpl()->getActiveForm_Lock().is() + || GetImpl()->isInFilterMode_Lock() + ) + rSet.DisableItem(nWhich); + else + { + bool bEnable = false; + try + { + switch (nWhich) + { + case SID_FM_VIEW_AS_GRID: + if (GetImpl()->getHostFrame_Lock().is() && GetImpl()->getNavController_Lock().is()) + { + bEnable = true; + bool bDisplayingCurrent = + GetImpl()->getInternalForm_Lock( + Reference<XForm>(GetImpl()->getNavController_Lock()->getModel(), UNO_QUERY) + ) == GetImpl()->getExternallyDisplayedForm_Lock(); + rSet.Put(SfxBoolItem(nWhich, bDisplayingCurrent)); + } + break; + + case SID_FM_SEARCH: + { + Reference<css::beans::XPropertySet> const xNavSet(GetImpl()->getActiveForm_Lock(), UNO_QUERY); + sal_Int32 nCount = ::comphelper::getINT32(xNavSet->getPropertyValue(FM_PROP_ROWCOUNT)); + bEnable = nCount != 0; + } break; + case SID_FM_RECORD_ABSOLUTE: + case SID_FM_RECORD_TOTAL: + { + FeatureState aState; + GetImpl()->getNavControllerFeatures_Lock()->getState( nWhich, aState ); + if ( SID_FM_RECORD_ABSOLUTE == nWhich ) + { + sal_Int32 nPosition = 0; + aState.State >>= nPosition; + rSet.Put( SfxInt32Item( nWhich, nPosition ) ); + } + else if ( SID_FM_RECORD_TOTAL == nWhich ) + { + OUString sTotalCount; + aState.State >>= sTotalCount; + rSet.Put( SfxStringItem( nWhich, sTotalCount ) ); + } + bEnable = aState.Enabled; + } + break; + + // first, prev, next, last, and absolute affect the nav controller, not the + // active controller + case SID_FM_RECORD_FIRST: + case SID_FM_RECORD_PREV: + case SID_FM_RECORD_NEXT: + case SID_FM_RECORD_LAST: + case SID_FM_RECORD_NEW: + case SID_FM_RECORD_SAVE: + case SID_FM_RECORD_UNDO: + case SID_FM_RECORD_DELETE: + case SID_FM_REFRESH: + case SID_FM_REFRESH_FORM_CONTROL: + case SID_FM_REMOVE_FILTER_SORT: + case SID_FM_SORTUP: + case SID_FM_SORTDOWN: + case SID_FM_AUTOFILTER: + case SID_FM_ORDERCRIT: + bEnable = GetImpl()->IsFormSlotEnabled( nWhich, nullptr ); + break; + + case SID_FM_FORM_FILTERED: + { + FeatureState aState; + bEnable = GetImpl()->IsFormSlotEnabled( nWhich, &aState ); + + rSet.Put( SfxBoolItem( nWhich, ::comphelper::getBOOL( aState.State ) ) ); + } + break; + + case SID_FM_FILTER_START: + bEnable = GetImpl()->getActiveControllerFeatures_Lock()->canDoFormFilter(); + break; + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.form", "caught an exception while determining the state!"); + } + if (!bEnable) + rSet.DisableItem(nWhich); + } +} + + +FmFormPage* FmFormShell::GetCurPage() const +{ + FmFormPage* pP = nullptr; + if (m_pFormView && m_pFormView->GetSdrPageView()) + pP = dynamic_cast<FmFormPage*>( m_pFormView->GetSdrPageView()->GetPage() ); + return pP; +} + + +void FmFormShell::SetView( FmFormView* _pView ) +{ + if ( m_pFormView ) + { + if ( IsActive() ) + GetImpl()->viewDeactivated_Lock(*m_pFormView); + + m_pFormView->SetFormShell( nullptr, FmFormView::FormShellAccess() ); + m_pFormView = nullptr; + m_pFormModel = nullptr; + } + + if ( !_pView ) + return; + + m_pFormView = _pView; + m_pFormView->SetFormShell( this, FmFormView::FormShellAccess() ); + m_pFormModel = static_cast<FmFormModel*>(m_pFormView->GetModel()); + + impl_setDesignMode( m_pFormView->IsDesignMode() ); + + // We activate our view if we are activated ourself, but sometimes the Activate precedes the SetView. + // But here we know both the view and our activation state so we at least are able to pass the latter + // to the former. + // FS - 30.06.99 - 67308 + if ( IsActive() ) + GetImpl()->viewActivated_Lock(*m_pFormView); +} + + +void FmFormShell::DetermineForms(bool bInvalidate) +{ + // are there forms on the current page + bool bForms = GetImpl()->hasForms_Lock(); + if (bForms != m_bHasForms) + { + m_bHasForms = bForms; + if (bInvalidate) + UIFeatureChanged(); + } +} + + +bool FmFormShell::GetY2KState(sal_uInt16& nReturn) +{ + return GetImpl()->GetY2KState_Lock(nReturn); +} + + +void FmFormShell::SetY2KState(sal_uInt16 n) +{ + GetImpl()->SetY2KState_Lock(n); +} + + +void FmFormShell::Activate(bool bMDI) +{ + SfxShell::Activate(bMDI); + + if ( m_pFormView ) + GetImpl()->viewActivated_Lock(*m_pFormView, true); +} + + +void FmFormShell::Deactivate(bool bMDI) +{ + SfxShell::Deactivate(bMDI); + + if ( m_pFormView ) + GetImpl()->viewDeactivated_Lock(*m_pFormView, false); +} + + +void FmFormShell::ExecuteTextAttribute( SfxRequest& _rReq ) +{ + m_pImpl->ExecuteTextAttribute_Lock(_rReq); +} + + +void FmFormShell::GetTextAttributeState( SfxItemSet& _rSet ) +{ + m_pImpl->GetTextAttributeState_Lock(_rSet); +} + + +bool FmFormShell::IsActiveControl() const +{ + return m_pImpl->IsActiveControl_Lock(false); +} + + +void FmFormShell::ForgetActiveControl() +{ + m_pImpl->ForgetActiveControl_Lock(); +} + + +void FmFormShell::SetControlActivationHandler( const Link<LinkParamNone*,void>& _rHdl ) +{ + m_pImpl->SetControlActivationHandler_Lock(_rHdl); +} + + +namespace +{ + SdrUnoObj* lcl_findUnoObject( const SdrObjList& _rObjList, const Reference< XControlModel >& _rxModel ) + { + SdrObjListIter aIter( &_rObjList ); + while ( aIter.IsMore() ) + { + SdrObject* pObject = aIter.Next(); + SdrUnoObj* pUnoObject = dynamic_cast<SdrUnoObj*>( pObject ); + if ( !pUnoObject ) + continue; + + Reference< XControlModel > xControlModel = pUnoObject->GetUnoControlModel(); + if ( !xControlModel.is() ) + continue; + + if ( _rxModel == xControlModel ) + return pUnoObject; + } + return nullptr; + } +} + + +void FmFormShell::ToggleControlFocus( const SdrUnoObj& i_rUnoObject, const SdrView& i_rView, const OutputDevice& i_rDevice ) const +{ + try + { + // check if the focus currently is in a control + // Well, okay, do it the other way 'round: Check whether the current control of the active controller + // actually has the focus. This should be equivalent. + const bool bHasControlFocus = GetImpl()->HasControlFocus_Lock(); + + if ( bHasControlFocus ) + { + vcl::Window* pWindow = i_rDevice.GetOwnerWindow(); + OSL_ENSURE( pWindow, "FmFormShell::ToggleControlFocus: I need a Window, really!" ); + if ( pWindow ) + pWindow->GrabFocus(); + } + else + { + Reference< XControl > xControl; + GetFormControl( i_rUnoObject.GetUnoControlModel(), i_rView, i_rDevice, xControl ); + Reference< XWindow > xControlWindow( xControl, UNO_QUERY ); + if ( xControlWindow.is() ) + xControlWindow->setFocus(); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +namespace +{ + class FocusableControlsFilter : public svx::ISdrObjectFilter + { + public: + FocusableControlsFilter( const SdrView& i_rView, const OutputDevice& i_rDevice ) + :m_rView( i_rView ) + ,m_rDevice( i_rDevice ) + { + } + + public: + virtual bool includeObject( const SdrObject& i_rObject ) const override + { + const SdrUnoObj* pUnoObj = dynamic_cast< const SdrUnoObj* >( &i_rObject ); + if ( !pUnoObj ) + return false; + + Reference< XControl > xControl = pUnoObj->GetUnoControl( m_rView, m_rDevice ); + return FmXFormView::isFocusable( xControl ); + } + + private: + const SdrView& m_rView; + const OutputDevice& m_rDevice; + }; +} + + +::std::unique_ptr< svx::ISdrObjectFilter > FmFormShell::CreateFocusableControlFilter( const SdrView& i_rView, const OutputDevice& i_rDevice ) +{ + ::std::unique_ptr< svx::ISdrObjectFilter > pFilter; + + if ( !i_rView.IsDesignMode() ) + pFilter.reset( new FocusableControlsFilter( i_rView, i_rDevice ) ); + + return pFilter; +} + + +SdrUnoObj* FmFormShell::GetFormControl( const Reference< XControlModel >& _rxModel, const SdrView& _rView, const OutputDevice& _rDevice, Reference< XControl >& _out_rxControl ) const +{ + if ( !_rxModel.is() ) + return nullptr; + + // we can only retrieve controls for SdrObjects which belong to page which is actually displayed in the given view + SdrPageView* pPageView = _rView.GetSdrPageView(); + SdrPage* pPage = pPageView ? pPageView->GetPage() : nullptr; + OSL_ENSURE( pPage, "FmFormShell::GetFormControl: no page displayed in the given view!" ); + if ( !pPage ) + return nullptr; + + SdrUnoObj* pUnoObject = lcl_findUnoObject( *pPage, _rxModel ); + if ( pUnoObject ) + { + _out_rxControl = pUnoObject->GetUnoControl( _rView, _rDevice ); + return pUnoObject; + } + +#if OSL_DEBUG_LEVEL > 0 + // perhaps we are fed with a control model which lives on a page other than the one displayed + // in the given view. This is worth being reported as error, in non-product builds. + FmFormModel* pModel = GetFormModel(); + if ( pModel ) + { + sal_uInt16 pageCount = pModel->GetPageCount(); + for ( sal_uInt16 page = 0; page < pageCount; ++page ) + { + pPage = pModel->GetPage( page ); + OSL_ENSURE( pPage, "FmFormShell::GetFormControl: NULL page encountered!" ); + if ( !pPage ) + continue; + + pUnoObject = lcl_findUnoObject( *pPage, _rxModel ); + OSL_ENSURE( !pUnoObject, "FmFormShell::GetFormControl: the given control model belongs to a wrong page (displayed elsewhere)!" ); + } + } +#else + (void) this; // avoid loplugin:staticmethods +#endif + + return nullptr; +} + + +Reference< runtime::XFormController > FmFormShell::GetFormController( const Reference< XForm >& _rxForm, const SdrView& _rView, const OutputDevice& _rDevice ) +{ + const FmFormView* pFormView = dynamic_cast< const FmFormView* >( &_rView ); + if ( !pFormView ) + return nullptr; + + return pFormView->GetFormController( _rxForm, _rDevice ); +} + + +void FmFormShell::SetDesignMode( bool _bDesignMode ) +{ + if ( _bDesignMode == m_bDesignMode ) + return; + + FmFormModel* pModel = GetFormModel(); + if (pModel) + // Switch off the undo environment for the time of the transition. This ensures that + // one can also change non-transient properties there. (It should be done with + // caution, however, and it should always be reversed when one switches the mode back. + // An example is the setting of the maximum text length by the OEditModel on its control.) + pModel->GetUndoEnv().Lock(); + + // then the actual switch + if ( m_bDesignMode || PrepareClose() ) + impl_setDesignMode(!m_bDesignMode ); + + // and my undo environment back on + if ( pModel ) + pModel->GetUndoEnv().UnLock(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmshimp.cxx b/svx/source/form/fmshimp.cxx new file mode 100644 index 000000000..8eb83000b --- /dev/null +++ b/svx/source/form/fmshimp.cxx @@ -0,0 +1,3960 @@ +/* -*- 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 <o3tl/safeint.hxx> +#include <sal/macros.h> +#include <sal/log.hxx> +#include <fmobj.hxx> +#include <fmpgeimp.hxx> +#include <svx/fmtools.hxx> +#include <fmprop.hxx> +#include <fmservs.hxx> +#include <fmshimp.hxx> +#include <fmtextcontrolshell.hxx> +#include <fmundo.hxx> +#include <fmurl.hxx> +#include <fmvwimp.hxx> +#include <gridcols.hxx> +#include <svx/svditer.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <svx/svdobjkind.hxx> +#include <svx/fmmodel.hxx> +#include <svx/fmpage.hxx> +#include <svx/fmshell.hxx> +#include <svx/fmview.hxx> +#include <svx/obj3d.hxx> +#include <svx/sdrpagewindow.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svxdlg.hxx> +#include <svx/svxids.hrc> +#include <bitmaps.hlst> +#include <formnavi.hrc> + +#include <com/sun/star/awt/XWindow2.hpp> +#include <com/sun/star/awt/XCheckBox.hpp> +#include <com/sun/star/awt/XListBox.hpp> +#include <com/sun/star/awt/XTextComponent.hpp> +#include <com/sun/star/beans/theIntrospection.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/beans/XPropertyState.hpp> +#include <com/sun/star/container/XContainer.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/container/XNamed.hpp> +#include <com/sun/star/form/ListSourceType.hpp> +#include <com/sun/star/form/TabOrderDialog.hpp> +#include <com/sun/star/form/XGrid.hpp> +#include <com/sun/star/form/XGridPeer.hpp> +#include <com/sun/star/form/XLoadable.hpp> +#include <com/sun/star/form/XReset.hpp> +#include <com/sun/star/form/binding/XBindableValue.hpp> +#include <com/sun/star/form/binding/XListEntrySink.hpp> +#include <com/sun/star/frame/FrameSearchFlag.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/script/XEventAttacherManager.hpp> +#include <com/sun/star/sdbc/SQLException.hpp> +#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> +#include <com/sun/star/util/XModeSelector.hpp> +#include <com/sun/star/util/XNumberFormatsSupplier.hpp> +#include <com/sun/star/view/XSelectionSupplier.hpp> + +#include <comphelper/evtmethodhelper.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/property.hxx> +#include <comphelper/sequence.hxx> +#include <comphelper/solarmutex.hxx> +#include <comphelper/string.hxx> +#include <comphelper/types.hxx> +#include <connectivity/dbtools.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/frame.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/viewsh.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <vcl/window.hxx> + +#include <algorithm> +#include <map> +#include <memory> +#include <string_view> +#include <vector> + +// is used for Invalidate -> maintain it as well +const sal_uInt16 DatabaseSlotMap[] = +{ + SID_FM_RECORD_FIRST, + SID_FM_RECORD_NEXT, + SID_FM_RECORD_PREV, + SID_FM_RECORD_LAST, + SID_FM_RECORD_NEW, + SID_FM_RECORD_DELETE, + SID_FM_RECORD_ABSOLUTE, + SID_FM_RECORD_TOTAL, + SID_FM_RECORD_SAVE, + SID_FM_RECORD_UNDO, + SID_FM_REMOVE_FILTER_SORT, + SID_FM_SORTUP, + SID_FM_SORTDOWN, + SID_FM_ORDERCRIT, + SID_FM_AUTOFILTER, + SID_FM_FORM_FILTERED, + SID_FM_REFRESH, + SID_FM_REFRESH_FORM_CONTROL, + SID_FM_SEARCH, + SID_FM_FILTER_START, + SID_FM_VIEW_AS_GRID, + 0 +}; + +// is used for Invalidate -> maintain it as well +// sort ascending !!!!!! +const sal_Int16 DlgSlotMap[] = // slots of the controller +{ + SID_FM_CTL_PROPERTIES, + SID_FM_PROPERTIES, + SID_FM_TAB_DIALOG, + SID_FM_ADD_FIELD, + SID_FM_SHOW_FMEXPLORER, + SID_FM_FIELDS_CONTROL, + SID_FM_SHOW_PROPERTIES, + SID_FM_PROPERTY_CONTROL, + SID_FM_FMEXPLORER_CONTROL, + SID_FM_SHOW_DATANAVIGATOR, + SID_FM_DATANAVIGATOR_CONTROL, + 0 +}; + +const sal_Int16 SelObjectSlotMap[] = // slots depending on the SelObject +{ + SID_FM_CONVERTTO_EDIT, + SID_FM_CONVERTTO_BUTTON, + SID_FM_CONVERTTO_FIXEDTEXT, + SID_FM_CONVERTTO_LISTBOX, + SID_FM_CONVERTTO_CHECKBOX, + SID_FM_CONVERTTO_RADIOBUTTON, + SID_FM_CONVERTTO_GROUPBOX, + SID_FM_CONVERTTO_COMBOBOX, + SID_FM_CONVERTTO_IMAGEBUTTON, + SID_FM_CONVERTTO_FILECONTROL, + SID_FM_CONVERTTO_DATE, + SID_FM_CONVERTTO_TIME, + SID_FM_CONVERTTO_NUMERIC, + SID_FM_CONVERTTO_CURRENCY, + SID_FM_CONVERTTO_PATTERN, + SID_FM_CONVERTTO_IMAGECONTROL, + SID_FM_CONVERTTO_FORMATTED, + SID_FM_CONVERTTO_SCROLLBAR, + SID_FM_CONVERTTO_SPINBUTTON, + SID_FM_CONVERTTO_NAVIGATIONBAR, + + SID_FM_FMEXPLORER_CONTROL, + SID_FM_DATANAVIGATOR_CONTROL, + + 0 +}; + +// the following arrays must be consistent, i.e., corresponding entries should +// be at the same relative position within their respective arrays +static const char* aConvertSlots[] = +{ + "ConvertToEdit", + "ConvertToButton", + "ConvertToFixed", + "ConvertToList", + "ConvertToCheckBox", + "ConvertToRadio", + "ConvertToGroup", + "ConvertToCombo", + "ConvertToImageBtn", + "ConvertToFileControl", + "ConvertToDate", + "ConvertToTime", + "ConvertToNumeric", + "ConvertToCurrency", + "ConvertToPattern", + "ConvertToImageControl", + "ConvertToFormatted", + "ConvertToScrollBar", + "ConvertToSpinButton", + "ConvertToNavigationBar" +}; + +constexpr rtl::OUStringConstExpr aImgIds[] = +{ + RID_SVXBMP_EDITBOX, + RID_SVXBMP_BUTTON, + RID_SVXBMP_FIXEDTEXT, + RID_SVXBMP_LISTBOX, + RID_SVXBMP_CHECKBOX, + RID_SVXBMP_RADIOBUTTON, + RID_SVXBMP_GROUPBOX, + RID_SVXBMP_COMBOBOX, + RID_SVXBMP_IMAGEBUTTON, + RID_SVXBMP_FILECONTROL, + RID_SVXBMP_DATEFIELD, + RID_SVXBMP_TIMEFIELD, + RID_SVXBMP_NUMERICFIELD, + RID_SVXBMP_CURRENCYFIELD, + RID_SVXBMP_PATTERNFIELD, + RID_SVXBMP_IMAGECONTROL, + RID_SVXBMP_FORMATTEDFIELD, + RID_SVXBMP_SCROLLBAR, + RID_SVXBMP_SPINBUTTON, + RID_SVXBMP_NAVIGATIONBAR +}; + +const SdrObjKind nObjectTypes[] = +{ + SdrObjKind::FormEdit, + SdrObjKind::FormButton, + SdrObjKind::FormFixedText, + SdrObjKind::FormListbox, + SdrObjKind::FormCheckbox, + SdrObjKind::FormRadioButton, + SdrObjKind::FormGroupBox, + SdrObjKind::FormCombobox, + SdrObjKind::FormImageButton, + SdrObjKind::FormFileControl, + SdrObjKind::FormDateField, + SdrObjKind::FormTimeField, + SdrObjKind::FormNumericField, + SdrObjKind::FormCurrencyField, + SdrObjKind::FormPatternField, + SdrObjKind::FormImageControl, + SdrObjKind::FormFormattedField, + SdrObjKind::FormScrollbar, + SdrObjKind::FormSpinButton, + SdrObjKind::FormNavigationBar +}; + +using namespace ::com::sun::star; +using namespace ::com::sun::star::ui; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdb; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::form::binding; +using namespace ::com::sun::star::form::runtime; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::view; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::script; +using namespace ::svxform; +using namespace ::svx; +using namespace ::dbtools; + + +//= helper + +namespace +{ + + void collectInterfacesFromMarkList( const SdrMarkList& _rMarkList, InterfaceBag& /* [out] */ _rInterfaces ) + { + _rInterfaces.clear(); + + const size_t nMarkCount = _rMarkList.GetMarkCount(); + for ( size_t i = 0; i < nMarkCount; ++i) + { + SdrObject* pCurrent = _rMarkList.GetMark( i )->GetMarkedSdrObj(); + + std::unique_ptr<SdrObjListIter> pGroupIterator; + if ( pCurrent->IsGroupObject() ) + { + pGroupIterator.reset(new SdrObjListIter( pCurrent->GetSubList() )); + pCurrent = pGroupIterator->IsMore() ? pGroupIterator->Next() : nullptr; + } + + while ( pCurrent ) + { + FmFormObj* pAsFormObject = FmFormObj::GetFormObject( pCurrent ); + // note this will de-reference virtual objects, if necessary/possible + if ( pAsFormObject ) + { + Reference< XInterface > xControlModel( pAsFormObject->GetUnoControlModel(), UNO_QUERY ); + // the UNO_QUERY is important for normalization + if ( xControlModel.is() ) + _rInterfaces.insert( xControlModel ); + } + + // next element + pCurrent = pGroupIterator && pGroupIterator->IsMore() ? pGroupIterator->Next() : nullptr; + } + } + } + + + sal_Int32 GridView2ModelPos(const Reference< XIndexAccess>& rColumns, sal_Int16 nViewPos) + { + try + { + if (rColumns.is()) + { + // loop through all columns + sal_Int32 i; + Reference< XPropertySet> xCur; + for (i=0; i<rColumns->getCount(); ++i) + { + rColumns->getByIndex(i) >>= xCur; + if (!::comphelper::getBOOL(xCur->getPropertyValue(FM_PROP_HIDDEN))) + { + // for every visible col : if nViewPos is greater zero, decrement it, else we + // have found the model position + if (!nViewPos) + break; + else + --nViewPos; + } + } + if (i<rColumns->getCount()) + return i; + } + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return -1; + } + + + void TransferEventScripts(const Reference< XControlModel>& xModel, const Reference< XControl>& xControl, + const Sequence< ScriptEventDescriptor>& rTransferIfAvailable) + { + // first check if we have a XEventAttacherManager for the model + Reference< XChild> xModelChild(xModel, UNO_QUERY); + if (!xModelChild.is()) + return; // nothing to do + + Reference< XEventAttacherManager> xEventManager(xModelChild->getParent(), UNO_QUERY); + if (!xEventManager.is()) + return; // nothing to do + + if (!rTransferIfAvailable.hasElements()) + return; // nothing to do + + // check for the index of the model within its parent + Reference< XIndexAccess> xParentIndex(xModelChild->getParent(), UNO_QUERY); + if (!xParentIndex.is()) + return; // nothing to do + sal_Int32 nIndex = getElementPos(xParentIndex, xModel); + if (nIndex<0 || nIndex>=xParentIndex->getCount()) + return; // nothing to do + + // then we need information about the listeners supported by the control and the model + Sequence< Type> aModelListeners; + Sequence< Type> aControlListeners; + + Reference< XIntrospection> xIntrospection = theIntrospection::get(::comphelper::getProcessComponentContext()); + + if (xModel.is()) + { + Any aModel(xModel); + aModelListeners = xIntrospection->inspect(aModel)->getSupportedListeners(); + } + + if (xControl.is()) + { + Any aControl(xControl); + aControlListeners = xIntrospection->inspect(aControl)->getSupportedListeners(); + } + + sal_Int32 nMaxNewLen = aModelListeners.getLength() + aControlListeners.getLength(); + if (!nMaxNewLen) + return; // the model and the listener don't support any listeners (or we were unable to retrieve these infos) + + Sequence< ScriptEventDescriptor> aTransferable(nMaxNewLen); + ScriptEventDescriptor* pTransferable = aTransferable.getArray(); + + for (const ScriptEventDescriptor& rCurrent : rTransferIfAvailable) + { + // search the model/control idl classes for the event described by pCurrent + for (const Sequence< Type>* pCurrentArray : { &aModelListeners, &aControlListeners }) + { + for (const Type& rCurrentListener : *pCurrentArray) + { + OUString aListener = rCurrentListener.getTypeName(); + if (!aListener.isEmpty()) + aListener = aListener.copy(aListener.lastIndexOf('.')+1); + + if (aListener == rCurrent.ListenerType) + // the current ScriptEventDescriptor doesn't match the current listeners class + continue; + + // now check the methods + Sequence< OUString> aMethodsNames = ::comphelper::getEventMethodsForType(rCurrentListener); + + if (comphelper::findValue(aMethodsNames, rCurrent.EventMethod) != -1) + { + // we can transfer the script event : the model (control) supports it + *pTransferable = rCurrent; + ++pTransferable; + break; + } + } + } + } + + sal_Int32 nRealNewLen = pTransferable - aTransferable.getArray(); + aTransferable.realloc(nRealNewLen); + + xEventManager->registerScriptEvents(nIndex, aTransferable); + } + + + OUString getServiceNameByControlType(SdrObjKind nType) + { + switch (nType) + { + case SdrObjKind::FormEdit : return FM_COMPONENT_TEXTFIELD; + case SdrObjKind::FormButton : return FM_COMPONENT_COMMANDBUTTON; + case SdrObjKind::FormFixedText : return FM_COMPONENT_FIXEDTEXT; + case SdrObjKind::FormListbox : return FM_COMPONENT_LISTBOX; + case SdrObjKind::FormCheckbox : return FM_COMPONENT_CHECKBOX; + case SdrObjKind::FormRadioButton : return FM_COMPONENT_RADIOBUTTON; + case SdrObjKind::FormGroupBox : return FM_COMPONENT_GROUPBOX; + case SdrObjKind::FormCombobox : return FM_COMPONENT_COMBOBOX; + case SdrObjKind::FormGrid : return FM_COMPONENT_GRIDCONTROL; + case SdrObjKind::FormImageButton : return FM_COMPONENT_IMAGEBUTTON; + case SdrObjKind::FormFileControl : return FM_COMPONENT_FILECONTROL; + case SdrObjKind::FormDateField : return FM_COMPONENT_DATEFIELD; + case SdrObjKind::FormTimeField : return FM_COMPONENT_TIMEFIELD; + case SdrObjKind::FormNumericField : return FM_COMPONENT_NUMERICFIELD; + case SdrObjKind::FormCurrencyField : return FM_COMPONENT_CURRENCYFIELD; + case SdrObjKind::FormPatternField : return FM_COMPONENT_PATTERNFIELD; + case SdrObjKind::FormHidden : return FM_COMPONENT_HIDDENCONTROL; + case SdrObjKind::FormImageControl : return FM_COMPONENT_IMAGECONTROL; + case SdrObjKind::FormFormattedField : return FM_COMPONENT_FORMATTEDFIELD; + case SdrObjKind::FormScrollbar : return FM_SUN_COMPONENT_SCROLLBAR; + case SdrObjKind::FormSpinButton : return FM_SUN_COMPONENT_SPINBUTTON; + case SdrObjKind::FormNavigationBar : return FM_SUN_COMPONENT_NAVIGATIONBAR; + default:; + } + return OUString(); + } + +} + + +// check if the control has one of the interfaces we can use for searching +// *_pCurrentText will be filled with the current text of the control (as used when searching this control) +bool IsSearchableControl( const css::uno::Reference< css::uno::XInterface>& _rxControl, + OUString* _pCurrentText ) +{ + if ( !_rxControl.is() ) + return false; + + Reference< XTextComponent > xAsText( _rxControl, UNO_QUERY ); + if ( xAsText.is() ) + { + if ( _pCurrentText ) + *_pCurrentText = xAsText->getText(); + return true; + } + + Reference< XListBox > xListBox( _rxControl, UNO_QUERY ); + if ( xListBox.is() ) + { + if ( _pCurrentText ) + *_pCurrentText = xListBox->getSelectedItem(); + return true; + } + + Reference< XCheckBox > xCheckBox( _rxControl, UNO_QUERY ); + if ( xCheckBox.is() ) + { + if ( _pCurrentText ) + { + switch ( static_cast<::TriState>(xCheckBox->getState()) ) + { + case TRISTATE_FALSE: *_pCurrentText = "0"; break; + case TRISTATE_TRUE: *_pCurrentText = "1"; break; + default: _pCurrentText->clear(); break; + } + } + return true; + } + + return false; +} + + +bool FmXBoundFormFieldIterator::ShouldStepInto(const Reference< XInterface>& _rContainer) const +{ + if (_rContainer == m_xStartingPoint) + // would be quite stupid to step over the root... + return true; + + return Reference< XControlModel>(_rContainer, UNO_QUERY).is(); +} + + +bool FmXBoundFormFieldIterator::ShouldHandleElement(const Reference< XInterface>& _rElement) +{ + if (!_rElement.is()) + // NULL element + return false; + + if (Reference< XForm>(_rElement, UNO_QUERY).is() || Reference< XGrid>(_rElement, UNO_QUERY).is()) + // a forms or a grid + return false; + + Reference< XPropertySet> xSet(_rElement, UNO_QUERY); + if (!xSet.is() || !::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet)) + // no "BoundField" property + return false; + + Any aVal( xSet->getPropertyValue(FM_PROP_BOUNDFIELD) ); + if (aVal.getValueTypeClass() != TypeClass_INTERFACE) + // void or invalid property value + return false; + + return aVal.hasValue(); +} + + +static bool isControlList(const SdrMarkList& rMarkList) +{ + // the list contains only controls and at least one control + const size_t nMarkCount = rMarkList.GetMarkCount(); + bool bControlList = nMarkCount != 0; + + bool bHadAnyLeafs = false; + + for (size_t i = 0; i < nMarkCount && bControlList; ++i) + { + SdrObject *pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + E3dObject* pAs3DObject = dynamic_cast< E3dObject* >( pObj); + // E3dObject's do not contain any 2D-objects (by definition) + // we need this extra check here : an E3dObject->IsGroupObject says "YES", but an SdrObjListIter working + // with an E3dObject doesn't give me any Nodes (E3dObject has a sub list, but no members in that list, + // cause there implementation differs from the one of "normal" SdrObject's. Unfortunally SdrObject::IsGroupObject + // doesn't check the element count of the sub list, which is simply a bug in IsGroupObject we can't fix at the moment). + // So at the end of this function bControlList would have the same value it was initialized with above : sal_True + // And this would be wrong :) + // 03.02.00 - 72529 - FS + if (!pAs3DObject) + { + if (pObj->IsGroupObject()) + { + SdrObjListIter aIter(pObj->GetSubList()); + while (aIter.IsMore() && bControlList) + { + bControlList = SdrInventor::FmForm == aIter.Next()->GetObjInventor(); + bHadAnyLeafs = true; + } + } + else + { + bHadAnyLeafs = true; + bControlList = SdrInventor::FmForm == pObj->GetObjInventor(); + } + } + } + + return bControlList && bHadAnyLeafs; +} + + +static Reference< XForm > GetForm(const Reference< XInterface>& _rxElement) +{ + Reference< XForm > xForm( _rxElement, UNO_QUERY ); + if ( xForm.is() ) + return xForm; + + Reference< XChild > xChild( _rxElement, UNO_QUERY ); + if ( xChild.is() ) + return GetForm( xChild->getParent() ); + + return Reference< XForm >(); +} + +FmXFormShell_Base_Disambiguation::FmXFormShell_Base_Disambiguation( ::osl::Mutex& _rMutex ) + :FmXFormShell_BD_BASE( _rMutex ) +{ +} + +FmXFormShell::FmXFormShell( FmFormShell& _rShell, SfxViewFrame* _pViewFrame ) + :FmXFormShell_BASE(m_aMutex) + ,FmXFormShell_CFGBASE("Office.Common/Misc", ConfigItemMode::NONE) + ,m_aMarkTimer("svx::FmXFormShell m_aMarkTimer") + ,m_eNavigate( NavigationBarMode_NONE ) + ,m_nInvalidationEvent( nullptr ) + ,m_nActivationEvent( nullptr ) + ,m_pShell( &_rShell ) + ,m_pTextShell( new svx::FmTextControlShell( _pViewFrame ) ) + ,m_aActiveControllerFeatures( this ) + ,m_aNavControllerFeatures( this ) + ,m_eDocumentType( eUnknownDocumentType ) + ,m_nLockSlotInvalidation( 0 ) + ,m_bHadPropertyBrowserInDesignMode( false ) + ,m_bTrackProperties( true ) + ,m_bUseWizards( true ) + ,m_bDatabaseBar( false ) + ,m_bInActivate( false ) + ,m_bSetFocus( false ) + ,m_bFilterMode( false ) + ,m_bChangingDesignMode( false ) + ,m_bPreparedClose( false ) + ,m_bFirstActivation( true ) +{ + m_aMarkTimer.SetTimeout(100); + m_aMarkTimer.SetInvokeHandler(LINK(this, FmXFormShell, OnTimeOut_Lock)); + + m_xAttachedFrame = _pViewFrame->GetFrame().GetFrameInterface(); + + // to prevent deletion of this we acquire our refcounter once + osl_atomic_increment(&m_refCount); + + // correct the refcounter + osl_atomic_decrement(&m_refCount); + + // cache the current configuration settings we're interested in + implAdjustConfigCache_Lock(); + // and register for changes on this settings + Sequence< OUString > aNames { "FormControlPilotsEnabled" }; + EnableNotification(aNames); +} + + +FmXFormShell::~FmXFormShell() +{ +} + + +Reference< css::frame::XModel > FmXFormShell::getContextDocument_Lock() const +{ + Reference< css::frame::XModel > xModel; + + // determine the type of document we live in + try + { + Reference< css::frame::XController > xController; + if ( m_xAttachedFrame.is() ) + xController = m_xAttachedFrame->getController(); + if ( xController.is() ) + xModel = xController->getModel(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return xModel; +} + + +bool FmXFormShell::isEnhancedForm_Lock() const +{ + return getDocumentType_Lock() == eEnhancedForm; +} + + +bool FmXFormShell::impl_checkDisposed_Lock() const +{ + DBG_TESTSOLARMUTEX(); + if ( !m_pShell ) + { + OSL_FAIL( "FmXFormShell::impl_checkDisposed: already disposed!" ); + return true; + } + return false; +} + + +::svxform::DocumentType FmXFormShell::getDocumentType_Lock() const +{ + if ( m_eDocumentType != eUnknownDocumentType ) + return m_eDocumentType; + + // determine the type of document we live in + Reference<css::frame::XModel> xModel = getContextDocument_Lock(); + if ( xModel.is() ) + m_eDocumentType = DocumentClassification::classifyDocument( xModel ); + else + { + OSL_FAIL( "FmXFormShell::getDocumentType: can't determine the document type!" ); + m_eDocumentType = eTextDocument; + // fallback, just to have a defined state + } + + return m_eDocumentType; +} + + +bool FmXFormShell::IsReadonlyDoc_Lock() const +{ + if (impl_checkDisposed_Lock()) + return true; + + FmFormModel* pModel = m_pShell->GetFormModel(); + if ( pModel && pModel->GetObjectShell() ) + return pModel->GetObjectShell()->IsReadOnly() || pModel->GetObjectShell()->IsReadOnlyUI(); + return true; +} + +// EventListener + +void SAL_CALL FmXFormShell::disposing(const lang::EventObject& e) +{ + SolarMutexGuard g; + + if (m_xActiveController == e.Source) + { + // the controller will release, then release everything + stopListening_Lock(); + m_xActiveForm = nullptr; + m_xActiveController = nullptr; + m_xNavigationController = nullptr; + + m_aActiveControllerFeatures.dispose(); + m_aNavControllerFeatures.dispose(); + + if ( m_pShell ) + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell); + } + + if (e.Source != m_xExternalViewController) + return; + + Reference< runtime::XFormController > xFormController( m_xExternalViewController, UNO_QUERY ); + OSL_ENSURE( xFormController.is(), "FmXFormShell::disposing: invalid external view controller!" ); + if (xFormController.is()) + xFormController->removeActivateListener(static_cast<XFormControllerListener*>(this)); + + if (m_xExternalViewController.is()) + m_xExternalViewController->removeEventListener(static_cast<XEventListener*>(static_cast<XPropertyChangeListener*>(this))); + + m_xExternalViewController = nullptr; + m_xExternalDisplayedForm = nullptr; + m_xExtViewTriggerController = nullptr; + + InvalidateSlot_Lock( SID_FM_VIEW_AS_GRID, false ); +} + + +void SAL_CALL FmXFormShell::propertyChange(const PropertyChangeEvent& evt) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock()) + return; + + if (evt.PropertyName == FM_PROP_ROWCOUNT) + { + // The update following this forces a re-painting of the corresponding + // slots. But if I am not in the MainThread of the application (because, + // for example, a cursor is counting data sets at the moment and always + // gives me this PropertyChanges), this can clash with normal paints in + // the MainThread of the application. (Such paints happen, for example, + // if one simply places another application over the office and switches + // back again). + // Therefore the use of the SolarMutex, which safeguards that. + comphelper::SolarMutex& rSolarSafety = Application::GetSolarMutex(); + if (rSolarSafety.tryToAcquire()) + { + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_RECORD_TOTAL, true); + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Update(SID_FM_RECORD_TOTAL); + rSolarSafety.release(); + } + else + { + // with the following the slot is invalidated asynchron + LockSlotInvalidation_Lock(true); + InvalidateSlot_Lock(SID_FM_RECORD_TOTAL, false); + LockSlotInvalidation_Lock(false); + } + } + + // this may be called from a non-main-thread so invalidate the shell asynchronously + LockSlotInvalidation_Lock(true); + InvalidateSlot_Lock(0, false); // special meaning : invalidate m_pShell + LockSlotInvalidation_Lock(false); +} + + +void FmXFormShell::invalidateFeatures( const ::std::vector< sal_Int32 >& _rFeatures ) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock()) + return; + + OSL_ENSURE( !_rFeatures.empty(), "FmXFormShell::invalidateFeatures: invalid arguments!" ); + + if ( !(m_pShell->GetViewShell() && m_pShell->GetViewShell()->GetViewFrame()) ) + return; + + // unfortunately, SFX requires sal_uInt16 + ::std::vector< sal_uInt16 > aSlotIds( _rFeatures.begin(), _rFeatures.end() ); + + // furthermore, SFX wants a terminating 0 + aSlotIds.push_back( 0 ); + + // and, last but not least, SFX wants the ids to be sorted + ::std::sort( aSlotIds.begin(), aSlotIds.end() - 1 ); + + sal_uInt16 *pSlotIds = aSlotIds.data(); + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate( pSlotIds ); +} + + +void SAL_CALL FmXFormShell::formActivated(const lang::EventObject& rEvent) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock()) + return; + + Reference< runtime::XFormController > xController( rEvent.Source, UNO_QUERY_THROW ); + m_pTextShell->formActivated( xController ); + setActiveController_Lock(xController); +} + + +void SAL_CALL FmXFormShell::formDeactivated(const lang::EventObject& rEvent) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock()) + return; + + Reference< runtime::XFormController > xController( rEvent.Source, UNO_QUERY_THROW ); + m_pTextShell->formDeactivated( xController ); +} + + +void FmXFormShell::disposing() +{ + SolarMutexGuard g; + + FmXFormShell_BASE::disposing(); + + if ( m_pShell && !m_pShell->IsDesignMode() ) + setActiveController_Lock(nullptr, true); + // do NOT save the content of the old form (the second parameter tells this) + // if we're here, then we expect that PrepareClose has been called, and thus the user + // got a chance to commit or reject any changes. So in case we're here and there + // are still uncommitted changes, the user explicitly wanted this. + + m_pTextShell->dispose(); + + m_xAttachedFrame = nullptr; + + CloseExternalFormViewer_Lock(); + + while ( !m_aLoadingPages.empty() ) + { + Application::RemoveUserEvent( m_aLoadingPages.front().nEventId ); + m_aLoadingPages.pop(); + } + + { + if (m_nInvalidationEvent) + { + Application::RemoveUserEvent(m_nInvalidationEvent); + m_nInvalidationEvent = nullptr; + } + if ( m_nActivationEvent ) + { + Application::RemoveUserEvent( m_nActivationEvent ); + m_nActivationEvent = nullptr; + } + } + + { + DBG_ASSERT(!m_nInvalidationEvent, "FmXFormShell::~FmXFormShell : still have an invalidation event !"); + // should have been deleted while being disposed + + m_aMarkTimer.Stop(); + } + + DisableNotification(); + + RemoveElement_Lock(m_xForms); + m_xForms.clear(); + + impl_switchActiveControllerListening_Lock(false); + m_xActiveController = nullptr; + m_xActiveForm = nullptr; + + m_pShell = nullptr; + m_xNavigationController = nullptr; + m_xCurrentForm = nullptr; + m_xLastGridFound = nullptr; + m_xAttachedFrame = nullptr; + m_xExternalViewController = nullptr; + m_xExtViewTriggerController = nullptr; + m_xExternalDisplayedForm = nullptr; + + InterfaceBag().swap(m_aCurrentSelection); + + m_aActiveControllerFeatures.dispose(); + m_aNavControllerFeatures.dispose(); +} + + +void FmXFormShell::UpdateSlot_Lock(sal_Int16 _nId) +{ + if (impl_checkDisposed_Lock()) + return; + + if ( m_nLockSlotInvalidation ) + { + OSL_FAIL( "FmXFormShell::UpdateSlot: cannot update if invalidation is currently locked!" ); + InvalidateSlot_Lock(_nId, false); + } + else + { + OSL_ENSURE( _nId, "FmXFormShell::UpdateSlot: can't update the complete shell!" ); + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate( _nId, true, true ); + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Update( _nId ); + } +} + + +void FmXFormShell::InvalidateSlot_Lock(sal_Int16 nId, bool bWithId) +{ + if (impl_checkDisposed_Lock()) + return; + + if (m_nLockSlotInvalidation) + { + sal_uInt8 nFlags = ( bWithId ? 0x01 : 0 ); + m_arrInvalidSlots.emplace_back(nId, nFlags ); + } + else + if (nId) + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(nId, true, bWithId); + else + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell); +} + + +void FmXFormShell::LockSlotInvalidation_Lock(bool bLock) +{ + if (impl_checkDisposed_Lock()) + return; + + DBG_ASSERT(bLock || m_nLockSlotInvalidation>0, "FmXFormShell::LockSlotInvalidation : invalid call !"); + + if (bLock) + ++m_nLockSlotInvalidation; + else if (!--m_nLockSlotInvalidation) + { + // (asynchronously) invalidate everything accumulated during the locked phase + if (!m_nInvalidationEvent) + m_nInvalidationEvent = Application::PostUserEvent(LINK(this, FmXFormShell, OnInvalidateSlots_Lock)); + } +} + + +IMPL_LINK_NOARG(FmXFormShell, OnInvalidateSlots_Lock, void*,void) +{ + if (impl_checkDisposed_Lock()) + return; + + m_nInvalidationEvent = nullptr; + + for (const auto& rInvalidSlot : m_arrInvalidSlots) + { + if (rInvalidSlot.id) + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(rInvalidSlot.id, true, (rInvalidSlot.flags & 0x01)); + else + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell); + } + m_arrInvalidSlots.clear(); +} + + +void FmXFormShell::ForceUpdateSelection_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + if (IsSelectionUpdatePending_Lock()) + { + m_aMarkTimer.Stop(); + + // optionally turn off the invalidation of slots which is implicitly done by SetSelection + LockSlotInvalidation_Lock(true); + + SetSelection_Lock(m_pShell->GetFormView()->GetMarkedObjectList()); + + LockSlotInvalidation_Lock(false); + } +} + +void FmXFormShell::GetConversionMenu_Lock(weld::Menu& rNewMenu) +{ + for (size_t i = 0; i < SAL_N_ELEMENTS(aConvertSlots); ++i) + { + // the corresponding image at it + rNewMenu.append(OUString::createFromAscii(aConvertSlots[i]), SvxResId(RID_SVXSW_CONVERTMENU[i]), aImgIds[i]); + } +} + +OString FmXFormShell::SlotToIdent(sal_uInt16 nSlot) +{ + static_assert(SAL_N_ELEMENTS(SelObjectSlotMap) >= SAL_N_ELEMENTS(aConvertSlots)); + + for (size_t i = 0; i < SAL_N_ELEMENTS(aConvertSlots); ++i) + { + if (nSlot == SelObjectSlotMap[i]) + return aConvertSlots[i]; + } + + return OString(); +} + +bool FmXFormShell::isControlConversionSlot(std::string_view rIdent) +{ + for (const auto& rConvertSlot : aConvertSlots) + if (rIdent == rConvertSlot) + return true; + return false; +} + +void FmXFormShell::executeControlConversionSlot_Lock(std::string_view rIdent) +{ + OSL_PRECOND( canConvertCurrentSelectionToControl_Lock(rIdent), "FmXFormShell::executeControlConversionSlot: illegal call!" ); + InterfaceBag::const_iterator aSelectedElement = m_aCurrentSelection.begin(); + if ( aSelectedElement == m_aCurrentSelection.end() ) + return; + + executeControlConversionSlot_Lock(Reference<XFormComponent>(*aSelectedElement, UNO_QUERY), rIdent); +} + +bool FmXFormShell::executeControlConversionSlot_Lock(const Reference<XFormComponent>& _rxObject, std::string_view rIdent) +{ + if (impl_checkDisposed_Lock()) + return false; + + OSL_ENSURE( _rxObject.is(), "FmXFormShell::executeControlConversionSlot: invalid object!" ); + if ( !_rxObject.is() ) + return false; + + SdrPage* pPage = m_pShell->GetCurPage(); + FmFormPage* pFormPage = dynamic_cast< FmFormPage* >( pPage ); + OSL_ENSURE( pFormPage, "FmXFormShell::executeControlConversionSlot: no current (form) page!" ); + if ( !pFormPage ) + return false; + + OSL_ENSURE( isSolelySelected_Lock(_rxObject), + "FmXFormShell::executeControlConversionSlot: hmm ... shouldn't this parameter be redundant?" ); + + for (size_t lookupSlot = 0; lookupSlot < SAL_N_ELEMENTS(aConvertSlots); ++lookupSlot) + { + if (rIdent == aConvertSlots[lookupSlot]) + { + Reference< XInterface > xNormalizedObject( _rxObject, UNO_QUERY ); + + FmFormObj* pFormObject = nullptr; + SdrObjListIter aPageIter( pFormPage ); + while ( aPageIter.IsMore() ) + { + SdrObject* pCurrent = aPageIter.Next(); + pFormObject = FmFormObj::GetFormObject( pCurrent ); + if ( !pFormObject ) + continue; + + Reference< XInterface > xCurrentNormalized( pFormObject->GetUnoControlModel(), UNO_QUERY ); + if ( xCurrentNormalized.get() == xNormalizedObject.get() ) + break; + + pFormObject = nullptr; + } + + if ( !pFormObject ) + return false; + + OUString sNewName( getServiceNameByControlType( nObjectTypes[ lookupSlot ] ) ); + Reference<XComponentContext> xContext = comphelper::getProcessComponentContext(); + Reference< XControlModel> xNewModel( xContext->getServiceManager()->createInstanceWithContext(sNewName, xContext), UNO_QUERY ); + if (!xNewModel.is()) + return false; + + Reference< XControlModel> xOldModel( pFormObject->GetUnoControlModel() ); + + // transfer properties + Reference< XPropertySet> xOldSet(xOldModel, UNO_QUERY); + Reference< XPropertySet> xNewSet(xNewModel, UNO_QUERY); + + + lang::Locale aNewLanguage = Application::GetSettings().GetUILanguageTag().getLocale(); + TransferFormComponentProperties(xOldSet, xNewSet, aNewLanguage); + + Sequence< css::script::ScriptEventDescriptor> aOldScripts; + Reference< XChild> xChild(xOldModel, UNO_QUERY); + if (xChild.is()) + { + Reference< XIndexAccess> xParent(xChild->getParent(), UNO_QUERY); + + // remember old script events + Reference< css::script::XEventAttacherManager> xEvManager(xChild->getParent(), UNO_QUERY); + if (xParent.is() && xEvManager.is()) + { + sal_Int32 nIndex = getElementPos(xParent, xOldModel); + if (nIndex>=0 && nIndex<xParent->getCount()) + aOldScripts = xEvManager->getScriptEvents(nIndex); + } + + // replace the model within the parent container + Reference< XIndexContainer> xIndexParent(xChild->getParent(), UNO_QUERY); + if (xIndexParent.is()) + { + // the form container works with FormComponents + Reference< XFormComponent> xComponent(xNewModel, UNO_QUERY); + DBG_ASSERT(xComponent.is(), "FmXFormShell::executeControlConversionSlot: the new model is no form component !"); + Any aNewModel(xComponent); + try + { + + sal_Int32 nIndex = getElementPos(xParent, xOldModel); + if (nIndex>=0 && nIndex<xParent->getCount()) + xIndexParent->replaceByIndex(nIndex, aNewModel); + else + { + OSL_FAIL("FmXFormShell::executeControlConversionSlot: could not replace the model !"); + Reference< css::lang::XComponent> xNewComponent(xNewModel, UNO_QUERY); + if (xNewComponent.is()) + xNewComponent->dispose(); + return false; + } + } + catch(Exception&) + { + OSL_FAIL("FmXFormShell::executeControlConversionSlot: could not replace the model !"); + Reference< css::lang::XComponent> xNewComponent(xNewModel, UNO_QUERY); + if (xNewComponent.is()) + xNewComponent->dispose(); + return false; + } + + } + } + + // special handling for the LabelControl-property : can only be set when the model is placed + // within the forms hierarchy + if (::comphelper::hasProperty(FM_PROP_CONTROLLABEL, xOldSet) && ::comphelper::hasProperty(FM_PROP_CONTROLLABEL, xNewSet)) + { + try + { + xNewSet->setPropertyValue(FM_PROP_CONTROLLABEL, xOldSet->getPropertyValue(FM_PROP_CONTROLLABEL)); + } + catch(Exception&) + { + } + + } + + // set new model + pFormObject->SetChanged(); + pFormObject->SetUnoControlModel(xNewModel); + + // transfer script events + // (do this _after_ SetUnoControlModel as we need the new (implicitly created) control) + if (aOldScripts.hasElements()) + { + // find the control for the model + Reference<XControlContainer> xControlContainer(getControlContainerForView_Lock()); + + const Sequence< Reference< XControl> > aControls( xControlContainer->getControls() ); + + Reference< XControl> xControl; + auto pControl = std::find_if(aControls.begin(), aControls.end(), + [&xNewModel](const Reference< XControl>& rControl) { return rControl->getModel() == xNewModel; }); + if (pControl != aControls.end()) + xControl = *pControl; + TransferEventScripts(xNewModel, xControl, aOldScripts); + } + + // transfer value bindings, if possible + { + Reference< XBindableValue > xOldBindable( xOldModel, UNO_QUERY ); + Reference< XBindableValue > xNewBindable( xNewModel, UNO_QUERY ); + if ( xOldBindable.is() ) + { + try + { + if ( xNewBindable.is() ) + xNewBindable->setValueBinding( xOldBindable->getValueBinding() ); + xOldBindable->setValueBinding( nullptr ); + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + // same for list entry sources + { + Reference< XListEntrySink > xOldSink( xOldModel, UNO_QUERY ); + Reference< XListEntrySink > xNewSink( xNewModel, UNO_QUERY ); + if ( xOldSink.is() ) + { + try + { + if ( xNewSink.is() ) + xNewSink->setListEntrySource( xOldSink->getListEntrySource() ); + xOldSink->setListEntrySource( nullptr ); + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + + // create an undo action + FmFormModel* pModel = m_pShell->GetFormModel(); + DBG_ASSERT(pModel != nullptr, "FmXFormShell::executeControlConversionSlot: my shell has no model !"); + if (pModel && pModel->IsUndoEnabled() ) + { + pModel->AddUndo(std::make_unique<FmUndoModelReplaceAction>(*pModel, pFormObject, xOldModel)); + } + else + { + FmUndoModelReplaceAction::DisposeElement( xOldModel ); + } + + return true; + } + } + return false; +} + +bool FmXFormShell::canConvertCurrentSelectionToControl_Lock(std::string_view rIdent) +{ + if ( m_aCurrentSelection.empty() ) + return false; + + InterfaceBag::const_iterator aCheck = m_aCurrentSelection.begin(); + Reference< lang::XServiceInfo > xElementInfo( *aCheck, UNO_QUERY ); + if ( !xElementInfo.is() ) + // no service info -> cannot determine this + return false; + + if ( ++aCheck != m_aCurrentSelection.end() ) + // more than one element + return false; + + if ( Reference< XForm >::query( xElementInfo ).is() ) + // it's a form + return false; + + SdrObjKind nObjectType = getControlTypeByObject( xElementInfo ); + + if ( ( SdrObjKind::FormHidden == nObjectType ) + || ( SdrObjKind::FormControl == nObjectType ) + || ( SdrObjKind::FormGrid == nObjectType ) + ) + return false; // those types cannot be converted + + DBG_ASSERT(SAL_N_ELEMENTS(aConvertSlots) == SAL_N_ELEMENTS(nObjectTypes), + "FmXFormShell::canConvertCurrentSelectionToControl: aConvertSlots & nObjectTypes must have the same size !"); + + for (size_t i = 0; i < SAL_N_ELEMENTS(aConvertSlots); ++i) + if (rIdent == aConvertSlots[i]) + return nObjectTypes[i] != nObjectType; + + return true; // all other slots: assume "yes" +} + +void FmXFormShell::checkControlConversionSlotsForCurrentSelection_Lock(weld::Menu& rMenu) +{ + for (int i = 0, nCount = rMenu.n_children(); i < nCount; ++i) + { + // the context is already of a type that corresponds to the entry -> disable + OString sIdent(aConvertSlots[i]); + rMenu.set_sensitive(sIdent, canConvertCurrentSelectionToControl_Lock(sIdent)); + } +} + +void FmXFormShell::LoopGrids_Lock(LoopGridsSync nSync, LoopGridsFlags nFlags) +{ + if (impl_checkDisposed_Lock()) + return; + + Reference< XIndexContainer> xControlModels(m_xActiveForm, UNO_QUERY); + if (!xControlModels.is()) + return; + + for (sal_Int32 i=0; i<xControlModels->getCount(); ++i) + { + Reference< XPropertySet> xModelSet; + xControlModels->getByIndex(i) >>= xModelSet; + if (!xModelSet.is()) + continue; + + if (!::comphelper::hasProperty(FM_PROP_CLASSID, xModelSet)) + continue; + sal_Int16 nClassId = ::comphelper::getINT16(xModelSet->getPropertyValue(FM_PROP_CLASSID)); + if (FormComponentType::GRIDCONTROL != nClassId) + continue; + + if (!::comphelper::hasProperty(FM_PROP_CURSORCOLOR, xModelSet) || !::comphelper::hasProperty(FM_PROP_ALWAYSSHOWCURSOR, xModelSet) || !::comphelper::hasProperty(FM_PROP_DISPLAYSYNCHRON, xModelSet)) + continue; + + switch (nSync) + { + case LoopGridsSync::DISABLE_SYNC: + { + xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, Any(false)); + } + break; + case LoopGridsSync::FORCE_SYNC: + { + Any aOldVal( xModelSet->getPropertyValue(FM_PROP_DISPLAYSYNCHRON) ); + xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, Any(true)); + xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, aOldVal); + } + break; + case LoopGridsSync::ENABLE_SYNC: + { + xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, Any(true)); + } + break; + } + + if (nFlags & LoopGridsFlags::DISABLE_ROCTRLR) + { + xModelSet->setPropertyValue(FM_PROP_ALWAYSSHOWCURSOR, Any(false)); + Reference< XPropertyState> xModelPropState(xModelSet, UNO_QUERY); + if (xModelPropState.is()) + xModelPropState->setPropertyToDefault(FM_PROP_CURSORCOLOR); + else + xModelSet->setPropertyValue(FM_PROP_CURSORCOLOR, Any()); // this should be the default + } + } +} + + +Reference< XControlContainer > FmXFormShell::getControlContainerForView_Lock() const +{ + if (impl_checkDisposed_Lock()) + return nullptr; + + SdrPageView* pPageView = nullptr; + if ( m_pShell && m_pShell->GetFormView() ) + pPageView = m_pShell->GetFormView()->GetSdrPageView(); + + Reference< XControlContainer> xControlContainer; + if ( pPageView ) + xControlContainer = pPageView->GetPageWindow(0)->GetControlContainer(); + + return xControlContainer; +} + + +void FmXFormShell::ExecuteTabOrderDialog_Lock(const Reference<XTabControllerModel>& _rxForForm) +{ + if (impl_checkDisposed_Lock()) + return; + + OSL_PRECOND( _rxForForm.is(), "FmXFormShell::ExecuteTabOrderDialog: invalid tabbing model!" ); + if ( !_rxForForm.is() ) + return; + + try + { + Reference< XWindow > xParentWindow; + if ( m_pShell->GetViewShell() && m_pShell->GetViewShell()->GetViewFrame() ) + xParentWindow = VCLUnoHelper::GetInterface ( &m_pShell->GetViewShell()->GetViewFrame()->GetWindow() ); + + Reference< dialogs::XExecutableDialog > xDialog = form::TabOrderDialog::createWithModel( + comphelper::getProcessComponentContext(), + _rxForForm, getControlContainerForView_Lock(), xParentWindow + ); + + xDialog->execute(); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmXFormShell::ExecuteTabOrderDialog" ); + } +} + + +void FmXFormShell::ExecuteSearch_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + // a collection of all (logical) forms + FmFormArray().swap(m_aSearchForms); + ::std::vector< OUString > aContextNames; + impl_collectFormSearchContexts_nothrow_Lock( + m_pShell->GetCurPage()->GetForms(), u"", + m_aSearchForms, aContextNames); + + if ( m_aSearchForms.size() != aContextNames.size() ) + { + SAL_WARN ( "svx.form", "FmXFormShell::ExecuteSearch: nonsense!" ); + return; + } + + // filter out the forms which do not contain valid controls at all + { + FmFormArray aValidForms; + ::std::vector< OUString > aValidContexts; + FmFormArray::const_iterator form = m_aSearchForms.begin(); + ::std::vector< OUString >::const_iterator contextName = aContextNames.begin(); + for ( ; form != m_aSearchForms.end(); ++form, ++contextName ) + { + FmSearchContext aTestContext; + aTestContext.nContext = static_cast< sal_Int16 >( form - m_aSearchForms.begin() ); + sal_uInt32 nValidControls = OnSearchContextRequest_Lock(aTestContext); + if ( nValidControls > 0 ) + { + aValidForms.push_back( *form ); + aValidContexts.push_back( *contextName ); + } + } + + m_aSearchForms.swap( aValidForms ); + aContextNames.swap( aValidContexts ); + } + + if (m_aSearchForms.empty() ) + { + // there are no controls that meet all the conditions for a search + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Warning, VclButtonsType::Ok, + SvxResId(RID_STR_NODATACONTROLS))); + xBox->run(); + return; + } + + // now I need another 'initial context' + sal_Int16 nInitialContext = 0; + Reference<XForm> xActiveForm(getActiveForm_Lock()); + for ( size_t i=0; i<m_aSearchForms.size(); ++i ) + { + if (m_aSearchForms.at(i) == xActiveForm) + { + nInitialContext = static_cast<sal_Int16>(i); + break; + } + } + + // If the dialog should initially offer the text of the active control, + // this must have an XTextComponent interface. An addition, this makes + // sense only if the current field is also bound to a table (or whatever) field. + OUString strActiveField; + OUString strInitialText; + // ... this I get from my FormController + DBG_ASSERT(m_xActiveController.is(), "FmXFormShell::ExecuteSearch : no active controller !"); + Reference< XControl> xActiveControl( m_xActiveController->getCurrentControl()); + if (xActiveControl.is()) + { + // the control can tell me its model ... + Reference< XControlModel> xActiveModel( xActiveControl->getModel()); + DBG_ASSERT(xActiveModel.is(), "FmXFormShell::ExecuteSearch : active control has no model !"); + + // I ask the model for the ControlSource property ... + Reference< XPropertySet> xProperties(xActiveControl->getModel(), UNO_QUERY); + if (::comphelper::hasProperty(FM_PROP_CONTROLSOURCE, xProperties) && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xProperties)) + { + Reference< XPropertySet> xField; + xProperties->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + if (xField.is()) // (only when the thing is really bound) + { + // and the control itself for a TextComponent interface (so that I can pick up the text there) + Reference< XTextComponent> xText(xActiveControl, UNO_QUERY); + if (xText.is()) + { + strActiveField = getLabelName(xProperties); + strInitialText = xText->getText(); + } + } + } + else + { + // the control itself has no ControlSource, but maybe it is a GridControl + Reference< XGrid> xGrid(xActiveControl, UNO_QUERY); + if (xGrid.is()) + { + // for strActiveField I need the ControlSource of the column, + // for that the columns container, for that the GridPeer + Reference< XGridPeer> xGridPeer(xActiveControl->getPeer(), UNO_QUERY); + Reference< XIndexAccess> xColumns; + if (xGridPeer.is()) + xColumns = xGridPeer->getColumns(); + + sal_Int16 nViewCol = xGrid->getCurrentColumnPosition(); + sal_Int32 nModelCol = GridView2ModelPos(xColumns, nViewCol); + Reference< XPropertySet> xCurrentCol; + if(xColumns.is()) + xColumns->getByIndex(nModelCol) >>= xCurrentCol; + if (xCurrentCol.is()) + strActiveField = ::comphelper::getString(xCurrentCol->getPropertyValue(FM_PROP_LABEL)); + + // the text of the current column + Reference< XIndexAccess> xColControls(xGridPeer, UNO_QUERY); + Reference< XInterface> xCurControl; + xColControls->getByIndex(nViewCol) >>= xCurControl; + OUString sInitialText; + if (IsSearchableControl(xCurControl, &sInitialText)) + strInitialText = sInitialText; + } + } + } + + // taking care of possible GridControls that I know + LoopGrids_Lock(LoopGridsSync::DISABLE_SYNC); + + // Now I am ready for the dialogue. + // When the potential deadlocks caused by the use of the solar mutex in + // MTs VCLX... classes are eventually cleared, an SM_USETHREAD should be + // placed here, because the search in a separate thread is nevertheless + // somewhat more fluid. Should be, however, somehow made dependent of the + // underlying cursor. DAO for example is not thread-safe. + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractFmSearchDialog> pDialog( + pFact->CreateFmSearchDialog( + m_pShell->GetViewShell()->GetViewFrame()->GetFrameWeld(), + strInitialText, aContextNames, nInitialContext, + LINK(this, FmXFormShell, OnSearchContextRequest_Lock) )); + pDialog->SetActiveField( strActiveField ); + pDialog->SetFoundHandler(LINK(this, FmXFormShell, OnFoundData_Lock)); + pDialog->SetCanceledNotFoundHdl(LINK(this, FmXFormShell, OnCanceledNotFound_Lock)); + pDialog->Execute(); + pDialog.disposeAndClear(); + + // restore GridControls again + LoopGrids_Lock(LoopGridsSync::ENABLE_SYNC, LoopGridsFlags::DISABLE_ROCTRLR); + + m_pShell->GetFormView()->UnMarkAll(m_pShell->GetFormView()->GetSdrPageView()); + // because I marked controls in OnFoundData (if I was there) +} + + +bool FmXFormShell::GetY2KState_Lock(sal_uInt16& n) +{ + if (impl_checkDisposed_Lock()) + return false; + + if (m_pShell->IsDesignMode()) + // in the design mode (without active controls) the main document is to take care of it + return false; + + Reference<XForm> xForm(getActiveForm_Lock()); + if (!xForm.is()) + // no current form (in particular no current control) -> the main document is to take care + return false; + + Reference< XRowSet> xDB(xForm, UNO_QUERY); + DBG_ASSERT(xDB.is(), "FmXFormShell::GetY2KState : current form has no dbform-interface !"); + + Reference< XNumberFormatsSupplier> xSupplier( getNumberFormats(getConnection(xDB))); + if (xSupplier.is()) + { + Reference< XPropertySet> xSet(xSupplier->getNumberFormatSettings()); + if (xSet.is()) + { + try + { + Any aVal( xSet->getPropertyValue("TwoDigitDateStart") ); + aVal >>= n; + return true; + } + catch(Exception&) + { + } + + } + } + return false; +} + + +void FmXFormShell::SetY2KState_Lock(sal_uInt16 n) +{ + if (impl_checkDisposed_Lock()) + return; + + Reference<XForm> xActiveForm(getActiveForm_Lock()); + Reference< XRowSet > xActiveRowSet( xActiveForm, UNO_QUERY ); + if ( xActiveRowSet.is() ) + { + Reference< XNumberFormatsSupplier > xSupplier( getNumberFormats( getConnection( xActiveRowSet ) ) ); + if (xSupplier.is()) + { + Reference< XPropertySet> xSet(xSupplier->getNumberFormatSettings()); + if (xSet.is()) + { + try + { + xSet->setPropertyValue("TwoDigitDateStart", Any(sal_uInt16(n))); + } + catch(Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", ""); + } + + } + return; + } + } + + // no active form found -> iterate through all current forms + Reference< XIndexAccess> xCurrentForms( m_xForms); + if (!xCurrentForms.is()) + { // in the alive mode, my forms are not set, but the ones on the page are + if (m_pShell->GetCurPage()) + xCurrentForms = m_pShell->GetCurPage()->GetForms( false ); + } + if (!xCurrentForms.is()) + return; + + ::comphelper::IndexAccessIterator aIter(xCurrentForms); + Reference< XInterface> xCurrentElement( aIter.Next()); + while (xCurrentElement.is()) + { + // is the current element a DatabaseForm? + Reference< XRowSet> xElementAsRowSet( xCurrentElement, UNO_QUERY ); + if ( xElementAsRowSet.is() ) + { + Reference< XNumberFormatsSupplier > xSupplier( getNumberFormats( getConnection( xElementAsRowSet ) ) ); + if (!xSupplier.is()) + continue; + + Reference< XPropertySet> xSet(xSupplier->getNumberFormatSettings()); + if (xSet.is()) + { + try + { + xSet->setPropertyValue("TwoDigitDateStart", Any(sal_uInt16(n))); + } + catch(Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", ""); + } + + } + } + xCurrentElement = aIter.Next(); + } +} + + +void FmXFormShell::CloseExternalFormViewer_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + if (!m_xExternalViewController.is()) + return; + + Reference< css::frame::XFrame> xExternalViewFrame( m_xExternalViewController->getFrame()); + Reference< css::frame::XDispatchProvider> xCommLink(xExternalViewFrame, UNO_QUERY); + if (!xCommLink.is()) + return; + + xExternalViewFrame->setComponent(nullptr,nullptr); + ::comphelper::disposeComponent(xExternalViewFrame); + m_xExternalViewController = nullptr; + m_xExtViewTriggerController = nullptr; + m_xExternalDisplayedForm = nullptr; +} + + +Reference<XResultSet> FmXFormShell::getInternalForm_Lock(const Reference<XResultSet>& _xForm) const +{ + if (impl_checkDisposed_Lock()) + return nullptr; + + Reference< runtime::XFormController> xExternalCtrlr(m_xExternalViewController, UNO_QUERY); + if (xExternalCtrlr.is() && (_xForm == xExternalCtrlr->getModel())) + { + DBG_ASSERT(m_xExternalDisplayedForm.is(), "FmXFormShell::getInternalForm : invalid external form !"); + return m_xExternalDisplayedForm; + } + return _xForm; +} + + +Reference<XForm> FmXFormShell::getInternalForm_Lock(const Reference<XForm>& _xForm) const +{ + if (impl_checkDisposed_Lock()) + return nullptr; + + Reference< runtime::XFormController > xExternalCtrlr(m_xExternalViewController, UNO_QUERY); + if (xExternalCtrlr.is() && (_xForm == xExternalCtrlr->getModel())) + { + DBG_ASSERT(m_xExternalDisplayedForm.is(), "FmXFormShell::getInternalForm : invalid external form !"); + return Reference< XForm>(m_xExternalDisplayedForm, UNO_QUERY); + } + return _xForm; +} + + +namespace +{ + bool lcl_isNavigationRelevant( sal_Int32 _nWhich ) + { + return ( _nWhich == SID_FM_RECORD_FIRST ) + || ( _nWhich == SID_FM_RECORD_PREV ) + || ( _nWhich == SID_FM_RECORD_NEXT ) + || ( _nWhich == SID_FM_RECORD_LAST ) + || ( _nWhich == SID_FM_RECORD_NEW ); + } +} + + +bool FmXFormShell::IsFormSlotEnabled( sal_Int32 _nSlot, FeatureState* _pCompleteState ) const +{ + const svx::ControllerFeatures& rController = + lcl_isNavigationRelevant( _nSlot ) + ? getNavControllerFeatures_Lock() + : getActiveControllerFeatures_Lock(); + + if ( !_pCompleteState ) + return rController->isEnabled( _nSlot ); + + rController->getState( _nSlot, *_pCompleteState ); + return _pCompleteState->Enabled; +} + + +void FmXFormShell::ExecuteFormSlot_Lock( sal_Int32 _nSlot ) +{ + const svx::ControllerFeatures& rController = + lcl_isNavigationRelevant( _nSlot ) + ? getNavControllerFeatures_Lock() + : getActiveControllerFeatures_Lock(); + + rController->execute( _nSlot ); + + if ( _nSlot != SID_FM_RECORD_UNDO ) + return; + + // if we're doing an UNDO, *and* if the affected form is the form which we also display + // as external view, then we need to reset the controls of the external form, too + if (getInternalForm_Lock(getActiveForm_Lock()) != m_xExternalDisplayedForm) + return; + + Reference< XIndexAccess > xContainer( m_xExternalDisplayedForm, UNO_QUERY ); + if ( !xContainer.is() ) + return; + + Reference< XReset > xReset; + for ( sal_Int32 i = 0; i < xContainer->getCount(); ++i ) + { + if ( ( xContainer->getByIndex( i ) >>= xReset ) && xReset.is() ) + { + // no resets on sub forms + Reference< XForm > xAsForm( xReset, UNO_QUERY ); + if ( !xAsForm.is() ) + xReset->reset(); + } + } +} + + +void FmXFormShell::impl_switchActiveControllerListening_Lock(const bool _bListen) +{ + if ( !m_xActiveController.is() ) + return; + + if ( _bListen ) + m_xActiveController->addEventListener( static_cast<XFormControllerListener*>(this) ); + else + m_xActiveController->removeEventListener( static_cast<XFormControllerListener*>(this) ); +} + + +void FmXFormShell::setActiveController_Lock(const Reference<runtime::XFormController>& xController, bool _bNoSaveOldContent) +{ + if (impl_checkDisposed_Lock()) + return; + + if (m_bChangingDesignMode) + return; + DBG_ASSERT(!m_pShell->IsDesignMode(), "only to be used in alive mode"); + + // if the routine has been called a second time, + // the focus should no longer be transferred + if (m_bInActivate) + { + m_bSetFocus = xController != m_xActiveController; + return; + } + + if (xController == m_xActiveController) + return; + + // switch all nav dispatchers belonging to the form of the current nav controller to 'non active' + Reference< XResultSet> xNavigationForm; + if (m_xNavigationController.is()) + xNavigationForm.set(m_xNavigationController->getModel(), UNO_QUERY); + + m_bInActivate = true; + + // check if the 2 controllers serve different forms + Reference< XResultSet> xOldForm; + if (m_xActiveController.is()) + xOldForm.set(m_xActiveController->getModel(), UNO_QUERY); + Reference< XResultSet> xNewForm; + if (xController.is()) + xNewForm = Reference< XResultSet>(xController->getModel(), UNO_QUERY); + xOldForm = getInternalForm_Lock(xOldForm); + xNewForm = getInternalForm_Lock(xNewForm); + + bool bDifferentForm = ( xOldForm.get() != xNewForm.get() ); + bool bNeedSave = bDifferentForm && !_bNoSaveOldContent; + // we save the content of the old form if we move to a new form, and saving old content is allowed + + if ( m_xActiveController.is() && bNeedSave ) + { + // save content on change of the controller; a commit has already been executed + if ( m_aActiveControllerFeatures->commitCurrentControl() ) + { + m_bSetFocus = true; + if ( m_aActiveControllerFeatures->isModifiedRow() ) + { + bool bIsNew = m_aActiveControllerFeatures->isInsertionRow(); + bool bResult = m_aActiveControllerFeatures->commitCurrentRecord(); + if ( !bResult && m_bSetFocus ) + { + // if we couldn't save the current record, set the focus back to the + // current control + Reference< XWindow > xWindow( m_xActiveController->getCurrentControl(), UNO_QUERY ); + if ( xWindow.is() ) + xWindow->setFocus(); + m_bInActivate = false; + return; + } + else if ( bResult && bIsNew ) + { + Reference< XResultSet > xCursor( m_aActiveControllerFeatures->getCursor() ); + if ( xCursor.is() ) + { + DO_SAFE( xCursor->last(); ); + } + } + } + } + } + + stopListening_Lock(); + + impl_switchActiveControllerListening_Lock(false); + + m_aActiveControllerFeatures.dispose(); + m_xActiveController = xController; + if ( m_xActiveController.is() ) + m_aActiveControllerFeatures.assign( m_xActiveController ); + + impl_switchActiveControllerListening_Lock(true); + + if ( m_xActiveController.is() ) + m_xActiveForm = getInternalForm_Lock(Reference<XForm>(m_xActiveController->getModel(), UNO_QUERY)); + else + m_xActiveForm = nullptr; + + startListening_Lock(); + + // activate all dispatchers belonging to form of the new navigation controller + xNavigationForm = nullptr; + if (m_xNavigationController.is()) + xNavigationForm.set(m_xNavigationController->getModel(), UNO_QUERY); + + m_bInActivate = false; + + m_pShell->UIFeatureChanged(); + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell); + + InvalidateSlot_Lock(SID_FM_FILTER_NAVIGATOR_CONTROL, true); +} + + +void FmXFormShell::getCurrentSelection_Lock(InterfaceBag& /* [out] */ _rSelection) const +{ + _rSelection = m_aCurrentSelection; +} + + +bool FmXFormShell::setCurrentSelectionFromMark_Lock(const SdrMarkList& _rMarkList) +{ + m_aLastKnownMarkedControls.clear(); + + if ( ( _rMarkList.GetMarkCount() > 0 ) && isControlList( _rMarkList ) ) + collectInterfacesFromMarkList( _rMarkList, m_aLastKnownMarkedControls ); + + return setCurrentSelection_Lock(o3tl::sorted_vector(m_aLastKnownMarkedControls)); +} + + +bool FmXFormShell::selectLastMarkedControls_Lock() +{ + return setCurrentSelection_Lock(o3tl::sorted_vector(m_aLastKnownMarkedControls)); +} + + +bool FmXFormShell::setCurrentSelection_Lock( InterfaceBag&& _rSelection ) +{ + if (impl_checkDisposed_Lock()) + return false; + + DBG_ASSERT( m_pShell->IsDesignMode(), "FmXFormShell::setCurrentSelection: only to be used in design mode!" ); + + if ( _rSelection.empty() && m_aCurrentSelection.empty() ) + // nothing to do + return false; + + if ( _rSelection.size() == m_aCurrentSelection.size() ) + { + InterfaceBag::const_iterator aNew = _rSelection.begin(); + InterfaceBag::const_iterator aOld = m_aCurrentSelection.begin(); + for ( ; aNew != _rSelection.end(); ++aNew, ++aOld ) + { + OSL_ENSURE( Reference< XInterface >( *aNew, UNO_QUERY ).get() == aNew->get(), "FmXFormShell::setCurrentSelection: new interface not normalized!" ); + OSL_ENSURE( Reference< XInterface >( *aOld, UNO_QUERY ).get() == aOld->get(), "FmXFormShell::setCurrentSelection: old interface not normalized!" ); + + if ( aNew->get() != aOld->get() ) + break; + } + + if ( aNew == _rSelection.end() ) + // both bags equal + return false; + } + + // the following is some strange code to ensure that when you have two grid controls in a document, + // only one of them can have a selected column. + // TODO: this should happen elsewhere, but not here - shouldn't it? + if ( !m_aCurrentSelection.empty() ) + { + Reference< XChild > xCur; if ( m_aCurrentSelection.size() == 1 ) xCur.set(*m_aCurrentSelection.begin(), css::uno::UNO_QUERY); + Reference< XChild > xNew; if ( _rSelection.size() == 1 ) xNew.set(*_rSelection.begin(), css::uno::UNO_QUERY); + + // is there nothing to be selected, or the parents differ, and the parent of the current object + // is a selection supplier, then deselect + if ( xCur.is() && ( !xNew.is() || ( xCur->getParent() != xNew->getParent() ) ) ) + { + Reference< XSelectionSupplier > xSel( xCur->getParent(), UNO_QUERY ); + if ( xSel.is() ) + xSel->select( Any() ); + } + } + + m_aCurrentSelection = _rSelection; + + // determine the form which all the selected objects belong to, if any + Reference< XForm > xNewCurrentForm; + for (const auto& rpSelection : m_aCurrentSelection) + { + Reference< XForm > xThisRoundsForm( GetForm( rpSelection ) ); + OSL_ENSURE( xThisRoundsForm.is(), "FmXFormShell::setCurrentSelection: *everything* should belong to a form!" ); + + if ( !xNewCurrentForm.is() ) + { // the first form we encountered + xNewCurrentForm = xThisRoundsForm; + } + else if ( xNewCurrentForm != xThisRoundsForm ) + { // different forms -> no "current form" at all + xNewCurrentForm.clear(); + break; + } + } + + if ( !m_aCurrentSelection.empty() ) + impl_updateCurrentForm_Lock(xNewCurrentForm); + + // ensure some slots are updated + for (sal_Int16 i : SelObjectSlotMap) + InvalidateSlot_Lock(i, false); + + return true; +} + + +bool FmXFormShell::isSolelySelected_Lock(const Reference<XInterface>& _rxObject) +{ + return ( m_aCurrentSelection.size() == 1 ) && ( *m_aCurrentSelection.begin() == _rxObject ); +} + + +void FmXFormShell::forgetCurrentForm_Lock() +{ + if ( !m_xCurrentForm.is() ) + return; + + // reset ... + impl_updateCurrentForm_Lock(nullptr); + + // ... and try finding a new current form + // #i88186# / 2008-04-12 / frank.schoenheit@sun.com + impl_defaultCurrentForm_nothrow_Lock(); +} + + +void FmXFormShell::impl_updateCurrentForm_Lock(const Reference<XForm>& _rxNewCurForm) +{ + if (impl_checkDisposed_Lock()) + return; + + m_xCurrentForm = _rxNewCurForm; + + // propagate to the FormPage(Impl) + FmFormPage* pPage = m_pShell->GetCurPage(); + if ( pPage ) + pPage->GetImpl().setCurForm( m_xCurrentForm ); + + // ensure the UI which depends on the current form is up-to-date + for (sal_Int16 i : DlgSlotMap) + InvalidateSlot_Lock(i, false); +} + + +void FmXFormShell::startListening_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + Reference< XRowSet> xDatabaseForm(m_xActiveForm, UNO_QUERY); + if (xDatabaseForm.is() && getConnection(xDatabaseForm).is()) + { + Reference< XPropertySet> xActiveFormSet(m_xActiveForm, UNO_QUERY); + if (xActiveFormSet.is()) + { + // if there is a data source, then build the listener + // TODO: this is strange - shouldn't this depend on a isLoaded instead of + // a "has command value"? Finally, the command value only means that it was + // intended to be loaded, not that it actually *is* loaded + OUString aSource = ::comphelper::getString(xActiveFormSet->getPropertyValue(FM_PROP_COMMAND)); + if (!aSource.isEmpty()) + { + m_bDatabaseBar = true; + + xActiveFormSet->getPropertyValue(FM_PROP_NAVIGATION) >>= m_eNavigate; + + switch (m_eNavigate) + { + case NavigationBarMode_PARENT: + { + // search for the controller via which navigation is possible + Reference< XChild> xChild = m_xActiveController; + Reference< runtime::XFormController > xParent; + while (xChild.is()) + { + xChild.set(xChild->getParent(), UNO_QUERY); + xParent.set(xChild, UNO_QUERY); + Reference< XPropertySet> xParentSet; + if (xParent.is()) + xParentSet.set(xParent->getModel(), UNO_QUERY); + if (xParentSet.is()) + { + xParentSet->getPropertyValue(FM_PROP_NAVIGATION) >>= m_eNavigate; + if (m_eNavigate == NavigationBarMode_CURRENT) + break; + } + } + m_xNavigationController = xParent; + } + break; + + case NavigationBarMode_CURRENT: + m_xNavigationController = m_xActiveController; + break; + + default: + m_xNavigationController = nullptr; + m_bDatabaseBar = false; + } + + m_aNavControllerFeatures.dispose(); + if ( m_xNavigationController.is() && ( m_xNavigationController != m_xActiveController ) ) + m_aNavControllerFeatures.assign( m_xNavigationController ); + + // because of RecordCount, listen at the controller which controls the navigation + Reference< XPropertySet> xNavigationSet; + if (m_xNavigationController.is()) + { + xNavigationSet.set(m_xNavigationController->getModel(), UNO_QUERY); + if (xNavigationSet.is()) + xNavigationSet->addPropertyChangeListener(FM_PROP_ROWCOUNT,this); + } + return; + } + } + } + + m_eNavigate = NavigationBarMode_NONE; + m_bDatabaseBar = false; + m_xNavigationController = nullptr; +} + + +void FmXFormShell::stopListening_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + Reference< XRowSet> xDatabaseForm(m_xActiveForm, UNO_QUERY); + if ( xDatabaseForm.is() ) + { + if (m_xNavigationController.is()) + { + Reference< XPropertySet> xSet(m_xNavigationController->getModel(), UNO_QUERY); + if (xSet.is()) + xSet->removePropertyChangeListener(FM_PROP_ROWCOUNT, this); + + } + } + + m_bDatabaseBar = false; + m_eNavigate = NavigationBarMode_NONE; + m_xNavigationController = nullptr; +} + + +void FmXFormShell::ShowSelectionProperties_Lock(bool bShow) +{ + if (impl_checkDisposed_Lock()) + return; + + // if the window is already visible, only update the state + bool bHasChild = m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_SHOW_PROPERTIES ); + if ( bHasChild && bShow ) + UpdateSlot_Lock(SID_FM_PROPERTY_CONTROL); + + // else toggle state + else + m_pShell->GetViewShell()->GetViewFrame()->ToggleChildWindow(SID_FM_SHOW_PROPERTIES); + + InvalidateSlot_Lock(SID_FM_PROPERTIES, false); + InvalidateSlot_Lock(SID_FM_CTL_PROPERTIES, false); +} + + +IMPL_LINK(FmXFormShell, OnFoundData_Lock, FmFoundRecordInformation&, rfriWhere, void) +{ + if (impl_checkDisposed_Lock()) + return; + + DBG_ASSERT((rfriWhere.nContext >= 0) && (o3tl::make_unsigned(rfriWhere.nContext) < m_aSearchForms.size()), + "FmXFormShell::OnFoundData : invalid context!"); + Reference< XForm> xForm( m_aSearchForms.at(rfriWhere.nContext)); + DBG_ASSERT(xForm.is(), "FmXFormShell::OnFoundData : invalid form!"); + + Reference< XRowLocate> xCursor(xForm, UNO_QUERY); + if (!xCursor.is()) + return; // what should I do there? + + // to the record + try + { + xCursor->moveToBookmark(rfriWhere.aPosition); + } + catch(const SQLException&) + { + OSL_FAIL("Can position on bookmark!"); + } + + LoopGrids_Lock(LoopGridsSync::FORCE_SYNC); + + // and to the field (for that, I collected the XVclComponent interfaces before the start of the search) + SAL_WARN_IF(o3tl::make_unsigned(rfriWhere.nFieldPos) >= + m_arrSearchedControls.size(), + "svx.form", "FmXFormShell::OnFoundData : invalid index!"); + SdrObject* pObject = m_arrSearchedControls.at(rfriWhere.nFieldPos); + + m_pShell->GetFormView()->UnMarkAll(m_pShell->GetFormView()->GetSdrPageView()); + m_pShell->GetFormView()->MarkObj(pObject, m_pShell->GetFormView()->GetSdrPageView()); + + FmFormObj* pFormObject = FmFormObj::GetFormObject( pObject ); + Reference< XControlModel > xControlModel( pFormObject ? pFormObject->GetUnoControlModel() : Reference< XControlModel >() ); + DBG_ASSERT( xControlModel.is(), "FmXFormShell::OnFoundData: invalid control!" ); + if ( !xControlModel.is() ) + return; + + // disable the permanent cursor for the last grid we found a record + if (m_xLastGridFound.is() && (m_xLastGridFound != xControlModel)) + { + Reference< XPropertySet> xOldSet(m_xLastGridFound, UNO_QUERY); + xOldSet->setPropertyValue(FM_PROP_ALWAYSSHOWCURSOR, Any( false ) ); + Reference< XPropertyState> xOldSetState(xOldSet, UNO_QUERY); + if (xOldSetState.is()) + xOldSetState->setPropertyToDefault(FM_PROP_CURSORCOLOR); + else + xOldSet->setPropertyValue(FM_PROP_CURSORCOLOR, Any()); + } + + // if the field is in a GridControl, I have to additionally go into the corresponding column there + sal_Int32 nGridColumn = m_arrRelativeGridColumn[rfriWhere.nFieldPos]; + if (nGridColumn != -1) + { // unfortunately, I have to first get the control again + Reference<XControl> xControl(pFormObject ? impl_getControl_Lock(xControlModel, *pFormObject) : Reference<XControl>()); + Reference< XGrid> xGrid(xControl, UNO_QUERY); + DBG_ASSERT(xGrid.is(), "FmXFormShell::OnFoundData : invalid control!"); + // if one of the asserts fires, I probably did something wrong on building of m_arrSearchedControls + + // enable a permanent cursor for the grid so we can see the found text + Reference< XPropertySet> xModelSet(xControlModel, UNO_QUERY); + DBG_ASSERT(xModelSet.is(), "FmXFormShell::OnFoundData : invalid control model (no property set) !"); + xModelSet->setPropertyValue( FM_PROP_ALWAYSSHOWCURSOR, Any( true ) ); + xModelSet->setPropertyValue( FM_PROP_CURSORCOLOR, Any( COL_LIGHTRED ) ); + m_xLastGridFound = xControlModel; + + if ( xGrid.is() ) + xGrid->setCurrentColumnPosition(static_cast<sal_Int16>(nGridColumn)); + } + + // As the cursor has been repositioned, I have (in positioned) invalidated + // my form bar slots. But that does not take effect here unfortunately, as + // generally the (modal) search dialog is of course at the top ... So, force ... + sal_uInt16 nPos = 0; + while (DatabaseSlotMap[nPos]) + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Update(DatabaseSlotMap[nPos++]); + // unfortunately the update goes against the invalidate with only individual slots +} + + +IMPL_LINK(FmXFormShell, OnCanceledNotFound_Lock, FmFoundRecordInformation&, rfriWhere, void) +{ + if (impl_checkDisposed_Lock()) + return; + + DBG_ASSERT((rfriWhere.nContext >= 0) && (o3tl::make_unsigned(rfriWhere.nContext) < m_aSearchForms.size()), + "FmXFormShell::OnCanceledNotFound : invalid context!"); + Reference< XForm> xForm( m_aSearchForms.at(rfriWhere.nContext)); + DBG_ASSERT(xForm.is(), "FmXFormShell::OnCanceledNotFound : invalid form!"); + + Reference< XRowLocate> xCursor(xForm, UNO_QUERY); + if (!xCursor.is()) + return; // what should I do there? + + // to the record + try + { + xCursor->moveToBookmark(rfriWhere.aPosition); + } + catch(const SQLException&) + { + OSL_FAIL("Can position on bookmark!"); + } + + + m_pShell->GetFormView()->UnMarkAll(m_pShell->GetFormView()->GetSdrPageView()); +} + + +IMPL_LINK(FmXFormShell, OnSearchContextRequest_Lock, FmSearchContext&, rfmscContextInfo, sal_uInt32) +{ + if (impl_checkDisposed_Lock()) + return 0; + + DBG_ASSERT(rfmscContextInfo.nContext < static_cast<sal_Int16>(m_aSearchForms.size()), "FmXFormShell::OnSearchContextRequest : invalid parameter !"); + Reference< XForm> xForm( m_aSearchForms.at(rfmscContextInfo.nContext)); + DBG_ASSERT(xForm.is(), "FmXFormShell::OnSearchContextRequest : unexpected : invalid context !"); + + Reference< XResultSet> xIter(xForm, UNO_QUERY); + DBG_ASSERT(xIter.is(), "FmXFormShell::OnSearchContextRequest : unexpected : context has no iterator !"); + + + // assemble the list of fields to involve (that is, the ControlSources of all fields that have such a property) + OUString strFieldList, sFieldDisplayNames; + m_arrSearchedControls.clear(); + m_arrRelativeGridColumn.clear(); + + // small problem: To mark found fields, I need SdrObjects. To determine which controls + // to include in the search, I need Controls (that is, XControl interfaces). So I have + // to iterate over one of them and get the other in some way. Unfortunately, there is + // no direct connection between the two worlds (except from a GetUnoControl to a + // SdrUnoObject, but this requires an OutputDevice I can not do anything with. + // However I can get to the Model from the Control and also from the SdrObject, and in + // this way the assignment SdrObject<->Control is possible with a double loop. + // The alternative to this (ugly but certainly not entirely fixable) solution would be + // to renounce the caching of the SdrObjects, which would lead to significant extra + // work in OnFoundData (since there I'd have to get the SdrObject first thing every + // time). But since OnFoundData is usually called more often than ExecuteSearch, I'll + // do that here. + + Reference< XNameAccess> xValidFormFields; + Reference< XColumnsSupplier> xSupplyCols(xIter, UNO_QUERY); + DBG_ASSERT(xSupplyCols.is(), "FmXFormShell::OnSearchContextRequest : invalid cursor : no columns supplier !"); + if (xSupplyCols.is()) + xValidFormFields = xSupplyCols->getColumns(); + DBG_ASSERT(xValidFormFields.is(), "FmXFormShell::OnSearchContextRequest : form has no fields !"); + + // current Page/Controller + FmFormPage* pCurrentPage = m_pShell->GetCurPage(); + assert(pCurrentPage && "FmXFormShell::OnSearchContextRequest : no page !"); + // Search all SdrControls of this page... + OUString sControlSource, aName; + + SdrObjListIter aPageIter( pCurrentPage ); + while ( aPageIter.IsMore() ) + { + SdrObject* pCurrent = aPageIter.Next(); + FmFormObj* pFormObject = FmFormObj::GetFormObject( pCurrent ); + // note that in case pCurrent is a virtual object, pFormObject points to the referenced object + + if ( !pFormObject ) + continue; + + // the current object's model, in different tastes + Reference< XControlModel> xControlModel( pFormObject->GetUnoControlModel() ); + Reference< XFormComponent > xCurrentFormComponent( xControlModel, UNO_QUERY ); + DBG_ASSERT( xCurrentFormComponent.is(), "FmXFormShell::OnSearchContextRequest: invalid objects!" ); + if ( !xCurrentFormComponent.is() ) + continue; + + // does the component belong to the form which we're interested in? + if ( xCurrentFormComponent->getParent() != xForm ) + continue; + + // ... ask for the ControlSource property + SearchableControlIterator iter( xCurrentFormComponent ); + Reference< XControl> xControl; + // the control that has model xControlModel + // (the following while can be passed through several times, without the Control + // being modified, so I don't have to search every time from scratch) + + Reference< XInterface > xSearchable( iter.Next() ); + while ( xSearchable.is() ) + { + sControlSource = iter.getCurrentValue(); + if ( sControlSource.isEmpty() ) + { + // the current element has no ControlSource, so it is a GridControl (that + // is the only thing that still permits the SearchableControlIteratore) + xControl = impl_getControl_Lock(xControlModel, *pFormObject); + DBG_ASSERT(xControl.is(), "FmXFormShell::OnSearchContextRequest : didn't ::std::find a control with requested model !"); + + Reference< XGridPeer> xGridPeer; + if ( xControl.is() ) + xGridPeer.set( xControl->getPeer(), UNO_QUERY ); + do + { + if (!xGridPeer.is()) + break; + + Reference< XIndexAccess> xPeerContainer(xGridPeer, UNO_QUERY); + if (!xPeerContainer.is()) + break; + + Reference< XIndexAccess> xModelColumns = xGridPeer->getColumns(); + DBG_ASSERT(xModelColumns.is(), "FmXFormShell::OnSearchContextRequest : there is a grid control without columns !"); + // the case 'no columns' should be indicated with an empty container, I think ... + DBG_ASSERT(xModelColumns->getCount() >= xPeerContainer->getCount(), "FmXFormShell::OnSearchContextRequest : impossible : have more view than model columns !"); + + Reference< XInterface> xCurrentColumn; + for (sal_Int32 nViewPos=0; nViewPos<xPeerContainer->getCount(); ++nViewPos) + { + xPeerContainer->getByIndex(nViewPos) >>= xCurrentColumn; + if (!xCurrentColumn.is()) + continue; + + // can we use this column control for searching ? + if (!IsSearchableControl(xCurrentColumn)) + continue; + + sal_Int32 nModelPos = GridView2ModelPos(xModelColumns, nViewPos); + Reference< XPropertySet> xCurrentColModel; + xModelColumns->getByIndex(nModelPos) >>= xCurrentColModel; + aName = ::comphelper::getString(xCurrentColModel->getPropertyValue(FM_PROP_CONTROLSOURCE)); + // the cursor has a field matching the control source ? + if (xValidFormFields->hasByName(aName)) + { + strFieldList += aName + ";"; + + sFieldDisplayNames += + ::comphelper::getString(xCurrentColModel->getPropertyValue(FM_PROP_LABEL)) + + ";"; + + rfmscContextInfo.arrFields.push_back(xCurrentColumn); + + // and the SdrOject to the Field + m_arrSearchedControls.push_back(pCurrent); + // the number of the column + m_arrRelativeGridColumn.push_back(nViewPos); + } + } + } while (false); + } + else + { + if (!sControlSource.isEmpty() && xValidFormFields->hasByName(sControlSource)) + { + // now I need the Control to SdrObject + if (!xControl.is()) + { + xControl = impl_getControl_Lock(xControlModel, *pFormObject); + DBG_ASSERT(xControl.is(), "FmXFormShell::OnSearchContextRequest : didn't ::std::find a control with requested model !"); + } + + if (IsSearchableControl(xControl)) + { + // all tests passed -> take along in the list + strFieldList += sControlSource + ";"; + + // the label which should appear for the control : + sFieldDisplayNames += + getLabelName(Reference< XPropertySet>(xControlModel, UNO_QUERY)) + + ";"; + + // mark the SdrObject (accelerates the treatment in OnFoundData) + m_arrSearchedControls.push_back(pCurrent); + + // the number of the column (here a dummy, since it is only interesting for GridControls) + m_arrRelativeGridColumn.push_back(-1); + + // and for the formatted search... + rfmscContextInfo.arrFields.emplace_back( xControl, UNO_QUERY ); + } + } + } + + xSearchable = iter.Next(); + } + } + + strFieldList = comphelper::string::stripEnd(strFieldList, ';'); + sFieldDisplayNames = comphelper::string::stripEnd(sFieldDisplayNames, ';'); + + if (rfmscContextInfo.arrFields.empty()) + { + rfmscContextInfo.arrFields.clear(); + rfmscContextInfo.xCursor = nullptr; + rfmscContextInfo.strUsedFields.clear(); + return 0; + } + + rfmscContextInfo.xCursor = xIter; + rfmscContextInfo.strUsedFields = strFieldList; + rfmscContextInfo.sFieldDisplayNames = sFieldDisplayNames; + + // 66463 - 31.05.99 - FS + // when the cursor is a non-STANDARD RecordMode, set it back + Reference< XPropertySet> xCursorSet(rfmscContextInfo.xCursor, UNO_QUERY); + Reference< XResultSetUpdate> xUpdateCursor(rfmscContextInfo.xCursor, UNO_QUERY); + if (xUpdateCursor.is() && xCursorSet.is()) + { + if (::comphelper::getBOOL(xCursorSet->getPropertyValue(FM_PROP_ISNEW))) + xUpdateCursor->moveToCurrentRow(); + else if (::comphelper::getBOOL(xCursorSet->getPropertyValue(FM_PROP_ISMODIFIED))) + xUpdateCursor->cancelRowUpdates(); + } + + return rfmscContextInfo.arrFields.size(); +} + + // XContainerListener + +void SAL_CALL FmXFormShell::elementInserted(const ContainerEvent& evt) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock()) + return; + + // new object to listen to + Reference< XInterface> xTemp; + evt.Element >>= xTemp; + AddElement_Lock(xTemp); + + m_pShell->DetermineForms(true); +} + + +void SAL_CALL FmXFormShell::elementReplaced(const ContainerEvent& evt) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock() ) + return; + + Reference< XInterface> xTemp; + evt.ReplacedElement >>= xTemp; + RemoveElement_Lock(xTemp); + evt.Element >>= xTemp; + AddElement_Lock(xTemp); +} + + +void SAL_CALL FmXFormShell::elementRemoved(const ContainerEvent& evt) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock()) + return; + + Reference< XInterface> xTemp; + evt.Element >>= xTemp; + RemoveElement_Lock(xTemp); + + m_pShell->DetermineForms(true); +} + + +void FmXFormShell::UpdateForms_Lock(bool _bInvalidate) +{ + if (impl_checkDisposed_Lock()) + return; + + Reference< XIndexAccess > xForms; + + FmFormPage* pPage = m_pShell->GetCurPage(); + if ( pPage && m_pShell->m_bDesignMode ) + xForms = pPage->GetForms( false ); + + if ( m_xForms != xForms ) + { + RemoveElement_Lock( m_xForms ); + m_xForms = xForms; + AddElement_Lock(m_xForms); + } + + SolarMutexGuard g; + m_pShell->DetermineForms( _bInvalidate ); +} + + +void FmXFormShell::AddElement_Lock(const Reference<XInterface>& _xElement) +{ + if (impl_checkDisposed_Lock()) + return; + impl_AddElement_nothrow(_xElement); +} + +void FmXFormShell::impl_AddElement_nothrow(const Reference< XInterface>& Element) +{ + // listen at the container + const Reference< XIndexContainer> xContainer(Element, UNO_QUERY); + if (xContainer.is()) + { + const sal_uInt32 nCount = xContainer->getCount(); + Reference< XInterface> xElement; + for (sal_uInt32 i = 0; i < nCount; ++i) + { + xElement.set(xContainer->getByIndex(i),UNO_QUERY); + impl_AddElement_nothrow(xElement); + } + + const Reference< XContainer> xCont(Element, UNO_QUERY); + if (xCont.is()) + xCont->addContainerListener(this); + } + + const Reference< css::view::XSelectionSupplier> xSelSupplier(Element, UNO_QUERY); + if (xSelSupplier.is()) + xSelSupplier->addSelectionChangeListener(this); +} + + +void FmXFormShell::RemoveElement_Lock(const Reference<XInterface>& Element) +{ + if (impl_checkDisposed_Lock()) + return; + impl_RemoveElement_nothrow_Lock(Element); +} + +void FmXFormShell::impl_RemoveElement_nothrow_Lock(const Reference<XInterface>& Element) +{ + const Reference< css::view::XSelectionSupplier> xSelSupplier(Element, UNO_QUERY); + if (xSelSupplier.is()) + xSelSupplier->removeSelectionChangeListener(this); + + // remove connection to children + const Reference< XIndexContainer> xContainer(Element, UNO_QUERY); + if (xContainer.is()) + { + const Reference< XContainer> xCont(Element, UNO_QUERY); + if (xCont.is()) + xCont->removeContainerListener(this); + + const sal_uInt32 nCount = xContainer->getCount(); + Reference< XInterface> xElement; + for (sal_uInt32 i = 0; i < nCount; i++) + { + xElement.set(xContainer->getByIndex(i),UNO_QUERY); + impl_RemoveElement_nothrow_Lock(xElement); + } + } + + auto wasSelectedPos = m_aCurrentSelection.find( Element ); + if ( wasSelectedPos != m_aCurrentSelection.end() ) + m_aCurrentSelection.erase( wasSelectedPos ); +} + + +void SAL_CALL FmXFormShell::selectionChanged(const lang::EventObject& rEvent) +{ + SolarMutexGuard g; + + if (impl_checkDisposed_Lock()) + return; + + Reference< XSelectionSupplier > xSupplier( rEvent.Source, UNO_QUERY ); + Reference< XInterface > xSelObj( xSupplier->getSelection(), UNO_QUERY ); + // a selection was removed, this can only be done by the shell + if ( !xSelObj.is() ) + return; + + EnableTrackProperties_Lock(false); + + bool bMarkChanged = m_pShell->GetFormView()->checkUnMarkAll(rEvent.Source); + + InterfaceBag aNewSelection; + aNewSelection.insert( Reference<XInterface>( xSelObj, UNO_QUERY ) ); + + if (setCurrentSelection_Lock(std::move(aNewSelection)) && IsPropBrwOpen_Lock()) + ShowSelectionProperties_Lock(true); + + EnableTrackProperties_Lock(true); + + if ( bMarkChanged ) + m_pShell->NotifyMarkListChanged( m_pShell->GetFormView() ); +} + + +IMPL_LINK_NOARG(FmXFormShell, OnTimeOut_Lock, Timer*, void) +{ + if (impl_checkDisposed_Lock()) + return; + + if (m_pShell->IsDesignMode() && m_pShell->GetFormView()) + SetSelection_Lock(m_pShell->GetFormView()->GetMarkedObjectList()); +} + + +void FmXFormShell::SetSelectionDelayed_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + if (m_pShell->IsDesignMode() && IsTrackPropertiesEnabled_Lock() && !m_aMarkTimer.IsActive()) + m_aMarkTimer.Start(); +} + + +void FmXFormShell::SetSelection_Lock(const SdrMarkList& rMarkList) +{ + if (impl_checkDisposed_Lock()) + return; + + DetermineSelection_Lock(rMarkList); + m_pShell->NotifyMarkListChanged(m_pShell->GetFormView()); +} + + +void FmXFormShell::DetermineSelection_Lock(const SdrMarkList& rMarkList) +{ + if (setCurrentSelectionFromMark_Lock(rMarkList) && IsPropBrwOpen_Lock()) + ShowSelectionProperties_Lock(true); +} + + +bool FmXFormShell::IsPropBrwOpen_Lock() const +{ + if (impl_checkDisposed_Lock()) + return false; + + return m_pShell->GetViewShell() && m_pShell->GetViewShell()->GetViewFrame() + && m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow(SID_FM_SHOW_PROPERTIES); +} + + +class FmXFormShell::SuspendPropertyTracking +{ +private: + FmXFormShell& m_rShell; + bool m_bEnabled; + +public: + explicit SuspendPropertyTracking( FmXFormShell& _rShell ) + :m_rShell( _rShell ) + ,m_bEnabled( false ) + { + if (m_rShell.IsTrackPropertiesEnabled_Lock()) + { + m_rShell.EnableTrackProperties_Lock(false); + m_bEnabled = true; + } + } + + ~SuspendPropertyTracking( ) + { + if ( m_bEnabled ) // note that ( false != m_bEnabled ) implies ( NULL != m_pShell ) + m_rShell.EnableTrackProperties_Lock(true); + } +}; + + +void FmXFormShell::SetDesignMode_Lock(bool bDesign) +{ + if (impl_checkDisposed_Lock()) + return; + + DBG_ASSERT(m_pShell->GetFormView(), "FmXFormShell::SetDesignMode : invalid call (have no shell or no view) !"); + m_bChangingDesignMode = true; + + // 67506 - 15.07.99 - FS + // if we're switching off the design mode we have to force the property browser to be closed + // so it can commit it's changes _before_ we load the forms + if (!bDesign) + { + m_bHadPropertyBrowserInDesignMode = m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow(SID_FM_SHOW_PROPERTIES); + if (m_bHadPropertyBrowserInDesignMode) + m_pShell->GetViewShell()->GetViewFrame()->ToggleChildWindow(SID_FM_SHOW_PROPERTIES); + } + + FmFormView* pFormView = m_pShell->GetFormView(); + if (bDesign) + { + // we are currently filtering, so stop filtering + if (m_bFilterMode) + stopFiltering_Lock(false); + + // unsubscribe from the objects of my MarkList + pFormView->GetImpl()->stopMarkListWatching(); + } + else + { + m_aMarkTimer.Stop(); + + SuspendPropertyTracking aSuspend( *this ); + pFormView->GetImpl()->saveMarkList(); + } + + if (bDesign && m_xExternalViewController.is()) + CloseExternalFormViewer_Lock(); + + pFormView->ChangeDesignMode(bDesign); + + // notify listeners + FmDesignModeChangedHint aChangedHint( bDesign ); + m_pShell->Broadcast(aChangedHint); + + m_pShell->m_bDesignMode = bDesign; + UpdateForms_Lock(false); + + m_pTextShell->designModeChanged(); + + if (bDesign) + { + SdrMarkList aList; + { + // during changing the mark list, don't track the selected objects in the property browser + SuspendPropertyTracking aSuspend( *this ); + // restore the marks + pFormView->GetImpl()->restoreMarkList( aList ); + } + + // synchronize with the restored mark list + if ( aList.GetMarkCount() ) + SetSelection_Lock(aList); + } + else + { + // subscribe to the model of the view (so that I'm informed when someone deletes + // during the alive mode controls that I had saved in the saveMarklist (60343) + pFormView->GetImpl()->startMarkListWatching(); + } + + m_pShell->UIFeatureChanged(); + + // 67506 - 15.07.99 - FS + if (bDesign && m_bHadPropertyBrowserInDesignMode) + { + // The UIFeatureChanged performs an update (a check of the available features) asynchronously. + // So we can't call ShowSelectionProperties directly as the according feature isn't enabled yet. + // That's why we use an asynchron execution on the dispatcher. + // (And that's why this has to be done AFTER the UIFeatureChanged.) + m_pShell->GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_SHOW_PROPERTY_BROWSER, SfxCallMode::ASYNCHRON ); + } + m_bChangingDesignMode = false; +} + + +Reference< XControl> FmXFormShell::impl_getControl_Lock(const Reference<XControlModel>& i_rxModel, const FmFormObj& i_rKnownFormObj) +{ + if (impl_checkDisposed_Lock()) + return nullptr; + + Reference< XControl > xControl; + try + { + Reference< XControlContainer> xControlContainer(getControlContainerForView_Lock(), UNO_SET_THROW); + + const Sequence< Reference< XControl > > seqControls( xControlContainer->getControls() ); + // ... that I can then search + for (Reference< XControl > const & control : seqControls) + { + xControl.set( control, UNO_SET_THROW ); + Reference< XControlModel > xCurrentModel( xControl->getModel() ); + if ( xCurrentModel == i_rxModel ) + break; + xControl.clear(); + } + + if ( !xControl.is() ) + { + // fallback (some controls might not have been created, yet, since they were never visible so far) + Reference< XControl > xContainerControl( xControlContainer, UNO_QUERY_THROW ); + const vcl::Window* pContainerWindow = VCLUnoHelper::GetWindow( xContainerControl->getPeer() ); + ENSURE_OR_THROW( pContainerWindow, "unexpected control container implementation" ); + + const SdrView* pSdrView = m_pShell ? m_pShell->GetFormView() : nullptr; + ENSURE_OR_THROW( pSdrView, "no current view" ); + + xControl.set( i_rKnownFormObj.GetUnoControl( *pSdrView, *pContainerWindow->GetOutDev() ), UNO_SET_THROW ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + OSL_ENSURE( xControl.is(), "FmXFormShell::impl_getControl: no control found!" ); + return xControl; +} + +// note: _out_rForms is a member so needs lock +void FmXFormShell::impl_collectFormSearchContexts_nothrow_Lock( const Reference<XInterface>& _rxStartingPoint, + std::u16string_view _rCurrentLevelPrefix, FmFormArray& _out_rForms, ::std::vector< OUString >& _out_rNames ) +{ + try + { + Reference< XIndexAccess> xContainer( _rxStartingPoint, UNO_QUERY ); + if ( !xContainer.is() ) + return; + + sal_Int32 nCount( xContainer->getCount() ); + if ( nCount == 0 ) + return; + + OUString sCurrentFormName; + OUStringBuffer aNextLevelPrefix; + for ( sal_Int32 i=0; i<nCount; ++i ) + { + // is the current child a form? + Reference< XForm > xCurrentAsForm( xContainer->getByIndex(i), UNO_QUERY ); + if ( !xCurrentAsForm.is() ) + continue; + + Reference< XNamed > xNamed( xCurrentAsForm, UNO_QUERY_THROW ); + sCurrentFormName = xNamed->getName(); + + // the name of the current form + OUString sCompleteCurrentName( sCurrentFormName ); + if ( !_rCurrentLevelPrefix.empty() ) + { + sCompleteCurrentName += OUString::Concat(" (") + _rCurrentLevelPrefix + ")"; + } + + // the prefix for the next level + aNextLevelPrefix = _rCurrentLevelPrefix; + if ( !_rCurrentLevelPrefix.empty() ) + aNextLevelPrefix.append( '/' ); + aNextLevelPrefix.append( sCurrentFormName ); + + // remember both the form and its "display name" + _out_rForms.push_back( xCurrentAsForm ); + _out_rNames.push_back( sCompleteCurrentName ); + + // and descend + impl_collectFormSearchContexts_nothrow_Lock( + xCurrentAsForm, aNextLevelPrefix, + _out_rForms, _out_rNames); + aNextLevelPrefix.setLength(0); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FmXFormShell::startFiltering_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + // setting all forms in filter mode + FmXFormView* pXView = m_pShell->GetFormView()->GetImpl(); + + // if the active controller is our external one we have to use the trigger controller + Reference< XControlContainer> xContainer; + if (getActiveController_Lock() == m_xExternalViewController) + { + DBG_ASSERT(m_xExtViewTriggerController.is(), "FmXFormShell::startFiltering : inconsistent : active external controller, but no one triggered this !"); + xContainer = m_xExtViewTriggerController->getContainer(); + } + else + xContainer = getActiveController_Lock()->getContainer(); + + rtl::Reference< FormViewPageWindowAdapter > pAdapter = pXView->findWindow( xContainer ); + if ( pAdapter.is() ) + { + const ::std::vector< Reference< runtime::XFormController> >& rControllerList = pAdapter->GetList(); + for (const auto& rpController : rControllerList) + { + Reference< XModeSelector> xModeSelector(rpController, UNO_QUERY); + if (xModeSelector.is()) + xModeSelector->setMode( "FilterMode" ); + } + } + + m_bFilterMode = true; + + m_pShell->UIFeatureChanged(); + SfxViewFrame* pViewFrame = m_pShell->GetViewShell()->GetViewFrame(); + pViewFrame->GetBindings().InvalidateShell( *m_pShell ); + + if ( pViewFrame->KnowsChildWindow( SID_FM_FILTER_NAVIGATOR ) + && !pViewFrame->HasChildWindow( SID_FM_FILTER_NAVIGATOR ) + ) + { + pViewFrame->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR ); + } +} + + +static void saveFilter(const Reference< runtime::XFormController >& _rxController) +{ + Reference< XPropertySet> xFormAsSet(_rxController->getModel(), UNO_QUERY); + Reference< XPropertySet> xControllerAsSet(_rxController, UNO_QUERY); + + // call the subcontroller + Reference< runtime::XFormController > xController; + for (sal_Int32 i = 0, nCount = _rxController->getCount(); i < nCount; ++i) + { + _rxController->getByIndex(i) >>= xController; + saveFilter(xController); + } + + try + { + + xFormAsSet->setPropertyValue(FM_PROP_FILTER, xControllerAsSet->getPropertyValue(FM_PROP_FILTER)); + xFormAsSet->setPropertyValue(FM_PROP_APPLYFILTER, Any( true ) ); + } + catch (const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + +} + + +void FmXFormShell::stopFiltering_Lock(bool bSave) +{ + if (impl_checkDisposed_Lock()) + return; + + m_bFilterMode = false; + + FmXFormView* pXView = m_pShell->GetFormView()->GetImpl(); + + // if the active controller is our external one we have to use the trigger controller + Reference< XControlContainer> xContainer; + if (getActiveController_Lock() == m_xExternalViewController) + { + DBG_ASSERT(m_xExtViewTriggerController.is(), "FmXFormShell::stopFiltering : inconsistent : active external controller, but no one triggered this !"); + xContainer = m_xExtViewTriggerController->getContainer(); + } + else + xContainer = getActiveController_Lock()->getContainer(); + + rtl::Reference< FormViewPageWindowAdapter > pAdapter = pXView->findWindow(xContainer); + if ( pAdapter.is() ) + { + const ::std::vector< Reference< runtime::XFormController > >& rControllerList = pAdapter->GetList(); + ::std::vector < OUString > aOriginalFilters; + ::std::vector < bool > aOriginalApplyFlags; + + if (bSave) + { + for (const auto& rpController : rControllerList) + { + // remember the current filter settings in case we're going to reload the forms below (which may fail) + try + { + Reference< XPropertySet > xFormAsSet(rpController->getModel(), UNO_QUERY); + aOriginalFilters.push_back(::comphelper::getString(xFormAsSet->getPropertyValue(FM_PROP_FILTER))); + aOriginalApplyFlags.push_back(::comphelper::getBOOL(xFormAsSet->getPropertyValue(FM_PROP_APPLYFILTER))); + } + catch(Exception&) + { + OSL_FAIL("FmXFormShell::stopFiltering : could not get the original filter !"); + // put dummies into the arrays so the they have the right size + + if (aOriginalFilters.size() == aOriginalApplyFlags.size()) + // the first getPropertyValue failed -> use two dummies + aOriginalFilters.emplace_back( ); + aOriginalApplyFlags.push_back( false ); + } + saveFilter(rpController); + } + } + for (const auto& rController : rControllerList) + { + + Reference< XModeSelector> xModeSelector(rController, UNO_QUERY); + if (xModeSelector.is()) + xModeSelector->setMode( "DataMode" ); + } + if (bSave) // execute the filter + { + const ::std::vector< Reference< runtime::XFormController > > & rControllers = pAdapter->GetList(); + for (::std::vector< Reference< runtime::XFormController > > ::const_iterator j = rControllers.begin(); + j != rControllers.end(); ++j) + { + Reference< XLoadable> xReload((*j)->getModel(), UNO_QUERY); + if (!xReload.is()) + continue; + Reference< XPropertySet > xFormSet(xReload, UNO_QUERY); + + try + { + xReload->reload(); + } + catch(Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", ""); + } + + if (!isRowSetAlive(xFormSet)) + { // something went wrong -> restore the original state + OUString sOriginalFilter = aOriginalFilters[ j - rControllers.begin() ]; + bool bOriginalApplyFlag = aOriginalApplyFlags[ j - rControllers.begin() ]; + try + { + xFormSet->setPropertyValue(FM_PROP_FILTER, Any(sOriginalFilter)); + xFormSet->setPropertyValue(FM_PROP_APPLYFILTER, Any(bOriginalApplyFlag)); + xReload->reload(); + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + } + } + + m_pShell->UIFeatureChanged(); + m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell); +} + + +void FmXFormShell::CreateExternalView_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + DBG_ASSERT(m_xAttachedFrame.is(), "FmXFormShell::CreateExternalView : no frame !"); + + // the frame the external view is displayed in + bool bAlreadyExistent = m_xExternalViewController.is(); + Reference< css::frame::XFrame> xExternalViewFrame; + + Reference<runtime::XFormController> xCurrentNavController(getNavController_Lock()); + // the creation of the "partwindow" may cause a deactivate of the document which will result in our nav controller to be set to NULL + + // _first_ check if we have any valid fields we can use for the grid view + // FS - 21.10.99 - 69219 + { + FmXBoundFormFieldIterator aModelIterator(xCurrentNavController->getModel()); + bool bHaveUsableControls = false; + for (;;) + { + Reference< XPropertySet> xCurrentModelSet(aModelIterator.Next(), UNO_QUERY); + if (!xCurrentModelSet.is()) + break; + // the FmXBoundFormFieldIterator only supplies controls with a valid control source + // so we just have to check the field type + sal_Int16 nClassId = ::comphelper::getINT16(xCurrentModelSet->getPropertyValue(FM_PROP_CLASSID)); + switch (nClassId) + { + case FormComponentType::IMAGECONTROL: + case FormComponentType::CONTROL: + continue; + } + bHaveUsableControls = true; + break; + } + + if (!bHaveUsableControls) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Warning, VclButtonsType::Ok, + SvxResId(RID_STR_NOCONTROLS_FOR_EXTERNALDISPLAY))); + xBox->run(); + return; + } + } + + // load the component for external form views + if (!bAlreadyExistent) + { + OUString sFrameName("_beamer"); + URL aWantToDispatch; + aWantToDispatch.Complete = FMURL_COMPONENT_FORMGRIDVIEW; + + Reference< css::frame::XDispatchProvider> xProv(m_xAttachedFrame, UNO_QUERY); + Reference< css::frame::XDispatch> xDisp; + if (xProv.is()) + xDisp = xProv->queryDispatch(aWantToDispatch, sFrameName, + css::frame::FrameSearchFlag::CHILDREN | css::frame::FrameSearchFlag::CREATE); + if (xDisp.is()) + { + xDisp->dispatch(aWantToDispatch, Sequence< PropertyValue>()); + } + + // with this the component should be loaded, now search the frame where it resides in + xExternalViewFrame = m_xAttachedFrame->findFrame(sFrameName, css::frame::FrameSearchFlag::CHILDREN); + if (xExternalViewFrame.is()) + { + m_xExternalViewController = xExternalViewFrame->getController(); + if (m_xExternalViewController.is()) + m_xExternalViewController->addEventListener(static_cast<XEventListener*>(static_cast<XPropertyChangeListener*>(this))); + } + } + else + { + xExternalViewFrame = m_xExternalViewController->getFrame(); + Reference< css::frame::XDispatchProvider> xCommLink(xExternalViewFrame, UNO_QUERY); + + // if we display the active form we interpret the slot as "remove it" + Reference< XForm> xCurrentModel(xCurrentNavController->getModel(), UNO_QUERY); + if ((xCurrentModel == m_xExternalDisplayedForm) || (getInternalForm_Lock(xCurrentModel) == m_xExternalDisplayedForm)) + { + if (m_xExternalViewController == getActiveController_Lock()) + { + Reference< runtime::XFormController > xAsFormController( m_xExternalViewController, UNO_QUERY ); + ControllerFeatures aHelper( xAsFormController ); + (void)aHelper->commitCurrentControl(); + } + + Reference< runtime::XFormController > xNewController(m_xExtViewTriggerController); + CloseExternalFormViewer_Lock(); + setActiveController_Lock(xNewController); + return; + } + + URL aClearURL; + aClearURL.Complete = FMURL_GRIDVIEW_CLEARVIEW; + + Reference< css::frame::XDispatch> xClear( xCommLink->queryDispatch(aClearURL, OUString(), 0)); + if (xClear.is()) + xClear->dispatch(aClearURL, Sequence< PropertyValue>()); + } + + // TODO: We need an interceptor at the xSupplier, which forwards all queryDispatch requests to the FormController + // instance for which this "external view" was triggered + + // get the dispatch interface of the frame so we can communicate (interceptable) with the controller + Reference< css::frame::XDispatchProvider> xCommLink(xExternalViewFrame, UNO_QUERY); + + if (m_xExternalViewController.is()) + { + DBG_ASSERT(xCommLink.is(), "FmXFormShell::CreateExternalView : the component doesn't have the necessary interfaces !"); + // collect the dispatchers we will need + URL aAddColumnURL; + aAddColumnURL.Complete = FMURL_GRIDVIEW_ADDCOLUMN; + Reference< css::frame::XDispatch> xAddColumnDispatch( xCommLink->queryDispatch(aAddColumnURL, OUString(), 0)); + URL aAttachURL; + aAttachURL.Complete = FMURL_GRIDVIEW_ATTACHTOFORM; + Reference< css::frame::XDispatch> xAttachDispatch( xCommLink->queryDispatch(aAttachURL, OUString(), 0)); + + if (xAddColumnDispatch.is() && xAttachDispatch.is()) + { + DBG_ASSERT(xCurrentNavController.is(), "FmXFormShell::CreateExternalView : invalid call : have no nav controller !"); + // first : dispatch the descriptions for the columns to add + sal_Int16 nAddedColumns = 0; + + // for radio buttons we need some special structures + typedef std::map< OUString, Sequence< OUString> > MapUString2UstringSeq; + typedef std::map< OUString, OUString > FmMapUString2UString; + typedef std::map< OUString, sal_Int16 > FmMapUString2Int16; + + MapUString2UstringSeq aRadioValueLists; + MapUString2UstringSeq aRadioListSources; + FmMapUString2UString aRadioControlSources; + FmMapUString2Int16 aRadioPositions; + + FmXBoundFormFieldIterator aModelIterator(xCurrentNavController->getModel()); + OUString sColumnType,aGroupName,sControlSource; + Sequence< Property> aProps; + for (;;) + { + Reference< XPropertySet> xCurrentModelSet(aModelIterator.Next(), UNO_QUERY); + if (!xCurrentModelSet.is()) + break; + OSL_ENSURE(xCurrentModelSet.is(),"xCurrentModelSet is null!"); + // create a description of the column to be created + // first : determine it's type + + sal_Int16 nClassId = ::comphelper::getINT16(xCurrentModelSet->getPropertyValue(FM_PROP_CLASSID)); + switch (nClassId) + { + case FormComponentType::RADIOBUTTON: + { + // get the label of the button (this is the access key for our structures) + aGroupName = getLabelName(xCurrentModelSet); + + // add the reference value of the radio button to the list source sequence + Sequence< OUString>& aThisGroupLabels = aRadioListSources[aGroupName]; + sal_Int32 nNewSizeL = aThisGroupLabels.getLength() + 1; + aThisGroupLabels.realloc(nNewSizeL); + aThisGroupLabels.getArray()[nNewSizeL - 1] = ::comphelper::getString(xCurrentModelSet->getPropertyValue(FM_PROP_REFVALUE)); + + // add the label to the value list sequence + Sequence< OUString>& aThisGroupControlSources = aRadioValueLists[aGroupName]; + sal_Int32 nNewSizeC = aThisGroupControlSources.getLength() + 1; + aThisGroupControlSources.realloc(nNewSizeC); + aThisGroupControlSources.getArray()[nNewSizeC - 1] = ::comphelper::getString(xCurrentModelSet->getPropertyValue(FM_PROP_LABEL)); + + // remember the controls source of the radio group + sControlSource = ::comphelper::getString(xCurrentModelSet->getPropertyValue(FM_PROP_CONTROLSOURCE)); + if (aRadioControlSources.find(aGroupName) == aRadioControlSources.end()) + aRadioControlSources[aGroupName] = sControlSource; +#ifdef DBG_UTIL + else + DBG_ASSERT(aRadioControlSources[aGroupName] == sControlSource, + "FmXFormShell::CreateExternalView : inconsistent radio buttons detected !"); + // (radio buttons with the same name should have the same control source) +#endif + // remember the position within the columns + if (aRadioPositions.find(aGroupName) == aRadioPositions.end()) + aRadioPositions[aGroupName] = nAddedColumns; + + // any further handling is done below + } + continue; + + case FormComponentType::IMAGECONTROL: + case FormComponentType::CONTROL: + // no grid columns for these types (though they have a control source) + continue; + case FormComponentType::CHECKBOX: + sColumnType = FM_COL_CHECKBOX; break; + case FormComponentType::LISTBOX: + sColumnType = FM_COL_LISTBOX; break; + case FormComponentType::COMBOBOX: + sColumnType = FM_COL_COMBOBOX; break; + case FormComponentType::DATEFIELD: + sColumnType = FM_COL_DATEFIELD; break; + case FormComponentType::TIMEFIELD: + sColumnType = FM_COL_TIMEFIELD; break; + case FormComponentType::NUMERICFIELD: + sColumnType = FM_COL_NUMERICFIELD; break; + case FormComponentType::CURRENCYFIELD: + sColumnType = FM_COL_CURRENCYFIELD; break; + case FormComponentType::PATTERNFIELD: + sColumnType = FM_COL_PATTERNFIELD; break; + + case FormComponentType::TEXTFIELD: + { + sColumnType = FM_COL_TEXTFIELD; + // we know at least two different controls which are TextFields : the basic edit field and the formatted + // field. we distinguish them by their service name + Reference< lang::XServiceInfo> xInfo(xCurrentModelSet, UNO_QUERY); + if (xInfo.is()) + { + SdrObjKind nObjectType = getControlTypeByObject(xInfo); + if (SdrObjKind::FormFormattedField == nObjectType) + sColumnType = FM_COL_FORMATTEDFIELD; + } + } + break; + default: + sColumnType = FM_COL_TEXTFIELD; break; + } + + const sal_Int16 nDispatchArgs = 3; + Sequence< PropertyValue> aDispatchArgs(nDispatchArgs); + PropertyValue* pDispatchArgs = aDispatchArgs.getArray(); + + // properties describing "meta data" about the column + // the type + pDispatchArgs->Name = FMARG_ADDCOL_COLUMNTYPE; + pDispatchArgs->Value <<= sColumnType; + ++pDispatchArgs; + + // the pos : append the col + pDispatchArgs->Name = FMARG_ADDCOL_COLUMNPOS; + pDispatchArgs->Value <<= nAddedColumns; + ++pDispatchArgs; + + // the properties to forward to the new column + Sequence< PropertyValue> aColumnProps(1); + PropertyValue* pColumnProps = aColumnProps.getArray(); + + // the label + pColumnProps->Name = FM_PROP_LABEL; + pColumnProps->Value <<= getLabelName(xCurrentModelSet); + ++pColumnProps; + + // for all other props : transfer them + Reference< XPropertySetInfo> xControlModelInfo( xCurrentModelSet->getPropertySetInfo()); + DBG_ASSERT(xControlModelInfo.is(), "FmXFormShell::CreateExternalView : the control model has no property info ! This will crash !"); + aProps = xControlModelInfo->getProperties(); + + // realloc the control description sequence + sal_Int32 nExistentDescs = pColumnProps - aColumnProps.getArray(); + aColumnProps.realloc(nExistentDescs + aProps.getLength()); + pColumnProps = aColumnProps.getArray() + nExistentDescs; + + for (const Property& rProp : std::as_const(aProps)) + { + if (rProp.Name == FM_PROP_LABEL) + // already set + continue; + if (rProp.Name == FM_PROP_DEFAULTCONTROL) + // allow the column's own "default control" + continue; + if (rProp.Attributes & PropertyAttribute::READONLY) + // assume that properties which are readonly for the control are ro for the column to be created, too + continue; + + pColumnProps->Name = rProp.Name; + pColumnProps->Value = xCurrentModelSet->getPropertyValue(rProp.Name); + ++pColumnProps; + } + aColumnProps.realloc(pColumnProps - aColumnProps.getArray()); + + // columns props are a dispatch argument + pDispatchArgs->Name = "ColumnProperties"; // TODO : fmurl.* + pDispatchArgs->Value <<= aColumnProps; + ++pDispatchArgs; + DBG_ASSERT(nDispatchArgs == (pDispatchArgs - aDispatchArgs.getConstArray()), + "FmXFormShell::CreateExternalView : forgot to adjust nDispatchArgs ?"); + + // dispatch the "add column" + xAddColumnDispatch->dispatch(aAddColumnURL, aDispatchArgs); + ++nAddedColumns; + } + + // now for the radio button handling + sal_Int16 nOffset(0); + // properties describing the "direct" column properties + const sal_Int16 nListBoxDescription = 6; + Sequence< PropertyValue> aListBoxDescription(nListBoxDescription); + for (const auto& rCtrlSource : aRadioControlSources) + { + PropertyValue* pListBoxDescription = aListBoxDescription.getArray(); + // label + pListBoxDescription->Name = FM_PROP_LABEL; + pListBoxDescription->Value <<= rCtrlSource.first; + ++pListBoxDescription; + + // control source + pListBoxDescription->Name = FM_PROP_CONTROLSOURCE; + pListBoxDescription->Value <<= rCtrlSource.second; + ++pListBoxDescription; + + // bound column + pListBoxDescription->Name = FM_PROP_BOUNDCOLUMN; + pListBoxDescription->Value <<= sal_Int16(1); + ++pListBoxDescription; + + // content type + pListBoxDescription->Name = FM_PROP_LISTSOURCETYPE; + pListBoxDescription->Value <<= ListSourceType_VALUELIST; + ++pListBoxDescription; + + // list source + MapUString2UstringSeq::const_iterator aCurrentListSource = aRadioListSources.find(rCtrlSource.first); + DBG_ASSERT(aCurrentListSource != aRadioListSources.end(), + "FmXFormShell::CreateExternalView : inconsistent radio descriptions !"); + pListBoxDescription->Name = FM_PROP_LISTSOURCE; + pListBoxDescription->Value <<= (*aCurrentListSource).second; + ++pListBoxDescription; + + // value list + MapUString2UstringSeq::const_iterator aCurrentValueList = aRadioValueLists.find(rCtrlSource.first); + DBG_ASSERT(aCurrentValueList != aRadioValueLists.end(), + "FmXFormShell::CreateExternalView : inconsistent radio descriptions !"); + pListBoxDescription->Name = FM_PROP_STRINGITEMLIST; + pListBoxDescription->Value <<= (*aCurrentValueList).second; + ++pListBoxDescription; + + DBG_ASSERT(nListBoxDescription == (pListBoxDescription - aListBoxDescription.getConstArray()), + "FmXFormShell::CreateExternalView : forgot to adjust nListBoxDescription ?"); + + // properties describing the column "meta data" + const sal_Int16 nDispatchArgs = 3; + Sequence< PropertyValue> aDispatchArgs(nDispatchArgs); + PropertyValue* pDispatchArgs = aDispatchArgs.getArray(); + + // column type : listbox + pDispatchArgs->Name = FMARG_ADDCOL_COLUMNTYPE; + pDispatchArgs->Value <<= OUString(FM_COL_LISTBOX); +// pDispatchArgs->Value <<= (OUString)FM_COL_LISTBOX; + ++pDispatchArgs; + + // column position + pDispatchArgs->Name = FMARG_ADDCOL_COLUMNPOS; + FmMapUString2Int16::const_iterator aOffset = aRadioPositions.find(rCtrlSource.first); + DBG_ASSERT(aOffset != aRadioPositions.end(), + "FmXFormShell::CreateExternalView : inconsistent radio descriptions !"); + sal_Int16 nPosition = (*aOffset).second; + nPosition = nPosition + nOffset; + // we already inserted nOffset additional columns... + pDispatchArgs->Value <<= nPosition; + ++pDispatchArgs; + + // the + pDispatchArgs->Name = "ColumnProperties"; // TODO : fmurl.* + pDispatchArgs->Value <<= aListBoxDescription; + ++pDispatchArgs; + DBG_ASSERT(nDispatchArgs == (pDispatchArgs - aDispatchArgs.getConstArray()), + "FmXFormShell::CreateExternalView : forgot to adjust nDispatchArgs ?"); + + // dispatch the "add column" + xAddColumnDispatch->dispatch(aAddColumnURL, aDispatchArgs); + ++nAddedColumns; + ++nOffset; + } + + + DBG_ASSERT(nAddedColumns > 0, "FmXFormShell::CreateExternalView : no controls (inconsistent) !"); + // we should have checked if we have any usable controls (see above). + + // "load" the "form" of the external view + PropertyValue aArg; + aArg.Name = FMARG_ATTACHTO_MASTERFORM; + Reference< XResultSet> xForm(xCurrentNavController->getModel(), UNO_QUERY); + aArg.Value <<= xForm; + + m_xExternalDisplayedForm = xForm; + // do this before dispatching the "attach" command, as the attach may result in a call to our queryDispatch (for the FormSlots) + // which needs the m_xExternalDisplayedForm + + xAttachDispatch->dispatch(aAttachURL, Sequence< PropertyValue>(&aArg, 1)); + + m_xExtViewTriggerController = xCurrentNavController; + + // we want to know modifications done in the external view + // if the external controller is a XFormController we can use all our default handlings for it + Reference< runtime::XFormController > xFormController( m_xExternalViewController, UNO_QUERY ); + OSL_ENSURE( xFormController.is(), "FmXFormShell::CreateExternalView:: invalid external view controller!" ); + if (xFormController.is()) + xFormController->addActivateListener(static_cast<XFormControllerListener*>(this)); + } + } +#ifdef DBG_UTIL + else + { + OSL_FAIL("FmXFormShell::CreateExternalView : could not create the external form view !"); + } +#endif + InvalidateSlot_Lock(SID_FM_VIEW_AS_GRID, false); +} + + +void FmXFormShell::implAdjustConfigCache_Lock() +{ + // get (cache) the wizard usage flag + Sequence< OUString > aNames { "FormControlPilotsEnabled" }; + Sequence< Any > aFlags = GetProperties(aNames); + if (1 == aFlags.getLength()) + m_bUseWizards = ::cppu::any2bool(aFlags[0]); +} + + +void FmXFormShell::Notify( const css::uno::Sequence< OUString >& _rPropertyNames) +{ + DBG_TESTSOLARMUTEX(); + if (impl_checkDisposed_Lock()) + return; + + for (const OUString& rName : _rPropertyNames) + if (rName == "FormControlPilotsEnabled") + { + implAdjustConfigCache_Lock(); + InvalidateSlot_Lock(SID_FM_USE_WIZARDS, true); + } +} + +void FmXFormShell::ImplCommit() +{ +} + + +void FmXFormShell::SetWizardUsing_Lock(bool _bUseThem) +{ + m_bUseWizards = _bUseThem; + + Sequence< OUString > aNames { "FormControlPilotsEnabled" }; + Sequence< Any > aValues{ Any(m_bUseWizards) }; + PutProperties(aNames, aValues); +} + + +void FmXFormShell::viewDeactivated_Lock(FmFormView& _rCurrentView, bool _bDeactivateController) +{ + + if ( _rCurrentView.GetImpl() && !_rCurrentView.IsDesignMode() ) + { + _rCurrentView.GetImpl()->Deactivate( _bDeactivateController ); + } + + // if we have an async load operation pending for the 0-th page for this view, + // we need to cancel this + if (FmFormPage* pPage = _rCurrentView.GetCurPage()) + { + // move all events from our queue to a new one, omit the events for the deactivated + // page + ::std::queue< FmLoadAction > aNewEvents; + while ( !m_aLoadingPages.empty() ) + { + FmLoadAction aAction = m_aLoadingPages.front(); + m_aLoadingPages.pop(); + if ( pPage != aAction.pPage ) + { + aNewEvents.push( aAction ); + } + else + { + Application::RemoveUserEvent( aAction.nEventId ); + } + } + m_aLoadingPages = aNewEvents; + + // remove callbacks at the page + pPage->GetImpl().SetFormsCreationHdl( Link<FmFormPageImpl&,void>() ); + } + UpdateForms_Lock(true); +} + + +IMPL_LINK_NOARG( FmXFormShell, OnFirstTimeActivation_Lock, void*, void ) +{ + if (impl_checkDisposed_Lock()) + return; + + m_nActivationEvent = nullptr; + SfxObjectShell* pDocument = m_pShell->GetObjectShell(); + + if ( pDocument && !pDocument->HasName() ) + { + if (isEnhancedForm_Lock()) + { + // show the data navigator + if ( !m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_SHOW_DATANAVIGATOR ) ) + m_pShell->GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_SHOW_DATANAVIGATOR ); + } + } +} + + +IMPL_LINK_NOARG( FmXFormShell, OnFormsCreated_Lock, FmFormPageImpl&, void ) +{ + UpdateForms_Lock(true); +} + + +void FmXFormShell::viewActivated_Lock(FmFormView& _rCurrentView, bool _bSyncAction) +{ + FmFormPage* pPage = _rCurrentView.GetCurPage(); + + // activate our view if we are activated ourself + // FS - 30.06.99 - 67308 + if ( _rCurrentView.GetImpl() && !_rCurrentView.IsDesignMode() ) + { + // load forms for the page the current view belongs to + if ( pPage ) + { + if ( !pPage->GetImpl().hasEverBeenActivated() ) + loadForms_Lock(pPage, LoadFormsFlags::Load + | (_bSyncAction ? LoadFormsFlags::Sync + : LoadFormsFlags::Async)); + pPage->GetImpl().setHasBeenActivated( ); + } + + // first-time initializations for the views + if ( !_rCurrentView.GetImpl()->hasEverBeenActivated( ) ) + { + _rCurrentView.GetImpl()->onFirstViewActivation( dynamic_cast<FmFormModel*>( _rCurrentView.GetModel() ) ); + _rCurrentView.GetImpl()->setHasBeenActivated( ); + } + + // activate the current view + _rCurrentView.GetImpl()->Activate( _bSyncAction ); + } + + // set callbacks at the page + if ( pPage ) + { + pPage->GetImpl().SetFormsCreationHdl(LINK(this, FmXFormShell, OnFormsCreated_Lock)); + } + + UpdateForms_Lock(true); + + if ( m_bFirstActivation ) + { + m_nActivationEvent = Application::PostUserEvent(LINK(this, FmXFormShell, OnFirstTimeActivation_Lock)); + m_bFirstActivation = false; + } + + // find a default "current form", if there is none, yet + // #i88186# / 2008-04-12 / frank.schoenheit@sun.com + impl_defaultCurrentForm_nothrow_Lock(); +} + + +void FmXFormShell::impl_defaultCurrentForm_nothrow_Lock() +{ + if (impl_checkDisposed_Lock()) + return; + + if ( m_xCurrentForm.is() ) + // no action required + return; + + FmFormView* pFormView = m_pShell->GetFormView(); + FmFormPage* pPage = pFormView ? pFormView->GetCurPage() : nullptr; + if ( !pPage ) + return; + + try + { + Reference< XIndexAccess > xForms = pPage->GetForms( false ); + if ( !xForms.is() || !xForms->hasElements() ) + return; + + Reference< XForm > xNewCurrentForm( xForms->getByIndex(0), UNO_QUERY_THROW ); + impl_updateCurrentForm_Lock(xNewCurrentForm); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FmXFormShell::smartControlReset( const Reference< XIndexAccess >& _rxModels ) +{ + if (!_rxModels.is()) + { + OSL_FAIL("FmXFormShell::smartControlReset: invalid container!"); + return; + } + + sal_Int32 nCount = _rxModels->getCount(); + Reference< XPropertySet > xCurrent; + Reference< XPropertySetInfo > xCurrentInfo; + Reference< XPropertySet > xBoundField; + + for (sal_Int32 i=0; i<nCount; ++i) + { + _rxModels->getByIndex(i) >>= xCurrent; + if (xCurrent.is()) + xCurrentInfo = xCurrent->getPropertySetInfo(); + else + xCurrentInfo.clear(); + if (!xCurrentInfo.is()) + continue; + + if (xCurrentInfo->hasPropertyByName(FM_PROP_CLASSID)) + { // it's a control model + + // check if this control is bound to a living database field + if (xCurrentInfo->hasPropertyByName(FM_PROP_BOUNDFIELD)) + xCurrent->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xBoundField; + else + xBoundField.clear(); + + // reset only if it's *not* bound + bool bReset = !xBoundField.is(); + + // and additionally, check if it has an external value binding + Reference< XBindableValue > xBindable( xCurrent, UNO_QUERY ); + if ( xBindable.is() && xBindable->getValueBinding().is() ) + bReset = false; + + if ( bReset ) + { + Reference< XReset > xControlReset( xCurrent, UNO_QUERY ); + if ( xControlReset.is() ) + xControlReset->reset(); + } + } + else + { + Reference< XIndexAccess > xContainer(xCurrent, UNO_QUERY); + if (xContainer.is()) + smartControlReset(xContainer); + } + } +} + + +IMPL_LINK_NOARG( FmXFormShell, OnLoadForms_Lock, void*, void ) +{ + FmLoadAction aAction = m_aLoadingPages.front(); + m_aLoadingPages.pop(); + + loadForms_Lock(aAction.pPage, aAction.nFlags & ~LoadFormsFlags::Async); +} + + +namespace +{ + bool lcl_isLoadable( const Reference< XInterface >& _rxLoadable ) + { + // determines whether a form should be loaded or not + // if there is no datasource or connection there is no reason to load a form + Reference< XPropertySet > xSet( _rxLoadable, UNO_QUERY ); + if ( !xSet.is() ) + return false; + try + { + Reference< XConnection > xConn; + if ( isEmbeddedInDatabase( _rxLoadable, xConn ) ) + return true; + + // is there already an active connection + xSet->getPropertyValue(FM_PROP_ACTIVE_CONNECTION) >>= xConn; + if ( xConn.is() ) + return true; + + OUString sPropertyValue; + OSL_VERIFY( xSet->getPropertyValue( FM_PROP_DATASOURCE ) >>= sPropertyValue ); + if ( !sPropertyValue.isEmpty() ) + return true; + + OSL_VERIFY( xSet->getPropertyValue( FM_PROP_URL ) >>= sPropertyValue ); + if ( !sPropertyValue.isEmpty() ) + return true; + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return false; + } +} + + +void FmXFormShell::loadForms_Lock(FmFormPage* _pPage, const LoadFormsFlags _nBehaviour /* LoadFormsFlags::Load | LoadFormsFlags::Sync */) +{ + DBG_ASSERT( ( _nBehaviour & ( LoadFormsFlags::Async | LoadFormsFlags::Unload ) ) != ( LoadFormsFlags::Async | LoadFormsFlags::Unload ), + "FmXFormShell::loadForms: async loading not supported - this will heavily fail!" ); + + if ( _nBehaviour & LoadFormsFlags::Async ) + { + m_aLoadingPages.push( FmLoadAction( + _pPage, + _nBehaviour, + Application::PostUserEvent(LINK(this, FmXFormShell, OnLoadForms_Lock), _pPage) + ) ); + return; + } + + DBG_ASSERT( _pPage, "FmXFormShell::loadForms: invalid page!" ); + if ( !_pPage ) + return; + + // lock the undo env so the forms can change non-transient properties while loading + // (without this my doc's modified flag would be set) + FmFormModel& rFmFormModel(dynamic_cast< FmFormModel& >(_pPage->getSdrModelFromSdrPage())); + rFmFormModel.GetUndoEnv().Lock(); + + // load all forms + Reference< XIndexAccess > xForms = _pPage->GetForms( false ); + + if ( xForms.is() ) + { + Reference< XLoadable > xForm; + for ( sal_Int32 j = 0, nCount = xForms->getCount(); j < nCount; ++j ) + { + xForms->getByIndex( j ) >>= xForm; + bool bFormWasLoaded = false; + // a database form must be loaded for + try + { + if ( !( _nBehaviour & LoadFormsFlags::Unload ) ) + { + if ( lcl_isLoadable( xForm ) && !xForm->isLoaded() ) + xForm->load(); + } + else + { + if ( xForm->isLoaded() ) + { + bFormWasLoaded = true; + xForm->unload(); + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + // reset the form if it was loaded + if ( bFormWasLoaded ) + { + Reference< XIndexAccess > xContainer( xForm, UNO_QUERY ); + DBG_ASSERT( xContainer.is(), "FmXFormShell::loadForms: the form is no container!" ); + if ( xContainer.is() ) + smartControlReset( xContainer ); + } + } + } + + // unlock the environment + rFmFormModel.GetUndoEnv().UnLock(); +} + + +void FmXFormShell::ExecuteTextAttribute_Lock(SfxRequest& _rReq) +{ + DBG_TESTSOLARMUTEX(); + m_pTextShell->ExecuteTextAttribute( _rReq ); +} + + +void FmXFormShell::GetTextAttributeState_Lock(SfxItemSet& _rSet) +{ + DBG_TESTSOLARMUTEX(); + m_pTextShell->GetTextAttributeState( _rSet ); +} + + +bool FmXFormShell::IsActiveControl_Lock(bool _bCountRichTextOnly ) const +{ + DBG_TESTSOLARMUTEX(); + return m_pTextShell->IsActiveControl( _bCountRichTextOnly ); +} + + +void FmXFormShell::ForgetActiveControl_Lock() +{ + DBG_TESTSOLARMUTEX(); + m_pTextShell->ForgetActiveControl(); +} + + +void FmXFormShell::SetControlActivationHandler_Lock(const Link<LinkParamNone*,void>& _rHdl) +{ + DBG_TESTSOLARMUTEX(); + m_pTextShell->SetControlActivationHandler( _rHdl ); +} + +void FmXFormShell::handleShowPropertiesRequest_Lock() +{ + if (onlyControlsAreMarked_Lock()) + ShowSelectionProperties_Lock( true ); +} + + +void FmXFormShell::handleMouseButtonDown_Lock(const SdrViewEvent& _rViewEvent) +{ + // catch simple double clicks + if (_rViewEvent.mnMouseClicks == 2 && _rViewEvent.mnMouseCode == MOUSE_LEFT) + { + if ( _rViewEvent.meHit == SdrHitKind::MarkedObject ) + { + if (onlyControlsAreMarked_Lock()) + ShowSelectionProperties_Lock( true ); + } + } +} + + +bool FmXFormShell::HasControlFocus_Lock() const +{ + bool bHasControlFocus = false; + + try + { + Reference<runtime::XFormController> xController(getActiveController_Lock()); + Reference< XControl > xCurrentControl; + if ( xController.is() ) + xCurrentControl.set( xController->getCurrentControl() ); + if ( xCurrentControl.is() ) + { + Reference< XWindow2 > xPeerWindow( xCurrentControl->getPeer(), UNO_QUERY_THROW ); + bHasControlFocus = xPeerWindow->hasFocus(); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + return bHasControlFocus; +} + + +SearchableControlIterator::SearchableControlIterator(Reference< XInterface> const & xStartingPoint) + :IndexAccessIterator(xStartingPoint) +{ +} + + +bool SearchableControlIterator::ShouldHandleElement(const Reference< XInterface>& xElement) +{ + // if the thing has a ControlSource and a BoundField property + Reference< XPropertySet> xProperties(xElement, UNO_QUERY); + if (::comphelper::hasProperty(FM_PROP_CONTROLSOURCE, xProperties) && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xProperties)) + { + // and the BoundField is valid + Reference< XPropertySet> xField; + xProperties->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + if (xField.is()) + { + // we take it + m_sCurrentValue = ::comphelper::getString(xProperties->getPropertyValue(FM_PROP_CONTROLSOURCE)); + return true; + } + } + + // if it is a grid control + if (::comphelper::hasProperty(FM_PROP_CLASSID, xProperties)) + { + Any aClassId( xProperties->getPropertyValue(FM_PROP_CLASSID) ); + if (::comphelper::getINT16(aClassId) == FormComponentType::GRIDCONTROL) + { + m_sCurrentValue.clear(); + return true; + } + } + + return false; +} + + +bool SearchableControlIterator::ShouldStepInto(const Reference< XInterface>& /*xContainer*/) const +{ + return true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmsrccfg.cxx b/svx/source/form/fmsrccfg.cxx new file mode 100644 index 000000000..499d2cb16 --- /dev/null +++ b/svx/source/form/fmsrccfg.cxx @@ -0,0 +1,286 @@ +/* -*- 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/fmsrccfg.hxx> + +#include <sal/log.hxx> +#include <comphelper/processfactory.hxx> +#include <i18nutil/transliteration.hxx> + +using namespace ::com::sun::star::uno; + +namespace svxform +{ + // search parameters + + FmSearchParams::FmSearchParams() + :nTransliterationFlags( TransliterationFlags::NONE ) + ,nSearchForType ( 0 ) + ,nPosition ( MATCHING_ANYWHERE ) + ,nLevOther ( 2 ) + ,nLevShorter ( 2 ) + ,nLevLonger ( 2 ) + ,bLevRelaxed ( true ) + ,bAllFields ( false ) + ,bUseFormatter ( true ) + ,bBackwards ( false ) + ,bWildcard ( false ) + ,bRegular ( false ) + ,bApproxSearch ( false ) + ,bSoundsLikeCJK ( false ) + { + nTransliterationFlags = + TransliterationFlags::ignoreSpace_ja_JP + | TransliterationFlags::ignoreMiddleDot_ja_JP + | TransliterationFlags::ignoreProlongedSoundMark_ja_JP + | TransliterationFlags::ignoreSeparator_ja_JP + | TransliterationFlags::IGNORE_CASE; + } + + bool FmSearchParams::isIgnoreWidthCJK( ) const + { + return bool(nTransliterationFlags & TransliterationFlags::IGNORE_WIDTH); + } + + bool FmSearchParams::isCaseSensitive( ) const + { + return !(nTransliterationFlags & TransliterationFlags::IGNORE_CASE); + } + + void FmSearchParams::setCaseSensitive( bool _bCase ) + { + if ( _bCase ) + nTransliterationFlags &= ~TransliterationFlags::IGNORE_CASE; + else + nTransliterationFlags |= TransliterationFlags::IGNORE_CASE; + } + + // maps from ascii values to int values + + namespace { + + struct Ascii2Int16 + { + const char* pAscii; + sal_Int16 nValue; + }; + + } + + static const Ascii2Int16* lcl_getSearchForTypeValueMap() + { + static const Ascii2Int16 s_aSearchForTypeMap[] = + { + { "text", 0 }, + { "null", 1 }, + { "non-null", 2 }, + { nullptr, -1 } + }; + return s_aSearchForTypeMap; + } + + static const Ascii2Int16* lcl_getSearchPositionValueMap() + { + static const Ascii2Int16 s_aSearchPositionMap[] = + { + { "anywhere-in-field", MATCHING_ANYWHERE }, + { "beginning-of-field", MATCHING_BEGINNING }, + { "end-of-field", MATCHING_END }, + { "complete-field", MATCHING_WHOLETEXT }, + { nullptr, -1 } + }; + return s_aSearchPositionMap; + } + + static sal_Int16 lcl_implMapAsciiValue( const OUString& _rAsciiValue, const Ascii2Int16* _pMap ) + { + // search the map for the given ascii value + const Ascii2Int16* pSearch = _pMap; + while ( pSearch && pSearch->pAscii ) + { + if ( _rAsciiValue.equalsAscii( pSearch->pAscii ) ) + // found + return pSearch->nValue; + ++pSearch; + } + + SAL_WARN( + "svx.form", "could not convert the ascii value " << _rAsciiValue); + return -1; + } + + static const char* lcl_implMapIntValue( const sal_Int16 _nValue, const Ascii2Int16* _pMap ) + { + // search the map for the given integer value + const Ascii2Int16* pSearch = _pMap; + while ( pSearch && pSearch->pAscii ) + { + if ( _nValue == pSearch->nValue ) + // found + return pSearch->pAscii; + ++pSearch; + } + + SAL_WARN( "svx", "lcl_implMapIntValue: could not convert the integer value " + << _nValue << " !"); + static const char* const s_pDummy = ""; + // just as a fallback... + return s_pDummy; + } + + // class FmSearchConfigItem - a config item that stores search parameters + +#define TA( c ) &c, cppu::UnoType<decltype(c)>::get() + + FmSearchConfigItem::FmSearchConfigItem() + :OConfigurationValueContainer( ::comphelper::getProcessComponentContext(), m_aMutex, "/org.openoffice.Office.DataAccess/FormSearchOptions", 2 ) + { + // register our members so the data exchange with the node values is done automatically + + registerExchangeLocation( "SearchHistory", TA( aHistory ) ); + registerExchangeLocation( "LevenshteinOther", TA( nLevOther ) ); + registerExchangeLocation( "LevenshteinShorter", TA( nLevShorter ) ); + registerExchangeLocation( "LevenshteinLonger", TA( nLevLonger ) ); + registerExchangeLocation( "IsLevenshteinRelaxed", TA( bLevRelaxed ) ); + registerExchangeLocation( "IsSearchAllFields", TA( bAllFields ) ); + registerExchangeLocation( "IsUseFormatter", TA( bUseFormatter ) ); + registerExchangeLocation( "IsBackwards", TA( bBackwards ) ); + registerExchangeLocation( "IsWildcardSearch", TA( bWildcard ) ); + registerExchangeLocation( "IsUseRegularExpression", TA( bRegular ) ); + registerExchangeLocation( "IsSimilaritySearch", TA( bApproxSearch ) ); + registerExchangeLocation( "IsUseAsianOptions", TA( bSoundsLikeCJK ) ); + + // the properties which need to be translated + registerExchangeLocation( "SearchType", TA( m_sSearchForType ) ); + registerExchangeLocation( "SearchPosition", TA( m_sSearchPosition ) ); + + registerExchangeLocation( "IsMatchCase", TA( m_bIsMatchCase ) ); + registerExchangeLocation( "Japanese/IsMatchFullHalfWidthForms", TA( m_bIsMatchFullHalfWidthForms ) ); + registerExchangeLocation( "Japanese/IsMatchHiraganaKatakana", TA( m_bIsMatchHiraganaKatakana ) ); + registerExchangeLocation( "Japanese/IsMatchContractions", TA( m_bIsMatchContractions ) ); + registerExchangeLocation( "Japanese/IsMatchMinusDashCho-on", TA( m_bIsMatchMinusDashCho_on ) ); + registerExchangeLocation( "Japanese/IsMatchRepeatCharMarks", TA( m_bIsMatchRepeatCharMarks ) ); + registerExchangeLocation( "Japanese/IsMatchVariantFormKanji", TA( m_bIsMatchVariantFormKanji ) ); + registerExchangeLocation( "Japanese/IsMatchOldKanaForms", TA( m_bIsMatchOldKanaForms ) ); + registerExchangeLocation( "Japanese/IsMatch_DiZi_DuZu", TA( m_bIsMatch_DiZi_DuZu ) ); + registerExchangeLocation( "Japanese/IsMatch_BaVa_HaFa", TA( m_bIsMatch_BaVa_HaFa ) ); + registerExchangeLocation( "Japanese/IsMatch_TsiThiChi_DhiZi", TA( m_bIsMatch_TsiThiChi_DhiZi ) ); + registerExchangeLocation( "Japanese/IsMatch_HyuIyu_ByuVyu", TA( m_bIsMatch_HyuIyu_ByuVyu ) ); + registerExchangeLocation( "Japanese/IsMatch_SeShe_ZeJe", TA( m_bIsMatch_SeShe_ZeJe ) ); + registerExchangeLocation( "Japanese/IsMatch_IaIya", TA( m_bIsMatch_IaIya ) ); + registerExchangeLocation( "Japanese/IsMatch_KiKu", TA( m_bIsMatch_KiKu ) ); + registerExchangeLocation( "Japanese/IsIgnorePunctuation", TA( m_bIsIgnorePunctuation ) ); + registerExchangeLocation( "Japanese/IsIgnoreWhitespace", TA( m_bIsIgnoreWhitespace ) ); + registerExchangeLocation( "Japanese/IsIgnoreProlongedSoundMark",TA( m_bIsIgnoreProlongedSoundMark ) ); + registerExchangeLocation( "Japanese/IsIgnoreMiddleDot", TA( m_bIsIgnoreMiddleDot ) ); + + read( ); + } + + FmSearchConfigItem::~FmSearchConfigItem() + { + commit( ); + } + + void FmSearchConfigItem::implTranslateFromConfig( ) + { + // the search-for string + nSearchForType = lcl_implMapAsciiValue( m_sSearchForType, lcl_getSearchForTypeValueMap() ); + + // the search position + nPosition = lcl_implMapAsciiValue( m_sSearchPosition, lcl_getSearchPositionValueMap() ); + + // the transliteration flags + nTransliterationFlags = TransliterationFlags::NONE; + + if ( !m_bIsMatchCase ) nTransliterationFlags |= TransliterationFlags::IGNORE_CASE; + if ( m_bIsMatchFullHalfWidthForms ) nTransliterationFlags |= TransliterationFlags::IGNORE_WIDTH; + if ( m_bIsMatchHiraganaKatakana ) nTransliterationFlags |= TransliterationFlags::IGNORE_KANA; + if ( m_bIsMatchContractions ) nTransliterationFlags |= TransliterationFlags::ignoreSize_ja_JP; + if ( m_bIsMatchMinusDashCho_on ) nTransliterationFlags |= TransliterationFlags::ignoreMinusSign_ja_JP; + if ( m_bIsMatchRepeatCharMarks ) nTransliterationFlags |= TransliterationFlags::ignoreIterationMark_ja_JP; + if ( m_bIsMatchVariantFormKanji ) nTransliterationFlags |= TransliterationFlags::ignoreTraditionalKanji_ja_JP; + if ( m_bIsMatchOldKanaForms ) nTransliterationFlags |= TransliterationFlags::ignoreTraditionalKana_ja_JP; + if ( m_bIsMatch_DiZi_DuZu ) nTransliterationFlags |= TransliterationFlags::ignoreZiZu_ja_JP; + if ( m_bIsMatch_BaVa_HaFa ) nTransliterationFlags |= TransliterationFlags::ignoreBaFa_ja_JP; + if ( m_bIsMatch_TsiThiChi_DhiZi ) nTransliterationFlags |= TransliterationFlags::ignoreTiJi_ja_JP; + if ( m_bIsMatch_HyuIyu_ByuVyu ) nTransliterationFlags |= TransliterationFlags::ignoreHyuByu_ja_JP; + if ( m_bIsMatch_SeShe_ZeJe ) nTransliterationFlags |= TransliterationFlags::ignoreSeZe_ja_JP; + if ( m_bIsMatch_IaIya ) nTransliterationFlags |= TransliterationFlags::ignoreIandEfollowedByYa_ja_JP; + if ( m_bIsMatch_KiKu ) nTransliterationFlags |= TransliterationFlags::ignoreKiKuFollowedBySa_ja_JP; + + if ( m_bIsIgnorePunctuation ) nTransliterationFlags |= TransliterationFlags::ignoreSeparator_ja_JP; + if ( m_bIsIgnoreWhitespace ) nTransliterationFlags |= TransliterationFlags::ignoreSpace_ja_JP; + if ( m_bIsIgnoreProlongedSoundMark ) nTransliterationFlags |= TransliterationFlags::ignoreProlongedSoundMark_ja_JP; + if ( m_bIsIgnoreMiddleDot ) nTransliterationFlags |= TransliterationFlags::ignoreMiddleDot_ja_JP; + } + + void FmSearchConfigItem::implTranslateToConfig( ) + { + // the search-for string + m_sSearchForType = OUString::createFromAscii( lcl_implMapIntValue( nSearchForType, lcl_getSearchForTypeValueMap() ) ); + + // the search position + m_sSearchPosition = OUString::createFromAscii( lcl_implMapIntValue( nPosition, lcl_getSearchPositionValueMap() ) ); + + // the transliteration flags + + m_bIsMatchCase = !( nTransliterationFlags & TransliterationFlags::IGNORE_CASE ); + m_bIsMatchFullHalfWidthForms = bool( nTransliterationFlags & TransliterationFlags::IGNORE_WIDTH ); + m_bIsMatchHiraganaKatakana = bool( nTransliterationFlags & TransliterationFlags::IGNORE_KANA ); + m_bIsMatchContractions = bool( nTransliterationFlags & TransliterationFlags::ignoreSize_ja_JP ); + m_bIsMatchMinusDashCho_on = bool( nTransliterationFlags & TransliterationFlags::ignoreMinusSign_ja_JP ); + m_bIsMatchRepeatCharMarks = bool( nTransliterationFlags & TransliterationFlags::ignoreIterationMark_ja_JP ); + m_bIsMatchVariantFormKanji = bool( nTransliterationFlags & TransliterationFlags::ignoreTraditionalKanji_ja_JP ); + m_bIsMatchOldKanaForms = bool( nTransliterationFlags & TransliterationFlags::ignoreTraditionalKana_ja_JP ); + m_bIsMatch_DiZi_DuZu = bool( nTransliterationFlags & TransliterationFlags::ignoreZiZu_ja_JP ); + m_bIsMatch_BaVa_HaFa = bool( nTransliterationFlags & TransliterationFlags::ignoreBaFa_ja_JP ); + m_bIsMatch_TsiThiChi_DhiZi = bool( nTransliterationFlags & TransliterationFlags::ignoreTiJi_ja_JP ); + m_bIsMatch_HyuIyu_ByuVyu = bool( nTransliterationFlags & TransliterationFlags::ignoreHyuByu_ja_JP ); + m_bIsMatch_SeShe_ZeJe = bool( nTransliterationFlags & TransliterationFlags::ignoreSeZe_ja_JP ); + m_bIsMatch_IaIya = bool( nTransliterationFlags & TransliterationFlags::ignoreIandEfollowedByYa_ja_JP ); + m_bIsMatch_KiKu = bool( nTransliterationFlags & TransliterationFlags::ignoreKiKuFollowedBySa_ja_JP ); + + m_bIsIgnorePunctuation = bool( nTransliterationFlags & TransliterationFlags::ignoreSeparator_ja_JP ); + m_bIsIgnoreWhitespace = bool( nTransliterationFlags & TransliterationFlags::ignoreSpace_ja_JP ); + m_bIsIgnoreProlongedSoundMark = bool( nTransliterationFlags & TransliterationFlags::ignoreProlongedSoundMark_ja_JP ); + m_bIsIgnoreMiddleDot = bool( nTransliterationFlags & TransliterationFlags::ignoreMiddleDot_ja_JP ); + } + + const FmSearchParams& FmSearchConfigItem::getParams() const + { + // ensure that the properties which are not stored directly are up-to-date + const_cast< FmSearchConfigItem* >( this )->implTranslateFromConfig( ); + + // and return our FmSearchParams part + return *this; + } + + void FmSearchConfigItem::setParams( const FmSearchParams& _rParams ) + { + // copy the FmSearchParams part + *static_cast< FmSearchParams* >( this ) = _rParams; + + // translate the settings not represented by a direct config value + implTranslateToConfig(); + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmsrcimp.cxx b/svx/source/form/fmsrcimp.cxx new file mode 100644 index 000000000..6ebd99c93 --- /dev/null +++ b/svx/source/form/fmsrcimp.cxx @@ -0,0 +1,1058 @@ +/* -*- 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 <o3tl/safeint.hxx> +#include <o3tl/string_view.hxx> +#include <svx/fmtools.hxx> +#include <svx/fmsrccfg.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <tools/wldcrd.hxx> +#include <vcl/svapp.hxx> +#include <unotools/textsearch.hxx> +#include <com/sun/star/awt/XTextComponent.hpp> +#include <com/sun/star/awt/XListBox.hpp> +#include <com/sun/star/awt/XCheckBox.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/util/SearchAlgorithms2.hpp> +#include <com/sun/star/util/SearchFlags.hpp> +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/i18n/CollatorOptions.hpp> + +#include <com/sun/star/sdb/XColumn.hpp> +#include <com/sun/star/sdbc/XConnection.hpp> +#include <com/sun/star/sdbc/XDatabaseMetaData.hpp> +#include <com/sun/star/sdbcx/XColumnsSupplier.hpp> + +#include <fmprop.hxx> +#include <svx/fmsrcimp.hxx> + +#include <comphelper/types.hxx> +#include <unotools/syslocale.hxx> +#include <i18nutil/searchopt.hxx> + +#define EQUAL_BOOKMARKS(a, b) a == b + +#define IFACECAST(c) static_cast<const Reference< XInterface >&>(c) + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::i18n; +using namespace ::com::sun::star::beans; +using namespace ::svxform; + + +// = FmRecordCountListener + +// SMART_UNO_IMPLEMENTATION(FmRecordCountListener, UsrObject); + + +FmRecordCountListener::FmRecordCountListener(const Reference< css::sdbc::XResultSet > & dbcCursor) +{ + + m_xListening.set(dbcCursor, UNO_QUERY); + if (!m_xListening.is()) + return; + + if (::comphelper::getBOOL(m_xListening->getPropertyValue(FM_PROP_ROWCOUNTFINAL))) + { + m_xListening = nullptr; + // there's nothing to do as the record count is already known + return; + } + + m_xListening->addPropertyChangeListener(FM_PROP_ROWCOUNT, static_cast<css::beans::XPropertyChangeListener*>(this)); +} + + +void FmRecordCountListener::SetPropChangeHandler(const Link<sal_Int32,void>& lnk) +{ + m_lnkWhoWantsToKnow = lnk; + + if (m_xListening.is()) + NotifyCurrentCount(); +} + + +FmRecordCountListener::~FmRecordCountListener() +{ + +} + + +void FmRecordCountListener::DisConnect() +{ + if(m_xListening.is()) + m_xListening->removePropertyChangeListener(FM_PROP_ROWCOUNT, static_cast<css::beans::XPropertyChangeListener*>(this)); + m_xListening = nullptr; +} + + +void SAL_CALL FmRecordCountListener::disposing(const css::lang::EventObject& /*Source*/) +{ + DBG_ASSERT(m_xListening.is(), "FmRecordCountListener::disposing should never have been called without a propset !"); + DisConnect(); +} + + +void FmRecordCountListener::NotifyCurrentCount() +{ + if (m_lnkWhoWantsToKnow.IsSet()) + { + DBG_ASSERT(m_xListening.is(), "FmRecordCountListener::NotifyCurrentCount : I have no propset ... !?"); + sal_Int32 theCount = ::comphelper::getINT32(m_xListening->getPropertyValue(FM_PROP_ROWCOUNT)); + m_lnkWhoWantsToKnow.Call(theCount); + } +} + + +void FmRecordCountListener::propertyChange(const css::beans::PropertyChangeEvent& /*evt*/) +{ + NotifyCurrentCount(); +} + + +// FmSearchEngine - local classes + +SimpleTextWrapper::SimpleTextWrapper(const Reference< css::awt::XTextComponent > & _xText) + :ControlTextWrapper(_xText) + ,m_xText(_xText) +{ + DBG_ASSERT(m_xText.is(), "FmSearchEngine::SimpleTextWrapper::SimpleTextWrapper : invalid argument !"); +} + + +OUString SimpleTextWrapper::getCurrentText() const +{ + return m_xText->getText(); +} + + +ListBoxWrapper::ListBoxWrapper(const Reference< css::awt::XListBox > & _xBox) + :ControlTextWrapper(_xBox) + ,m_xBox(_xBox) +{ + DBG_ASSERT(m_xBox.is(), "FmSearchEngine::ListBoxWrapper::ListBoxWrapper : invalid argument !"); +} + + +OUString ListBoxWrapper::getCurrentText() const +{ + return m_xBox->getSelectedItem(); +} + + +CheckBoxWrapper::CheckBoxWrapper(const Reference< css::awt::XCheckBox > & _xBox) + :ControlTextWrapper(_xBox) + ,m_xBox(_xBox) +{ + DBG_ASSERT(m_xBox.is(), "FmSearchEngine::CheckBoxWrapper::CheckBoxWrapper : invalid argument !"); +} + + +OUString CheckBoxWrapper::getCurrentText() const +{ + switch (static_cast<TriState>(m_xBox->getState())) + { + case TRISTATE_FALSE: return "0"; + case TRISTATE_TRUE: return "1"; + default: break; + } + return OUString(); +} + + +// = FmSearchEngine + +bool FmSearchEngine::MoveCursor() +{ + bool bSuccess = true; + try + { + if (m_bForward) + if (m_xSearchCursor.isLast()) + m_xSearchCursor.first(); + else + m_xSearchCursor.next(); + else + if (m_xSearchCursor.isFirst()) + { + rtl::Reference<FmRecordCountListener> prclListener = new FmRecordCountListener(m_xSearchCursor); + prclListener->SetPropChangeHandler(LINK(this, FmSearchEngine, OnNewRecordCount)); + + m_xSearchCursor.last(); + + prclListener->DisConnect(); + } + else + m_xSearchCursor.previous(); + } + catch(Exception const&) + { + TOOLS_WARN_EXCEPTION( "svx", "FmSearchEngine::MoveCursor"); + bSuccess = false; + } + catch(...) + { + TOOLS_WARN_EXCEPTION( "svx", "FmSearchEngine::MoveCursor : caught an unknown Exception !"); + bSuccess = false; + } + + return bSuccess; +} + + +bool FmSearchEngine::MoveField(sal_Int32& nPos, FieldCollection::iterator& iter, const FieldCollection::iterator& iterBegin, const FieldCollection::iterator& iterEnd) +{ + bool bSuccess(true); + if (m_bForward) + { + ++iter; + ++nPos; + if (iter == iterEnd) + { + bSuccess = MoveCursor(); + iter = iterBegin; + nPos = 0; + } + } else + { + if (iter == iterBegin) + { + bSuccess = MoveCursor(); + iter = iterEnd; + nPos = iter-iterBegin; + } + --iter; + --nPos; + } + return bSuccess; +} + + +void FmSearchEngine::BuildAndInsertFieldInfo(const Reference< css::container::XIndexAccess > & xAllFields, sal_Int32 nField) +{ + DBG_ASSERT( xAllFields.is() && ( nField >= 0 ) && ( nField < xAllFields->getCount() ), + "FmSearchEngine::BuildAndInsertFieldInfo: invalid field descriptor!" ); + + // the field itself + Reference< XInterface > xCurrentField; + xAllFields->getByIndex(nField) >>= xCurrentField; + + // From this I now know that it supports the DatabaseRecord service (I hope). + // For the FormatKey and the type I need the PropertySet. + Reference< css::beans::XPropertySet > xProperties(xCurrentField, UNO_QUERY_THROW); + + // build the FieldInfo for that + FieldInfo fiCurrent; + fiCurrent.xContents.set(xCurrentField, UNO_QUERY); + + // and memorize + m_arrUsedFields.insert(m_arrUsedFields.end(), fiCurrent); + +} + +OUString FmSearchEngine::FormatField(sal_Int32 nWhich) +{ + DBG_ASSERT(o3tl::make_unsigned(nWhich) < m_aControlTexts.size(), "FmSearchEngine::FormatField(sal_Int32) : invalid position !"); + DBG_ASSERT(m_aControlTexts[nWhich], "FmSearchEngine::FormatField(sal_Int32) : invalid object in array !"); + DBG_ASSERT(m_aControlTexts[nWhich]->getControl().is(), "FmSearchEngine::FormatField : invalid control !"); + + if (m_nCurrentFieldIndex != -1) + { + DBG_ASSERT((nWhich == 0) || (nWhich == m_nCurrentFieldIndex), "FmSearchEngine::FormatField : parameter nWhich is invalid"); + // analogous situation as below + nWhich = m_nCurrentFieldIndex; + } + + DBG_ASSERT((nWhich >= 0) && (o3tl::make_unsigned(nWhich) < m_aControlTexts.size()), + "FmSearchEngine::FormatField : invalid argument nWhich !"); + return m_aControlTexts[m_nCurrentFieldIndex == -1 ? nWhich : m_nCurrentFieldIndex]->getCurrentText(); +} + + +FmSearchEngine::SearchResult FmSearchEngine::SearchSpecial(bool _bSearchForNull, sal_Int32& nFieldPos, + FieldCollection::iterator& iterFieldLoop, const FieldCollection::iterator& iterBegin, const FieldCollection::iterator& iterEnd) +{ + // memorize the start position + Any aStartMark; + try { aStartMark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); return SearchResult::Error; } + FieldCollection::const_iterator iterInitialField = iterFieldLoop; + + + bool bFound(false); + bool bMovedAround(false); + do + { + Application::Reschedule( true ); + + // the content to be compared currently + iterFieldLoop->xContents->getString(); // needed for wasNull + bFound = _bSearchForNull == bool(iterFieldLoop->xContents->wasNull()); + if (bFound) + break; + + // next field (implicitly next record, if necessary) + if (!MoveField(nFieldPos, iterFieldLoop, iterBegin, iterEnd)) + { // When moving to the next field, something went wrong... + // Continuing is not possible, since the next time exactly the same + // will definitely go wrong again, thus abort. + // Before, however, so that the search continues at the current position: + try { m_aPreviousLocBookmark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); } + m_iterPreviousLocField = iterFieldLoop; + // and leave + return SearchResult::Error; + } + + Any aCurrentBookmark; + try { aCurrentBookmark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); return SearchResult::Error; } + + bMovedAround = EQUAL_BOOKMARKS(aStartMark, aCurrentBookmark) && (iterFieldLoop == iterInitialField); + + if (nFieldPos == 0) + // that is, I've moved to a new record + PropagateProgress(bMovedAround); + // if we moved to the starting position we don't have to propagate an 'overflow' message + // FS - 07.12.99 - 68530 + + // cancel requested? + if (CancelRequested()) + return SearchResult::Cancelled; + + } while (!bMovedAround); + + return bFound ? SearchResult::Found : SearchResult::NotFound; +} + + +FmSearchEngine::SearchResult FmSearchEngine::SearchWildcard(std::u16string_view strExpression, sal_Int32& nFieldPos, + FieldCollection::iterator& iterFieldLoop, const FieldCollection::iterator& iterBegin, const FieldCollection::iterator& iterEnd) +{ + // memorize the start position + Any aStartMark; + try { aStartMark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); return SearchResult::Error; } + FieldCollection::const_iterator iterInitialField = iterFieldLoop; + + WildCard aSearchExpression(strExpression); + + + bool bFound(false); + bool bMovedAround(false); + do + { + Application::Reschedule( true ); + + // the content to be compared currently + OUString sCurrentCheck; + if (m_bFormatter) + sCurrentCheck = FormatField(nFieldPos); + else + sCurrentCheck = iterFieldLoop->xContents->getString(); + + if (!GetCaseSensitive()) + // norm the string + sCurrentCheck = m_aCharacterClassficator.lowercase(sCurrentCheck); + + // now the test is easy... + bFound = aSearchExpression.Matches(sCurrentCheck); + + if (bFound) + break; + + // next field (implicitly next record, if necessary) + if (!MoveField(nFieldPos, iterFieldLoop, iterBegin, iterEnd)) + { // When moving to the next field, something went wrong... + // Continuing is not possible, since the next time exactly the same + // will definitely go wrong again, thus abort. + // Before, however, so that the search continues at the current position: + try { m_aPreviousLocBookmark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); } + m_iterPreviousLocField = iterFieldLoop; + // and leave + return SearchResult::Error; + } + + Any aCurrentBookmark; + try { aCurrentBookmark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); return SearchResult::Error; } + + bMovedAround = EQUAL_BOOKMARKS(aStartMark, aCurrentBookmark) && (iterFieldLoop == iterInitialField); + + if (nFieldPos == 0) + // that is, I've moved to a new record + PropagateProgress(bMovedAround); + // if we moved to the starting position we don't have to propagate an 'overflow' message + // FS - 07.12.99 - 68530 + + // cancel requested? + if (CancelRequested()) + return SearchResult::Cancelled; + + } while (!bMovedAround); + + return bFound ? SearchResult::Found : SearchResult::NotFound; +} + + +FmSearchEngine::SearchResult FmSearchEngine::SearchRegularApprox(const OUString& strExpression, sal_Int32& nFieldPos, + FieldCollection::iterator& iterFieldLoop, const FieldCollection::iterator& iterBegin, const FieldCollection::iterator& iterEnd) +{ + DBG_ASSERT(m_bLevenshtein || m_bRegular, + "FmSearchEngine::SearchRegularApprox : invalid search mode!"); + DBG_ASSERT(!m_bLevenshtein || !m_bRegular, + "FmSearchEngine::SearchRegularApprox : cannot search for regular expressions and similarities at the same time!"); + + // memorize start position + Any aStartMark; + try { aStartMark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); return SearchResult::Error; } + FieldCollection::const_iterator iterInitialField = iterFieldLoop; + + // collect parameters + i18nutil::SearchOptions2 aParam; + aParam.AlgorithmType2 = m_bRegular ? SearchAlgorithms2::REGEXP : SearchAlgorithms2::APPROXIMATE; + aParam.searchFlag = 0; + aParam.transliterateFlags = GetTransliterationFlags(); + if ( !GetTransliteration() ) + { // if transliteration is not enabled, the only flags which matter are IGNORE_CASE and IGNORE_WIDTH + aParam.transliterateFlags &= TransliterationFlags::IGNORE_CASE | TransliterationFlags::IGNORE_WIDTH; + } + if (m_bLevenshtein) + { + if (m_bLevRelaxed) + aParam.searchFlag |= SearchFlags::LEV_RELAXED; + aParam.changedChars = m_nLevOther; + aParam.deletedChars = m_nLevShorter; + aParam.insertedChars = m_nLevLonger; + } + aParam.searchString = strExpression; + aParam.Locale = SvtSysLocale().GetLanguageTag().getLocale(); + ::utl::TextSearch aLocalEngine( aParam); + + + bool bFound = false; + bool bMovedAround(false); + do + { + Application::Reschedule( true ); + + // the content to be compared currently + OUString sCurrentCheck; + if (m_bFormatter) + sCurrentCheck = FormatField(nFieldPos); + else + sCurrentCheck = iterFieldLoop->xContents->getString(); + + // (don't care about case here, this is done by the TextSearch object, 'cause we passed our case parameter to it) + + sal_Int32 nStart = 0, nEnd = sCurrentCheck.getLength(); + bFound = aLocalEngine.SearchForward(sCurrentCheck, &nStart, &nEnd); + // it says 'forward' here, but that only refers to the search within + // sCurrentCheck, so it has nothing to do with the direction of my + // record migration (MoveField takes care of that) + + // check if the position is correct + if (bFound) + { + switch (m_nPosition) + { + case MATCHING_WHOLETEXT : + if (nEnd != sCurrentCheck.getLength()) + { + bFound = false; + break; + } + [[fallthrough]]; + case MATCHING_BEGINNING : + if (nStart != 0) + bFound = false; + break; + case MATCHING_END : + if (nEnd != sCurrentCheck.getLength()) + bFound = false; + break; + } + } + + if (bFound) // still? + break; + + // next field (implicitly next record, if necessary) + if (!MoveField(nFieldPos, iterFieldLoop, iterBegin, iterEnd)) + { // When moving to the next field, something went wrong... + // Continuing is not possible, since the next time exactly the same + // will definitely go wrong again, thus abort (without error + // notification, I expect it to be displayed in the Move). + // Before, however, so that the search continues at the current position: + try { m_aPreviousLocBookmark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); } + m_iterPreviousLocField = iterFieldLoop; + // and leave + return SearchResult::Error; + } + + Any aCurrentBookmark; + try { aCurrentBookmark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); return SearchResult::Error; } + bMovedAround = EQUAL_BOOKMARKS(aStartMark, aCurrentBookmark) && (iterFieldLoop == iterInitialField); + + if (nFieldPos == 0) + // that is, I've moved to a new record + PropagateProgress(bMovedAround); + // if we moved to the starting position we don't have to propagate an 'overflow' message + // FS - 07.12.99 - 68530 + + // cancel requested? + if (CancelRequested()) + return SearchResult::Cancelled; + + } while (!bMovedAround); + + return bFound ? SearchResult::Found : SearchResult::NotFound; +} + + +FmSearchEngine::FmSearchEngine(const Reference< XComponentContext >& _rxContext, + const Reference< XResultSet > & xCursor, std::u16string_view sVisibleFields, + const InterfaceArray& arrFields) + :m_xSearchCursor(xCursor) + ,m_aCharacterClassficator( _rxContext, SvtSysLocale().GetLanguageTag() ) + ,m_aStringCompare( _rxContext ) + ,m_nCurrentFieldIndex(-2) // -1 already has a meaning, so I take -2 for 'invalid' + ,m_xOriginalIterator(xCursor) + ,m_xClonedIterator(m_xOriginalIterator, true) + ,m_eSearchForType(SearchFor::String) + ,m_srResult(SearchResult::Found) + ,m_bCancelAsynchRequest(false) + ,m_bSearchingCurrently(false) + ,m_bFormatter(true) // this must be consistent with m_xSearchCursor, which is generally == m_xOriginalIterator + ,m_bForward(false) + ,m_bWildcard(false) + ,m_bRegular(false) + ,m_bLevenshtein(false) + ,m_bTransliteration(false) + ,m_bLevRelaxed(false) + ,m_nLevOther(0) + ,m_nLevShorter(0) + ,m_nLevLonger(0) + ,m_nPosition(MATCHING_ANYWHERE) + ,m_nTransliterationFlags(TransliterationFlags::NONE) +{ + + fillControlTexts(arrFields); + Init(sVisibleFields); +} + + +void FmSearchEngine::SetIgnoreWidthCJK(bool bSet) +{ + if (bSet) + m_nTransliterationFlags |= TransliterationFlags::IGNORE_WIDTH; + else + m_nTransliterationFlags &= ~TransliterationFlags::IGNORE_WIDTH; +} + + +bool FmSearchEngine::GetIgnoreWidthCJK() const +{ + return bool(m_nTransliterationFlags & TransliterationFlags::IGNORE_WIDTH); +} + + +void FmSearchEngine::SetCaseSensitive(bool bSet) +{ + if (bSet) + m_nTransliterationFlags &= ~TransliterationFlags::IGNORE_CASE; + else + m_nTransliterationFlags |= TransliterationFlags::IGNORE_CASE; +} + + +bool FmSearchEngine::GetCaseSensitive() const +{ + return !(m_nTransliterationFlags & TransliterationFlags::IGNORE_CASE); +} + + +void FmSearchEngine::fillControlTexts(const InterfaceArray& arrFields) +{ + m_aControlTexts.clear(); + Reference< XInterface > xCurrent; + for (const auto & rField : arrFields) + { + xCurrent = rField; + DBG_ASSERT(xCurrent.is(), "FmSearchEngine::fillControlTexts : invalid field interface !"); + // check which type of control this is + Reference< css::awt::XTextComponent > xAsText(xCurrent, UNO_QUERY); + if (xAsText.is()) + { + m_aControlTexts.emplace_back(new SimpleTextWrapper(xAsText)); + continue; + } + + Reference< css::awt::XListBox > xAsListBox(xCurrent, UNO_QUERY); + if (xAsListBox.is()) + { + m_aControlTexts.emplace_back(new ListBoxWrapper(xAsListBox)); + continue; + } + + Reference< css::awt::XCheckBox > xAsCheckBox(xCurrent, UNO_QUERY); + DBG_ASSERT(xAsCheckBox.is(), "FmSearchEngine::fillControlTexts : invalid field interface (no supported type) !"); + // we don't have any more options ... + m_aControlTexts.emplace_back(new CheckBoxWrapper(xAsCheckBox)); + } +} + + +void FmSearchEngine::Init(std::u16string_view sVisibleFields) +{ + // analyze the fields + // additionally, create the mapping: because the list of used columns can be shorter than the list + // of columns of the cursor, we need a mapping: "used column number n" -> "cursor column m" + m_arrFieldMapping.clear(); + + // important: The case of the columns does not need to be exact - for instance: + // - a user created a form which works on a table, for which the driver returns a column name "COLUMN" + // - the driver itself works case-insensitive with column names + // - a control in the form is bound to "column" - not the different case + // In such a scenario, the form and the field would work okay, but we here need to case for the different case + // explicitly + // #i8755# + + // so first of all, check if the database handles identifiers case sensitive + Reference< XConnection > xConn; + Reference< XDatabaseMetaData > xMeta; + Reference< XPropertySet > xCursorProps( IFACECAST( m_xSearchCursor ), UNO_QUERY ); + if ( xCursorProps.is() ) + { + try + { + xCursorProps->getPropertyValue( FM_PROP_ACTIVE_CONNECTION ) >>= xConn; + } + catch( const Exception& ) { /* silent this - will be asserted below */ } + } + if ( xConn.is() ) + xMeta = xConn->getMetaData(); + OSL_ENSURE( xMeta.is(), "FmSearchEngine::Init: very strange cursor (could not derive connection meta data from it)!" ); + + bool bCaseSensitiveIdentifiers = true; // assume case sensitivity + if ( xMeta.is() ) + bCaseSensitiveIdentifiers = xMeta->supportsMixedCaseQuotedIdentifiers(); + + // now that we have this information, we need a collator which is able to case (in)sensitivity compare strings + m_aStringCompare.loadDefaultCollator( SvtSysLocale().GetLanguageTag().getLocale(), + bCaseSensitiveIdentifiers ? 0 : css::i18n::CollatorOptions::CollatorOptions_IGNORE_CASE ); + + try + { + // the cursor can give me a record (as PropertySet), which supports the DatabaseRecord service + Reference< css::sdbcx::XColumnsSupplier > xSupplyCols(IFACECAST(m_xSearchCursor), UNO_QUERY); + DBG_ASSERT(xSupplyCols.is(), "FmSearchEngine::Init : invalid cursor (no columns supplier) !"); + Reference< css::container::XNameAccess > xAllFieldNames = xSupplyCols->getColumns(); + const Sequence< OUString > seqFieldNames = xAllFieldNames->getElementNames(); + + OUString sCurrentField; + sal_Int32 nIndex = 0; + do + { + sCurrentField = o3tl::getToken(sVisibleFields, 0, ';' , nIndex); + + // search in the field collection + sal_Int32 nFoundIndex = -1; + auto pFieldName = std::find_if(seqFieldNames.begin(), seqFieldNames.end(), + [this, &sCurrentField](const OUString& rFieldName) { + return 0 == m_aStringCompare.compareString( rFieldName, sCurrentField ); }); + if (pFieldName != seqFieldNames.end()) + nFoundIndex = static_cast<sal_Int32>(std::distance(seqFieldNames.begin(), pFieldName)); + DBG_ASSERT(nFoundIndex != -1, "FmSearchEngine::Init : Invalid field name were given !"); + m_arrFieldMapping.push_back(nFoundIndex); + } + while ( nIndex >= 0 ); + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", ""); + } + +} + + +void FmSearchEngine::SetFormatterUsing(bool bSet) +{ + if (m_bFormatter == bSet) + return; + m_bFormatter = bSet; + + // I did not use a formatter, but TextComponents -> the SearchIterator needs to be adjusted + try + { + if (m_bFormatter) + { + DBG_ASSERT(m_xSearchCursor == m_xClonedIterator, "FmSearchEngine::SetFormatterUsing : inconsistent state !"); + m_xSearchCursor = m_xOriginalIterator; + m_xSearchCursor.moveToBookmark(m_xClonedIterator.getBookmark()); + // so that I continue with the new iterator at the actual place where I previously stopped + } + else + { + DBG_ASSERT(m_xSearchCursor == m_xOriginalIterator, "FmSearchEngine::SetFormatterUsing : inconsistent state !"); + m_xSearchCursor = m_xClonedIterator; + m_xSearchCursor.moveToBookmark(m_xOriginalIterator.getBookmark()); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + // I have to re-bind the fields, because the text exchange might take + // place over these fields and the underlying cursor has changed + RebuildUsedFields(m_nCurrentFieldIndex, true); +} + + +void FmSearchEngine::PropagateProgress(bool _bDontPropagateOverflow) +{ + if (!m_aProgressHandler.IsSet()) + return; + + FmSearchProgress aProgress; + try + { + aProgress.aSearchState = FmSearchProgress::State::Progress; + aProgress.nCurrentRecord = m_xSearchCursor.getRow() - 1; + if (m_bForward) + aProgress.bOverflow = !_bDontPropagateOverflow && m_xSearchCursor.isFirst(); + else + aProgress.bOverflow = !_bDontPropagateOverflow && m_xSearchCursor.isLast(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + m_aProgressHandler.Call(&aProgress); +} + + +void FmSearchEngine::SearchNextImpl() +{ + DBG_ASSERT(!(m_bWildcard && m_bRegular) && !(m_bRegular && m_bLevenshtein) && !(m_bLevenshtein && m_bWildcard), + "FmSearchEngine::SearchNextImpl : search parameters are mutually exclusive!"); + + DBG_ASSERT(m_xSearchCursor.is(), "FmSearchEngine::SearchNextImpl : have invalid iterator!"); + + // the parameters of the search + OUString strSearchExpression(m_strSearchExpression); // I need non-const + if (!GetCaseSensitive()) + // norm the string + strSearchExpression = m_aCharacterClassficator.lowercase(strSearchExpression); + + if (!m_bRegular && !m_bLevenshtein) + { // 'normal' search I run through WildCards in any case, but must before adjust the OUString depending on the mode + + if (!m_bWildcard) + { // since in all other cases * and ? in the search string are of course + // also allowed, but should not count as WildCards, I need to normalize + OUString aTmp(strSearchExpression); + aTmp = aTmp.replaceAll("*", "\\*"); + aTmp = aTmp.replaceAll("?", "\\?"); + strSearchExpression = aTmp; + + switch (m_nPosition) + { + case MATCHING_ANYWHERE : + strSearchExpression = "*" + strSearchExpression + "*"; + break; + case MATCHING_BEGINNING : + strSearchExpression += "*"; + break; + case MATCHING_END : + strSearchExpression = "*" + strSearchExpression; + break; + case MATCHING_WHOLETEXT : + break; + default : + OSL_FAIL("FmSearchEngine::SearchNextImpl() : the methods listbox may contain only 4 entries ..."); + } + } + } + + // for work on field list + FieldCollection::iterator iterBegin = m_arrUsedFields.begin(); + FieldCollection::iterator iterEnd = m_arrUsedFields.end(); + FieldCollection::iterator iterFieldCheck; + + sal_Int32 nFieldPos; + + if (m_aPreviousLocBookmark.hasValue()) + { + DBG_ASSERT(EQUAL_BOOKMARKS(m_aPreviousLocBookmark, m_xSearchCursor.getBookmark()), + "FmSearchEngine::SearchNextImpl : invalid position!"); + iterFieldCheck = m_iterPreviousLocField; + // continue in the field after (or before) the last discovery + nFieldPos = iterFieldCheck - iterBegin; + MoveField(nFieldPos, iterFieldCheck, iterBegin, iterEnd); + } + else + { + if (m_bForward) + iterFieldCheck = iterBegin; + else + { + iterFieldCheck = iterEnd; + --iterFieldCheck; + } + nFieldPos = iterFieldCheck - iterBegin; + } + + PropagateProgress(true); + SearchResult srResult; + if (m_eSearchForType != SearchFor::String) + srResult = SearchSpecial(m_eSearchForType == SearchFor::Null, nFieldPos, iterFieldCheck, iterBegin, iterEnd); + else if (!m_bRegular && !m_bLevenshtein) + srResult = SearchWildcard(strSearchExpression, nFieldPos, iterFieldCheck, iterBegin, iterEnd); + else + srResult = SearchRegularApprox(strSearchExpression, nFieldPos, iterFieldCheck, iterBegin, iterEnd); + + m_srResult = srResult; + + if (SearchResult::Error == m_srResult) + return; + + // found? + if (SearchResult::Found == m_srResult) + { + // memorize the position + try { m_aPreviousLocBookmark = m_xSearchCursor.getBookmark(); } + catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION("svx"); } + m_iterPreviousLocField = iterFieldCheck; + } + else + // invalidate the "last discovery" + InvalidatePreviousLoc(); +} + + +void FmSearchEngine::OnSearchTerminated() +{ + if (!m_aProgressHandler.IsSet()) + return; + + FmSearchProgress aProgress; + try + { + switch (m_srResult) + { + case SearchResult::Error : + aProgress.aSearchState = FmSearchProgress::State::Error; + break; + case SearchResult::Found : + aProgress.aSearchState = FmSearchProgress::State::Successful; + aProgress.aBookmark = m_aPreviousLocBookmark; + aProgress.nFieldIndex = m_iterPreviousLocField - m_arrUsedFields.begin(); + break; + case SearchResult::NotFound : + aProgress.aSearchState = FmSearchProgress::State::NothingFound; + aProgress.aBookmark = m_xSearchCursor.getBookmark(); + break; + case SearchResult::Cancelled : + aProgress.aSearchState = FmSearchProgress::State::Canceled; + aProgress.aBookmark = m_xSearchCursor.getBookmark(); + break; + } + aProgress.nCurrentRecord = m_xSearchCursor.getRow() - 1; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + // by definition, the link must be thread-safe (I just require that), + // so that I do not have to worry about such things here + m_aProgressHandler.Call(&aProgress); + + m_bSearchingCurrently = false; +} + + +IMPL_LINK(FmSearchEngine, OnNewRecordCount, sal_Int32, theCounter, void) +{ + if (!m_aProgressHandler.IsSet()) + return; + + FmSearchProgress aProgress; + aProgress.nCurrentRecord = theCounter; + aProgress.aSearchState = FmSearchProgress::State::ProgressCounting; + m_aProgressHandler.Call(&aProgress); +} + + +bool FmSearchEngine::CancelRequested() +{ + bool bReturn = m_bCancelAsynchRequest; + return bReturn; +} + + +void FmSearchEngine::CancelSearch() +{ + m_bCancelAsynchRequest = true; +} + + +void FmSearchEngine::SwitchToContext(const Reference< css::sdbc::XResultSet > & xCursor, std::u16string_view sVisibleFields, const InterfaceArray& arrFields, + sal_Int32 nFieldIndex) +{ + DBG_ASSERT(!m_bSearchingCurrently, "FmSearchEngine::SwitchToContext : please do not call while I'm searching !"); + if (m_bSearchingCurrently) + return; + + m_xSearchCursor = xCursor; + m_xOriginalIterator = xCursor; + m_xClonedIterator = CursorWrapper(m_xOriginalIterator, true); + + fillControlTexts(arrFields); + + Init(sVisibleFields); + RebuildUsedFields(nFieldIndex, true); +} + + +void FmSearchEngine::ImplStartNextSearch() +{ + m_bCancelAsynchRequest = false; + m_bSearchingCurrently = true; + + SearchNextImpl(); + OnSearchTerminated(); +} + + +void FmSearchEngine::SearchNext(const OUString& strExpression) +{ + m_strSearchExpression = strExpression; + m_eSearchForType = SearchFor::String; + ImplStartNextSearch(); +} + + +void FmSearchEngine::SearchNextSpecial(bool _bSearchForNull) +{ + m_eSearchForType = _bSearchForNull ? SearchFor::Null : SearchFor::NotNull; + ImplStartNextSearch(); +} + + +void FmSearchEngine::StartOver(const OUString& strExpression) +{ + try + { + if (m_bForward) + m_xSearchCursor.first(); + else + m_xSearchCursor.last(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + return; + } + + InvalidatePreviousLoc(); + SearchNext(strExpression); +} + + +void FmSearchEngine::StartOverSpecial(bool _bSearchForNull) +{ + try + { + if (m_bForward) + m_xSearchCursor.first(); + else + m_xSearchCursor.last(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + return; + } + + InvalidatePreviousLoc(); + SearchNextSpecial(_bSearchForNull); +} + + +void FmSearchEngine::InvalidatePreviousLoc() +{ + m_aPreviousLocBookmark.clear(); + m_iterPreviousLocField = m_arrUsedFields.end(); +} + + +void FmSearchEngine::RebuildUsedFields(sal_Int32 nFieldIndex, bool bForce) +{ + if (!bForce && (nFieldIndex == m_nCurrentFieldIndex)) + return; + // (since I allow no change of the iterator from the outside, the same css::sdbcx::Index + // also always means the same column, so I have nothing to do) + + DBG_ASSERT((nFieldIndex == -1) || + ((nFieldIndex >= 0) && + (o3tl::make_unsigned(nFieldIndex) < m_arrFieldMapping.size())), + "FmSearchEngine::RebuildUsedFields : nFieldIndex is invalid!"); + // collect all fields I need to search through + m_arrUsedFields.clear(); + if (nFieldIndex == -1) + { + Reference< css::container::XIndexAccess > xFields; + for (sal_Int32 i : m_arrFieldMapping) + { + Reference< css::sdbcx::XColumnsSupplier > xSupplyCols(IFACECAST(m_xSearchCursor), UNO_QUERY); + DBG_ASSERT(xSupplyCols.is(), "FmSearchEngine::RebuildUsedFields : invalid cursor (no columns supplier) !"); + xFields.set(xSupplyCols->getColumns(), UNO_QUERY); + BuildAndInsertFieldInfo(xFields, i); + } + } + else + { + Reference< css::container::XIndexAccess > xFields; + Reference< css::sdbcx::XColumnsSupplier > xSupplyCols(IFACECAST(m_xSearchCursor), UNO_QUERY); + DBG_ASSERT(xSupplyCols.is(), "FmSearchEngine::RebuildUsedFields : invalid cursor (no columns supplier) !"); + xFields.set (xSupplyCols->getColumns(), UNO_QUERY); + BuildAndInsertFieldInfo(xFields, m_arrFieldMapping[static_cast< size_t >(nFieldIndex)]); + } + + m_nCurrentFieldIndex = nFieldIndex; + // and of course I start the next search in a virgin state again + InvalidatePreviousLoc(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmtextcontroldialogs.cxx b/svx/source/form/fmtextcontroldialogs.cxx new file mode 100644 index 000000000..c365becea --- /dev/null +++ b/svx/source/form/fmtextcontroldialogs.cxx @@ -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 . + */ + +#include <fmtextcontroldialogs.hxx> +#include <svx/dialogs.hrc> +#include <svx/svxids.hrc> + +#include <svx/flagsdef.hxx> +#include <svl/intitem.hxx> + +#include <svl/cjkoptions.hxx> + + +namespace svx +{ + + TextControlCharAttribDialog::TextControlCharAttribDialog(weld::Window* pParent, const SfxItemSet& rCoreSet, const SvxFontListItem& rFontList) + : SfxTabDialogController(pParent, "svx/ui/textcontrolchardialog.ui", "TextControlCharacterPropertiesDialog", &rCoreSet) + , m_aFontList(rFontList) + { + AddTabPage("font", RID_SVXPAGE_CHAR_NAME); + AddTabPage("fonteffects", RID_SVXPAGE_CHAR_EFFECTS); + AddTabPage("position", RID_SVXPAGE_CHAR_POSITION); + } + + void TextControlCharAttribDialog::PageCreated(const OString& rId, SfxTabPage& rPage) + { + SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool())); + + if (rId == "font") + { + aSet.Put (m_aFontList); + rPage.PageCreated(aSet); + } + else if (rId == "fonteffects") + { + aSet.Put (SfxUInt16Item(SID_DISABLE_CTL,DISABLE_CASEMAP)); + rPage.PageCreated(aSet); + } + else if (rId == "position") + { + aSet.Put( SfxUInt32Item(SID_FLAG_TYPE, SVX_PREVIEW_CHARACTER) ); + rPage.PageCreated(aSet); + } + } + + TextControlParaAttribDialog::TextControlParaAttribDialog(weld::Window* pParent, const SfxItemSet& rCoreSet) + : SfxTabDialogController(pParent, "svx/ui/textcontrolparadialog.ui", "TextControlParagraphPropertiesDialog", &rCoreSet) + { + AddTabPage("labelTP_PARA_STD", RID_SVXPAGE_STD_PARAGRAPH); + AddTabPage("labelTP_PARA_ALIGN", RID_SVXPAGE_ALIGN_PARAGRAPH); + + if( SvtCJKOptions::IsAsianTypographyEnabled() ) + AddTabPage("labelTP_PARA_ASIAN", RID_SVXPAGE_PARA_ASIAN); + else + RemoveTabPage("labelTP_PARA_ASIAN"); + + AddTabPage("labelTP_TABULATOR", RID_SVXPAGE_TABULATOR); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmtextcontrolfeature.cxx b/svx/source/form/fmtextcontrolfeature.cxx new file mode 100644 index 000000000..68bb8606a --- /dev/null +++ b/svx/source/form/fmtextcontrolfeature.cxx @@ -0,0 +1,118 @@ +/* -*- 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 <fmtextcontrolfeature.hxx> +#include <fmtextcontrolshell.hxx> + +#include <osl/diagnose.h> +#include <tools/diagnose_ex.h> + +namespace svx +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::util; + + FmTextControlFeature::FmTextControlFeature( const Reference< XDispatch >& _rxDispatcher, const URL& _rFeatureURL, SfxSlotId _nSlotId, FmTextControlShell* _pInvalidator ) + :m_xDispatcher ( _rxDispatcher ) + ,m_aFeatureURL ( _rFeatureURL ) + ,m_nSlotId ( _nSlotId ) + ,m_pInvalidator ( _pInvalidator ) + ,m_bFeatureEnabled( false ) + { + OSL_ENSURE( _rxDispatcher.is(), "FmTextControlFeature::FmTextControlFeature: invalid dispatcher!" ); + OSL_ENSURE( m_nSlotId, "FmTextControlFeature::FmTextControlFeature: invalid slot id!" ); + OSL_ENSURE( m_pInvalidator, "FmTextControlFeature::FmTextControlFeature: invalid invalidator!" ); + + osl_atomic_increment( &m_refCount ); + try + { + m_xDispatcher->addStatusListener( this, m_aFeatureURL ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmTextControlFeature::FmTextControlFeature" ); + } + osl_atomic_decrement( &m_refCount ); + } + + + FmTextControlFeature::~FmTextControlFeature( ) + { + } + + + void FmTextControlFeature::dispatch() const + { + dispatch( Sequence< PropertyValue >( ) ); + } + + + void FmTextControlFeature::dispatch( const Sequence< PropertyValue >& _rArgs ) const + { + try + { + if ( m_xDispatcher.is() ) + m_xDispatcher->dispatch( m_aFeatureURL, _rArgs ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmTextControlFeature::dispatch" ); + } + } + + + void SAL_CALL FmTextControlFeature::statusChanged( const FeatureStateEvent& _rState ) + { + m_aFeatureState = _rState.State; + m_bFeatureEnabled = _rState.IsEnabled; + + if ( m_pInvalidator ) + m_pInvalidator->Invalidate( m_nSlotId ); + } + + + void SAL_CALL FmTextControlFeature::disposing( const EventObject& /*Source*/ ) + { + // nothing to do + } + + + void FmTextControlFeature::dispose() + { + try + { + m_xDispatcher->removeStatusListener( this, m_aFeatureURL ); + m_xDispatcher.clear(); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmTextControlFeature::dispose" ); + } + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmtextcontrolshell.cxx b/svx/source/form/fmtextcontrolshell.cxx new file mode 100644 index 000000000..d97dfeb85 --- /dev/null +++ b/svx/source/form/fmtextcontrolshell.cxx @@ -0,0 +1,1315 @@ +/* -*- 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 <fmprop.hxx> +#include <fmtextcontroldialogs.hxx> +#include <fmtextcontrolfeature.hxx> +#include <fmtextcontrolshell.hxx> +#include <editeng/crossedoutitem.hxx> +#include <editeng/editeng.hxx> +#include <editeng/scriptspaceitem.hxx> +#include <svx/svxids.hrc> +#include <editeng/udlnitem.hxx> + +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/frame/XDispatchProvider.hpp> +#include <com/sun/star/container/XChild.hpp> +#include <com/sun/star/awt/XFocusListener.hpp> +#include <com/sun/star/awt/XMouseListener.hpp> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/util/URLTransformer.hpp> + +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <cppuhelper/implbase.hxx> +#include <sfx2/app.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/msgpool.hxx> +#include <sfx2/msg.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/request.hxx> +#include <sfx2/sfxuno.hxx> +#include <sfx2/viewfrm.hxx> +#include <svl/eitem.hxx> +#include <svl/itempool.hxx> +#include <svl/ctloptions.hxx> +#include <svtools/stringtransfer.hxx> +#include <svl/whiter.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <sal/log.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> + +#include <memory> + + +namespace svx +{ + + + using namespace ::com::sun::star; + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::form; + using namespace ::com::sun::star::form::runtime; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::util; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::container; + + + typedef sal_uInt16 WhichId; + + + static SfxSlotId pTextControlSlots[] = + { + SID_CLIPBOARD_FORMAT_ITEMS, + SID_CUT, + SID_COPY, + SID_PASTE, + SID_SELECTALL, +// SID_ATTR_TABSTOP, /* 2 */ + SID_ATTR_CHAR_FONT, + SID_ATTR_CHAR_POSTURE, + SID_ATTR_CHAR_WEIGHT, + SID_ATTR_CHAR_SHADOWED, + SID_ATTR_CHAR_WORDLINEMODE, + SID_ATTR_CHAR_CONTOUR, + SID_ATTR_CHAR_STRIKEOUT, + SID_ATTR_CHAR_UNDERLINE, + SID_ATTR_CHAR_FONTHEIGHT, + SID_ATTR_CHAR_COLOR, + SID_ATTR_CHAR_KERNING, + SID_ATTR_CHAR_LANGUAGE, /* 20 */ + SID_ATTR_CHAR_ESCAPEMENT, + SID_ATTR_PARA_ADJUST, /* 28 */ + SID_ATTR_PARA_ADJUST_LEFT, + SID_ATTR_PARA_ADJUST_RIGHT, + SID_ATTR_PARA_ADJUST_CENTER, + SID_ATTR_PARA_ADJUST_BLOCK, + SID_ATTR_PARA_LINESPACE, /* 33 */ + SID_ATTR_PARA_LINESPACE_10, + SID_ATTR_PARA_LINESPACE_15, + SID_ATTR_PARA_LINESPACE_20, + SID_ATTR_LRSPACE, /* 48 */ + SID_ATTR_ULSPACE, /* 49 */ + SID_ATTR_CHAR_AUTOKERN, + SID_SET_SUPER_SCRIPT, + SID_SET_SUB_SCRIPT, + SID_CHAR_DLG, + SID_PARA_DLG, +// SID_TEXTDIRECTION_LEFT_TO_RIGHT, /* 907 */ +// SID_TEXTDIRECTION_TOP_TO_BOTTOM, + SID_ATTR_CHAR_SCALEWIDTH, /* 911 */ + SID_ATTR_CHAR_RELIEF, + SID_ATTR_PARA_LEFT_TO_RIGHT, /* 950 */ + SID_ATTR_PARA_RIGHT_TO_LEFT, + SID_ATTR_CHAR_OVERLINE, + 0 + }; + + // slots which we are not responsible for on the SfxShell level, but + // need to handle during the "paragraph attributes" and/or "character + // attributes" dialogs + static SfxSlotId pDialogSlots[] = + { + SID_ATTR_TABSTOP, + SID_ATTR_PARA_HANGPUNCTUATION, + SID_ATTR_PARA_FORBIDDEN_RULES, + SID_ATTR_PARA_SCRIPTSPACE, + SID_ATTR_CHAR_LATIN_LANGUAGE, + SID_ATTR_CHAR_CJK_LANGUAGE, + SID_ATTR_CHAR_CTL_LANGUAGE, + SID_ATTR_CHAR_LATIN_FONT, + SID_ATTR_CHAR_CJK_FONT, + SID_ATTR_CHAR_CTL_FONT, + SID_ATTR_CHAR_LATIN_FONTHEIGHT, + SID_ATTR_CHAR_CJK_FONTHEIGHT, + SID_ATTR_CHAR_CTL_FONTHEIGHT, + SID_ATTR_CHAR_LATIN_WEIGHT, + SID_ATTR_CHAR_CJK_WEIGHT, + SID_ATTR_CHAR_CTL_WEIGHT, + SID_ATTR_CHAR_LATIN_POSTURE, + SID_ATTR_CHAR_CJK_POSTURE, + SID_ATTR_CHAR_CTL_POSTURE, + SID_ATTR_CHAR_EMPHASISMARK, + 0 + }; + + typedef ::cppu::WeakImplHelper < css::awt::XFocusListener + > FmFocusListenerAdapter_Base; + class FmFocusListenerAdapter : public FmFocusListenerAdapter_Base + { + private: + IFocusObserver* m_pObserver; + Reference< css::awt::XWindow > m_xWindow; + + public: + FmFocusListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IFocusObserver* _pObserver ); + + // clean up the instance + void dispose(); + + protected: + virtual ~FmFocusListenerAdapter() override; + + protected: + virtual void SAL_CALL focusGained( const css::awt::FocusEvent& e ) override; + virtual void SAL_CALL focusLost( const css::awt::FocusEvent& e ) override; + virtual void SAL_CALL disposing( const EventObject& Source ) override; + }; + + + FmFocusListenerAdapter::FmFocusListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IFocusObserver* _pObserver ) + :m_pObserver( _pObserver ) + ,m_xWindow( _rxControl, UNO_QUERY ) + { + + DBG_ASSERT( m_xWindow.is(), "FmFocusListenerAdapter::FmFocusListenerAdapter: invalid control!" ); + osl_atomic_increment( &m_refCount ); + { + try + { + if ( m_xWindow.is() ) + m_xWindow->addFocusListener( this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + osl_atomic_decrement( &m_refCount ); + } + + + FmFocusListenerAdapter::~FmFocusListenerAdapter() + { + acquire(); + dispose(); + + } + + + void FmFocusListenerAdapter::dispose() + { + if ( m_xWindow.is() ) + { + m_xWindow->removeFocusListener( this ); + m_xWindow.clear(); + } + } + + + void SAL_CALL FmFocusListenerAdapter::focusGained( const css::awt::FocusEvent& e ) + { + if ( m_pObserver ) + m_pObserver->focusGained( e ); + } + + + void SAL_CALL FmFocusListenerAdapter::focusLost( const css::awt::FocusEvent& e ) + { + if ( m_pObserver ) + m_pObserver->focusLost( e ); + } + + + void SAL_CALL FmFocusListenerAdapter::disposing( const EventObject& Source ) + { + DBG_ASSERT( Source.Source == m_xWindow, "FmFocusListenerAdapter::disposing: where did this come from?" ); + m_xWindow.clear(); + } + + typedef ::cppu::WeakImplHelper < css::awt::XMouseListener + > FmMouseListenerAdapter_Base; + class FmMouseListenerAdapter : public FmMouseListenerAdapter_Base + { + private: + IContextRequestObserver* m_pObserver; + Reference< css::awt::XWindow > m_xWindow; + + public: + FmMouseListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IContextRequestObserver* _pObserver ); + + // clean up the instance + void dispose(); + + protected: + virtual ~FmMouseListenerAdapter() override; + + protected: + virtual void SAL_CALL mousePressed( const css::awt::MouseEvent& e ) override; + virtual void SAL_CALL mouseReleased( const css::awt::MouseEvent& e ) override; + virtual void SAL_CALL mouseEntered( const css::awt::MouseEvent& e ) override; + virtual void SAL_CALL mouseExited( const css::awt::MouseEvent& e ) override; + virtual void SAL_CALL disposing( const EventObject& Source ) override; + }; + + FmMouseListenerAdapter::FmMouseListenerAdapter( const Reference< css::awt::XControl >& _rxControl, IContextRequestObserver* _pObserver ) + :m_pObserver( _pObserver ) + ,m_xWindow( _rxControl, UNO_QUERY ) + { + + DBG_ASSERT( m_xWindow.is(), "FmMouseListenerAdapter::FmMouseListenerAdapter: invalid control!" ); + osl_atomic_increment( &m_refCount ); + { + try + { + if ( m_xWindow.is() ) + m_xWindow->addMouseListener( this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + osl_atomic_decrement( &m_refCount ); + } + + + FmMouseListenerAdapter::~FmMouseListenerAdapter() + { + acquire(); + dispose(); + + } + + + void FmMouseListenerAdapter::dispose() + { + if ( m_xWindow.is() ) + { + m_xWindow->removeMouseListener( this ); + m_xWindow.clear(); + } + } + + + void SAL_CALL FmMouseListenerAdapter::mousePressed( const css::awt::MouseEvent& _rEvent ) + { + SolarMutexGuard aGuard; + // is this a request for a context menu? + if ( _rEvent.PopupTrigger ) + { + if ( m_pObserver ) + m_pObserver->contextMenuRequested(); + } + } + + + void SAL_CALL FmMouseListenerAdapter::mouseReleased( const css::awt::MouseEvent& /*e*/ ) + { + // not interested in + } + + + void SAL_CALL FmMouseListenerAdapter::mouseEntered( const css::awt::MouseEvent& /*e*/ ) + { + // not interested in + } + + + void SAL_CALL FmMouseListenerAdapter::mouseExited( const css::awt::MouseEvent& /*e*/ ) + { + // not interested in + } + + + void SAL_CALL FmMouseListenerAdapter::disposing( const EventObject& Source ) + { + DBG_ASSERT( Source.Source == m_xWindow, "FmMouseListenerAdapter::disposing: where did this come from?" ); + m_xWindow.clear(); + } + + + //= FmTextControlShell + + + namespace + { + + void lcl_translateUnoStateToItem( SfxSlotId _nSlot, const Any& _rUnoState, SfxItemSet& _rSet ) + { + WhichId nWhich = _rSet.GetPool()->GetWhich( _nSlot ); + if ( !_rUnoState.hasValue() ) + { + if ( ( _nSlot != SID_CUT ) + && ( _nSlot != SID_COPY ) + && ( _nSlot != SID_PASTE ) + ) + { + _rSet.InvalidateItem( nWhich ); + } + } + else + { + switch ( _rUnoState.getValueType().getTypeClass() ) + { + case TypeClass_BOOLEAN: + { + bool bState = false; + _rUnoState >>= bState; + if ( _nSlot == SID_ATTR_PARA_SCRIPTSPACE ) + _rSet.Put( SvxScriptSpaceItem( bState, nWhich ) ); + else + _rSet.Put( SfxBoolItem( nWhich, bState ) ); + } + break; + + default: + { + Sequence< PropertyValue > aComplexState; + if ( _rUnoState >>= aComplexState ) + { + if ( !aComplexState.hasElements() ) + _rSet.InvalidateItem( nWhich ); + else + { + SfxAllItemSet aAllItems( _rSet ); + TransformParameters( _nSlot, aComplexState, aAllItems ); + const SfxPoolItem* pTransformed = aAllItems.GetItem( nWhich ); + OSL_ENSURE( pTransformed, "lcl_translateUnoStateToItem: non-empty parameter sequence leading to empty item?" ); + if ( pTransformed ) + _rSet.Put( *pTransformed ); + else + _rSet.InvalidateItem( nWhich ); + } + } + else + { + OSL_FAIL( "lcl_translateUnoStateToItem: invalid state!" ); + } + } + } + } + } + + + OUString lcl_getUnoSlotName( SfxSlotId _nSlotId ) + { + OUString sSlotUnoName; + + SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool(); + const SfxSlot* pSlot = rSlotPool.GetSlot( _nSlotId ); + + const char* pAsciiUnoName = nullptr; + if ( pSlot ) + { + pAsciiUnoName = pSlot->GetUnoName(); + } + else + { + // some hard-coded slots, which do not have a UNO name at SFX level, but which + // we nevertheless need to transport via UNO mechanisms, so we need a name + switch ( _nSlotId ) + { + case SID_ATTR_PARA_HANGPUNCTUATION: pAsciiUnoName = "AllowHangingPunctuation"; break; + case SID_ATTR_PARA_FORBIDDEN_RULES: pAsciiUnoName = "ApplyForbiddenCharacterRules"; break; + case SID_ATTR_PARA_SCRIPTSPACE: pAsciiUnoName = "UseScriptSpacing"; break; + } + } + + if ( pAsciiUnoName ) + { + sSlotUnoName = ".uno:" + OUString::createFromAscii( pAsciiUnoName ); + } + else + { + SAL_WARN( "svx", "lcl_getUnoSlotName: invalid slot id, or invalid slot, or no UNO name! " + "(slot id: " << _nSlotId << ")"); + } + return sSlotUnoName; + } + + + bool lcl_determineReadOnly( const Reference< css::awt::XControl >& _rxControl ) + { + bool bIsReadOnlyModel = true; + try + { + Reference< XPropertySet > xModelProps; + if ( _rxControl.is() ) + xModelProps.set(_rxControl->getModel(), css::uno::UNO_QUERY); + Reference< XPropertySetInfo > xModelPropInfo; + if ( xModelProps.is() ) + xModelPropInfo = xModelProps->getPropertySetInfo(); + + if ( !xModelPropInfo.is() || !xModelPropInfo->hasPropertyByName( FM_PROP_READONLY ) ) + bIsReadOnlyModel = true; + else + { + bool bReadOnly = true; + xModelProps->getPropertyValue( FM_PROP_READONLY ) >>= bReadOnly; + bIsReadOnlyModel = bReadOnly; + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return bIsReadOnlyModel; + } + + + vcl::Window* lcl_getWindow( const Reference< css::awt::XControl >& _rxControl ) + { + vcl::Window* pWindow = nullptr; + try + { + Reference< css::awt::XWindowPeer > xControlPeer; + if ( _rxControl.is() ) + xControlPeer = _rxControl->getPeer(); + if ( xControlPeer.is() ) + pWindow = VCLUnoHelper::GetWindow( xControlPeer ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + return pWindow; + } + + + bool lcl_isRichText( const Reference< css::awt::XControl >& _rxControl ) + { + if ( !_rxControl.is() ) + return false; + + bool bIsRichText = false; + try + { + Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY ); + Reference< XPropertySetInfo > xPSI; + if ( xModelProps.is() ) + xPSI = xModelProps->getPropertySetInfo(); + OUString sRichTextPropertyName = "RichText"; + if ( xPSI.is() && xPSI->hasPropertyByName( sRichTextPropertyName ) ) + { + OSL_VERIFY( xModelProps->getPropertyValue( sRichTextPropertyName ) >>= bIsRichText ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return bIsRichText; + } + } + + + FmTextControlShell::FmTextControlShell( SfxViewFrame* _pFrame ) + :m_bActiveControl( false ) + ,m_bActiveControlIsReadOnly( true ) + ,m_bActiveControlIsRichText( false ) + ,m_pViewFrame( _pFrame ) + ,m_rBindings( _pFrame->GetBindings() ) + ,m_aClipboardInvalidation("svx FmTextControlShell m_aClipboardInvalidation") + ,m_bNeedClipboardInvalidation( true ) + { + m_aClipboardInvalidation.SetInvokeHandler( LINK( this, FmTextControlShell, OnInvalidateClipboard ) ); + m_aClipboardInvalidation.SetTimeout( 200 ); + } + + + FmTextControlShell::~FmTextControlShell() + { + dispose(); + } + + + IMPL_LINK_NOARG( FmTextControlShell, OnInvalidateClipboard, Timer*, void ) + { + if ( m_bNeedClipboardInvalidation ) + { + SAL_INFO("svx.form", "invalidating clipboard slots" ); + m_rBindings.Invalidate( SID_CUT ); + m_rBindings.Invalidate( SID_COPY ); + m_rBindings.Invalidate( SID_PASTE ); + m_bNeedClipboardInvalidation = false; + } + } + + + void FmTextControlShell::transferFeatureStatesToItemSet( ControlFeatures& _rDispatchers, SfxAllItemSet& _rSet, bool _bTranslateLatin ) + { + SfxItemPool& rPool = *_rSet.GetPool(); + + for (const auto& rFeature : _rDispatchers) + { + SfxSlotId nSlotId( rFeature.first ); +#if OSL_DEBUG_LEVEL > 0 + OUString sUnoSlotName; + if ( SfxGetpApp() ) + sUnoSlotName = lcl_getUnoSlotName( nSlotId ); + else + sUnoSlotName = "<unknown>"; + OString sUnoSlotNameAscii = "\"" + + OString( sUnoSlotName.getStr(), sUnoSlotName.getLength(), RTL_TEXTENCODING_ASCII_US ) + + "\""; +#endif + + if ( _bTranslateLatin ) + { + // A rich text control offers a dispatcher for the "Font" slot/feature. + // Sadly, the semantics of the dispatches is that the feature "Font" depends + // on the current cursor position: If it's on latin text, it's the "latin font" + // which is set up at the control. If it's on CJK text, it's the "CJK font", and + // equivalent for "CTL font". + // The same holds for some other font related features/slots. + // Thus, we have separate dispatches for "Latin Font", "Latin Font Size", etc, + // which are only "virtual", in a sense that there exist no item with this id. + // So when we encounter such a dispatcher for, say, "Latin Font", we need to + // put an item into the set which has the "Font" id. + + switch ( nSlotId ) + { + case SID_ATTR_CHAR_LATIN_FONT: nSlotId = SID_ATTR_CHAR_FONT; break; + case SID_ATTR_CHAR_LATIN_FONTHEIGHT:nSlotId = SID_ATTR_CHAR_FONTHEIGHT; break; + case SID_ATTR_CHAR_LATIN_LANGUAGE: nSlotId = SID_ATTR_CHAR_LANGUAGE; break; + case SID_ATTR_CHAR_LATIN_POSTURE: nSlotId = SID_ATTR_CHAR_POSTURE; break; + case SID_ATTR_CHAR_LATIN_WEIGHT: nSlotId = SID_ATTR_CHAR_WEIGHT; break; + } + } + + WhichId nWhich = rPool.GetWhich( nSlotId ); + bool bIsInPool = rPool.IsInRange( nWhich ); + if ( bIsInPool ) + { +#if OSL_DEBUG_LEVEL > 0 + bool bFeatureIsEnabled = rFeature.second->isFeatureEnabled(); + OString sMessage = "found a feature state for " + sUnoSlotNameAscii; + if ( !bFeatureIsEnabled ) + sMessage += " (disabled)"; + SAL_INFO("svx.form", sMessage ); +#endif + + lcl_translateUnoStateToItem( nSlotId, rFeature.second->getFeatureState(), _rSet ); + } +#if OSL_DEBUG_LEVEL > 0 + else + { + SAL_WARN("svx.form", "found a feature state for " << sUnoSlotNameAscii << ", but could not translate it into an item!" ); + } +#endif + } + } + + + void FmTextControlShell::executeAttributeDialog( AttributeSet _eSet, SfxRequest& rReq ) + { + const SvxFontListItem* pFontList = dynamic_cast<const SvxFontListItem*>( m_pViewFrame->GetObjectShell()->GetItem( SID_ATTR_CHAR_FONTLIST ) ); + DBG_ASSERT( pFontList, "FmTextControlShell::executeAttributeDialog: no font list item!" ); + if ( !pFontList ) + return; + + rtl::Reference<SfxItemPool> pPool(EditEngine::CreatePool()); + pPool->FreezeIdRanges(); + std::optional< SfxItemSet > xPureItems(( SfxItemSet( *pPool ) )); + + // put the current states of the items into the set + std::optional<SfxAllItemSet> xCurrentItems(( SfxAllItemSet( *xPureItems ) )); + transferFeatureStatesToItemSet( m_aControlFeatures, *xCurrentItems, false ); + + // additional items, which we are not responsible for at the SfxShell level, + // but which need to be forwarded to the dialog, anyway + ControlFeatures aAdditionalFestures; + fillFeatureDispatchers( m_xActiveControl, pDialogSlots, aAdditionalFestures ); + transferFeatureStatesToItemSet( aAdditionalFestures, *xCurrentItems, true ); + + std::unique_ptr<SfxTabDialogController> xDialog; + if (_eSet == eCharAttribs) + xDialog = std::make_unique<TextControlCharAttribDialog>(rReq.GetFrameWeld(), *xCurrentItems, *pFontList); + else + xDialog = std::make_unique<TextControlParaAttribDialog>(rReq.GetFrameWeld(), *xCurrentItems); + if ( RET_OK == xDialog->run() ) + { + const SfxItemSet& rModifiedItems = *xDialog->GetOutputItemSet(); + for ( WhichId nWhich = pPool->GetFirstWhich(); nWhich <= pPool->GetLastWhich(); ++nWhich ) + { + if ( rModifiedItems.GetItemState( nWhich ) == SfxItemState::SET ) + { + SfxSlotId nSlotForItemSet = pPool->GetSlotId( nWhich ); + const SfxPoolItem* pModifiedItem = rModifiedItems.GetItem( nWhich ); + + + SfxSlotId nSlotForDispatcher = nSlotForItemSet; + switch ( nSlotForDispatcher ) + { + case SID_ATTR_CHAR_FONT: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_FONT; break; + case SID_ATTR_CHAR_FONTHEIGHT:nSlotForDispatcher = SID_ATTR_CHAR_LATIN_FONTHEIGHT; break; + case SID_ATTR_CHAR_LANGUAGE: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_LANGUAGE; break; + case SID_ATTR_CHAR_POSTURE: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_POSTURE; break; + case SID_ATTR_CHAR_WEIGHT: nSlotForDispatcher = SID_ATTR_CHAR_LATIN_WEIGHT; break; + } + + // do we already have a dispatcher for this slot/feature? + ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlotForDispatcher ); + bool bFound = aFeaturePos != m_aControlFeatures.end( ); + + if ( !bFound ) + { + aFeaturePos = aAdditionalFestures.find( nSlotForDispatcher ); + bFound = aFeaturePos != aAdditionalFestures.end( ); + } + + if ( bFound ) + { + Sequence< PropertyValue > aArgs; + // temporarily put the modified item into a "clean" set, + // and let TransformItems calc the respective UNO parameters + xPureItems->Put( *pModifiedItem ); + TransformItems( nSlotForItemSet, *xPureItems, aArgs ); + xPureItems->ClearItem( nWhich ); + + if ( ( nSlotForItemSet == SID_ATTR_PARA_HANGPUNCTUATION ) + || ( nSlotForItemSet == SID_ATTR_PARA_FORBIDDEN_RULES ) + || ( nSlotForItemSet == SID_ATTR_PARA_SCRIPTSPACE ) + ) + { + // these are no UNO slots, they need special handling since TransformItems cannot + // handle them + DBG_ASSERT( !aArgs.hasElements(), "FmTextControlShell::executeAttributeDialog: these are no UNO slots - are they?" ); + + const SfxBoolItem* pBoolItem = dynamic_cast<const SfxBoolItem*>( pModifiedItem ); + DBG_ASSERT( pBoolItem, "FmTextControlShell::executeAttributeDialog: no bool item?!" ); + if ( pBoolItem ) + { + aArgs = { comphelper::makePropertyValue("Enable", + pBoolItem->GetValue()) }; + } + } + + // dispatch this + aFeaturePos->second->dispatch( aArgs ); + } + #if OSL_DEBUG_LEVEL > 0 + else + { + OUString sUnoSlotName = lcl_getUnoSlotName( nSlotForItemSet ); + if ( sUnoSlotName.isEmpty() ) + sUnoSlotName = "unknown (no SfxSlot)"; + SAL_WARN( "svx", "FmTextControShell::executeAttributeDialog: Could not handle the following item:" + "\n SlotID: " << nSlotForItemSet + << "\n WhichID: " << nWhich + << "\n UNO name: " << sUnoSlotName ); + } + #endif + } + } + rReq.Done( rModifiedItems ); + } + + xDialog.reset(); + xCurrentItems.reset(); + xPureItems.reset(); + pPool.clear(); + } + + + void FmTextControlShell::executeSelectAll( ) + { + try + { + if ( m_xActiveTextComponent.is() ) + { + sal_Int32 nTextLen = m_xActiveTextComponent->getText().getLength(); + m_xActiveTextComponent->setSelection( css::awt::Selection( 0, nTextLen ) ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void FmTextControlShell::executeClipboardSlot( SfxSlotId _nSlot ) + { + try + { + if ( m_xActiveTextComponent.is() ) + { + switch ( _nSlot ) + { + case SID_COPY: + case SID_CUT: + { + OUString sSelectedText( m_xActiveTextComponent->getSelectedText() ); + ::svt::OStringTransfer::CopyString( sSelectedText, lcl_getWindow( m_xActiveControl ) ); + if ( SID_CUT == _nSlot ) + { + css::awt::Selection aSelection( m_xActiveTextComponent->getSelection() ); + m_xActiveTextComponent->insertText( aSelection, OUString() ); + } + } + break; + case SID_PASTE: + { + OUString sClipboardContent; + OSL_VERIFY( ::svt::OStringTransfer::PasteString( sClipboardContent, lcl_getWindow( m_xActiveControl ) ) ); + css::awt::Selection aSelection( m_xActiveTextComponent->getSelection() ); + m_xActiveTextComponent->insertText( aSelection, sClipboardContent ); + } + break; + default: + OSL_FAIL( "FmTextControlShell::executeClipboardSlot: invalid slot!" ); + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void FmTextControlShell::ExecuteTextAttribute( SfxRequest& _rReq ) + { + SfxSlotId nSlot = _rReq.GetSlot(); + + ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlot ); + if ( aFeaturePos == m_aControlFeatures.end() ) + { + // special slots + switch ( nSlot ) + { + case SID_CHAR_DLG: + executeAttributeDialog( eCharAttribs, _rReq ); + break; + + case SID_PARA_DLG: + executeAttributeDialog( eParaAttribs, _rReq ); + break; + + case SID_SELECTALL: + executeSelectAll(); + break; + + case SID_CUT: + case SID_COPY: + case SID_PASTE: + executeClipboardSlot( nSlot ); + break; + + default: + DBG_ASSERT( aFeaturePos != m_aControlFeatures.end(), "FmTextControShell::ExecuteTextAttribute: I have no such dispatcher, and cannot handle it at all!" ); + return; + } + } + else + { + // slots which are dispatched to the control + + switch ( nSlot ) + { + case SID_ATTR_CHAR_STRIKEOUT: + case SID_ATTR_CHAR_UNDERLINE: + case SID_ATTR_CHAR_OVERLINE: + { + SfxItemSet aToggled( *_rReq.GetArgs() ); + + lcl_translateUnoStateToItem( nSlot, aFeaturePos->second->getFeatureState(), aToggled ); + WhichId nWhich = aToggled.GetPool()->GetWhich( nSlot ); + const SfxPoolItem* pItem = aToggled.GetItem( nWhich ); + if ( ( SID_ATTR_CHAR_UNDERLINE == nSlot ) || ( SID_ATTR_CHAR_OVERLINE == nSlot ) ) + { + const SvxTextLineItem* pTextLine = dynamic_cast<const SvxTextLineItem*>( pItem ); + DBG_ASSERT( pTextLine, "FmTextControlShell::ExecuteTextAttribute: ooops - no underline/overline item!" ); + if ( pTextLine ) + { + FontLineStyle eTL = pTextLine->GetLineStyle(); + if ( SID_ATTR_CHAR_UNDERLINE == nSlot ) { + aToggled.Put( SvxUnderlineItem( eTL == LINESTYLE_SINGLE ? LINESTYLE_NONE : LINESTYLE_SINGLE, nWhich ) ); + } else { + aToggled.Put( SvxOverlineItem( eTL == LINESTYLE_SINGLE ? LINESTYLE_NONE : LINESTYLE_SINGLE, nWhich ) ); + } + } + } + else + { + const SvxCrossedOutItem* pCrossedOut = dynamic_cast<const SvxCrossedOutItem*>( pItem ); + DBG_ASSERT( pCrossedOut, "FmTextControlShell::ExecuteTextAttribute: ooops - no CrossedOut item!" ); + if ( pCrossedOut ) + { + FontStrikeout eFS = pCrossedOut->GetStrikeout(); + aToggled.Put( SvxCrossedOutItem( eFS == STRIKEOUT_SINGLE ? STRIKEOUT_NONE : STRIKEOUT_SINGLE, nWhich ) ); + } + } + + Sequence< PropertyValue > aArguments; + TransformItems( nSlot, aToggled, aArguments ); + aFeaturePos->second->dispatch( aArguments ); + } + break; + + case SID_ATTR_CHAR_FONTHEIGHT: + case SID_ATTR_CHAR_FONT: + case SID_ATTR_CHAR_POSTURE: + case SID_ATTR_CHAR_WEIGHT: + case SID_ATTR_CHAR_SHADOWED: + case SID_ATTR_CHAR_CONTOUR: + case SID_SET_SUPER_SCRIPT: + case SID_SET_SUB_SCRIPT: + { + const SfxItemSet* pArgs = _rReq.GetArgs(); + Sequence< PropertyValue > aArgs; + if ( pArgs ) + TransformItems( nSlot, *pArgs, aArgs ); + aFeaturePos->second->dispatch( aArgs ); + } + break; + + default: + if ( aFeaturePos->second->isFeatureEnabled() ) + aFeaturePos->second->dispatch(); + break; + } + } + _rReq.Done(); + } + + + void FmTextControlShell::GetTextAttributeState( SfxItemSet& _rSet ) + { + SfxWhichIter aIter( _rSet ); + sal_uInt16 nSlot = aIter.FirstWhich(); + while ( nSlot ) + { + if ( ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT ) + || ( nSlot == SID_ATTR_PARA_RIGHT_TO_LEFT ) + ) + { + if ( !SvtCTLOptions().IsCTLFontEnabled() ) + { + _rSet.DisableItem( nSlot ); + nSlot = aIter.NextWhich(); + continue; + } + } + + ControlFeatures::const_iterator aFeaturePos = m_aControlFeatures.find( nSlot ); + if ( aFeaturePos != m_aControlFeatures.end() ) + { + if ( aFeaturePos->second->isFeatureEnabled() ) + lcl_translateUnoStateToItem( nSlot, aFeaturePos->second->getFeatureState(), _rSet ); + else + _rSet.DisableItem( nSlot ); + } + else + { + bool bDisable = false; + + bool bNeedWriteableControl = false; + bool bNeedTextComponent = false; + bool bNeedSelection = false; + + switch ( nSlot ) + { + case SID_CHAR_DLG: + case SID_PARA_DLG: + bDisable |= m_aControlFeatures.empty(); + bNeedWriteableControl = true; + break; + + case SID_CUT: + bNeedSelection = true; + bNeedTextComponent = true; + bNeedWriteableControl = true; + SAL_INFO("svx.form", "need to invalidate again" ); + m_bNeedClipboardInvalidation = true; + break; + + case SID_PASTE: + { + vcl::Window* pActiveControlVCLWindow = lcl_getWindow( m_xActiveControl ); + if ( pActiveControlVCLWindow ) + { + TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pActiveControlVCLWindow) ); + bDisable |= !aDataHelper.HasFormat( SotClipboardFormatId::STRING ); + } + else + bDisable = true; + + bNeedTextComponent = true; + bNeedWriteableControl = true; + } + break; + + case SID_COPY: + bNeedTextComponent = true; + bNeedSelection = true; + break; + + case SID_SELECTALL: + bNeedTextComponent = true; + break; + + default: + // slot is unknown at all + bDisable = true; + break; + } + SAL_WARN_IF( bNeedSelection && !bNeedTextComponent, "svx.form", "FmTextControlShell::GetTextAttributeState: bNeedSelection should imply bNeedTextComponent!" ); + + if ( !bDisable && bNeedWriteableControl ) + bDisable |= !IsActiveControl( ) || m_bActiveControlIsReadOnly; + + if ( !bDisable && bNeedTextComponent ) + bDisable |= !m_xActiveTextComponent.is(); + + if ( !bDisable && bNeedSelection ) + { + css::awt::Selection aSelection = m_xActiveTextComponent->getSelection(); + bDisable |= aSelection.Min == aSelection.Max; + } + + if ( bDisable ) + _rSet.DisableItem( nSlot ); + } + + nSlot = aIter.NextWhich(); + } + } + + + bool FmTextControlShell::IsActiveControl( bool _bCountRichTextOnly ) const + { + if ( _bCountRichTextOnly && !m_bActiveControlIsRichText ) + return false; + + return m_bActiveControl; + } + + + void FmTextControlShell::dispose() + { + if ( IsActiveControl() ) + controlDeactivated(); + if ( isControllerListening() ) + stopControllerListening(); + } + + + void FmTextControlShell::designModeChanged() + { + m_rBindings.Invalidate( pTextControlSlots ); + } + + + void FmTextControlShell::formActivated( const Reference< runtime::XFormController >& _rxController ) + { +#if OSL_DEBUG_LEVEL > 0 + SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(_rxController.get()), 16 )); +#endif + + DBG_ASSERT( _rxController.is(), "FmTextControlShell::formActivated: invalid controller!" ); + if ( !_rxController.is() ) + return; + + // sometimes, a form controller notifies activations, even if it's already activated + if ( m_xActiveController == _rxController ) + return; + + try + { + startControllerListening( _rxController ); + controlActivated( _rxController->getCurrentControl() ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void FmTextControlShell::formDeactivated( const Reference< runtime::XFormController >& _rxController ) + { + SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(_rxController.get()), 16 )); + + if ( IsActiveControl() ) + controlDeactivated(); + if ( isControllerListening() ) + stopControllerListening(); + } + + + void FmTextControlShell::startControllerListening( const Reference< runtime::XFormController >& _rxController ) + { + OSL_PRECOND( _rxController.is(), "FmTextControlShell::startControllerListening: invalid controller!" ); + if ( !_rxController.is() ) + return; + + OSL_PRECOND( !isControllerListening(), "FmTextControlShell::startControllerListening: already listening!" ); + if ( isControllerListening() ) + stopControllerListening( ); + DBG_ASSERT( !isControllerListening(), "FmTextControlShell::startControllerListening: inconsistence!" ); + + try + { + const Sequence< Reference< css::awt::XControl > > aControls( _rxController->getControls() ); + m_aControlObservers.resize( 0 ); + m_aControlObservers.reserve( aControls.getLength() ); + + std::transform(aControls.begin(), aControls.end(), std::back_inserter(m_aControlObservers), + [this](const Reference< css::awt::XControl >& rControl) -> FocusListenerAdapter { + return FocusListenerAdapter( new FmFocusListenerAdapter( rControl, this ) ); }); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + m_xActiveController = _rxController; + } + + + void FmTextControlShell::stopControllerListening( ) + { + OSL_PRECOND( isControllerListening(), "FmTextControlShell::stopControllerListening: inconsistence!" ); + + // dispose all listeners associated with the controls of the active controller + for (auto& rpObserver : m_aControlObservers) + { + rpObserver->dispose(); + } + + FocusListenerAdapters().swap(m_aControlObservers); + + m_xActiveController.clear(); + } + + + void FmTextControlShell::implClearActiveControlRef() + { + // no more features for this control + for (auto& rFeature : m_aControlFeatures) + { + rFeature.second->dispose(); + } + + ControlFeatures().swap(m_aControlFeatures); + + if ( m_aContextMenuObserver ) + { + m_aContextMenuObserver->dispose(); + m_aContextMenuObserver = MouseListenerAdapter(); + } + + if ( m_xActiveTextComponent.is() ) + { + SAL_INFO("svx.form", "stopping timer for clipboard invalidation" ); + m_aClipboardInvalidation.Stop(); + } + // no more active control + m_xActiveControl.clear(); + m_xActiveTextComponent.clear(); + m_bActiveControlIsReadOnly = true; + m_bActiveControlIsRichText = false; + m_bActiveControl = false; + } + + + void FmTextControlShell::controlDeactivated( ) + { + DBG_ASSERT( IsActiveControl(), "FmTextControlShell::controlDeactivated: no active control!" ); + + m_bActiveControl = false; + + m_rBindings.Invalidate( pTextControlSlots ); + } + + + void FmTextControlShell::controlActivated( const Reference< css::awt::XControl >& _rxControl ) + { + // ensure that all knittings with the previously active control are lost + if ( m_xActiveControl.is() ) + implClearActiveControlRef(); + DBG_ASSERT( m_aControlFeatures.empty(), "FmTextControlShell::controlActivated: should have no dispatchers when I'm here!" ); + +#if OSL_DEBUG_LEVEL > 0 + { + Sequence< Reference< css::awt::XControl > > aActiveControls; + if ( m_xActiveController.is() ) + aActiveControls = m_xActiveController->getControls(); + + bool bFoundThisControl = false; + + const Reference< css::awt::XControl >* pControls = aActiveControls.getConstArray(); + const Reference< css::awt::XControl >* pControlsEnd = pControls + aActiveControls.getLength(); + for ( ; ( pControls != pControlsEnd ) && !bFoundThisControl; ++pControls ) + { + if ( *pControls == _rxControl ) + bFoundThisControl = true; + } + DBG_ASSERT( bFoundThisControl, "FmTextControlShell::controlActivated: only controls which belong to the active controller can be activated!" ); + } +#endif + // ask the control for dispatchers for our text-related slots + fillFeatureDispatchers( _rxControl, pTextControlSlots, m_aControlFeatures ); + + // remember this control + m_xActiveControl = _rxControl; + m_xActiveTextComponent.set(_rxControl, css::uno::UNO_QUERY); + m_bActiveControlIsReadOnly = lcl_determineReadOnly( m_xActiveControl ); + m_bActiveControlIsRichText = lcl_isRichText( m_xActiveControl ); + + // if we found a rich text control, we need context menu support + if ( m_bActiveControlIsRichText ) + { + DBG_ASSERT( !m_aContextMenuObserver, "FmTextControlShell::controlActivated: already have an observer!" ); + m_aContextMenuObserver = MouseListenerAdapter( new FmMouseListenerAdapter( _rxControl, this ) ); + } + + if ( m_xActiveTextComponent.is() ) + { + SAL_INFO("svx.form", "starting timer for clipboard invalidation" ); + m_aClipboardInvalidation.Start(); + } + + m_bActiveControl = true; + + m_rBindings.Invalidate( pTextControlSlots ); + + if ( m_pViewFrame ) + m_pViewFrame->UIFeatureChanged(); + + // don't call the activation handler if we don't have any slots we can serve + // The activation handler is used to put the shell on the top of the dispatcher stack, + // so it's preferred when slots are distributed. + // Note that this is a slight hack, to prevent that we grab slots from the SfxDispatcher + // which should be served by other shells (e.g. Cut/Copy/Paste). + // A real solution would be a forwarding-mechanism for slots: We should be on the top + // if we're active, but if we cannot handle the slot, then we need to tell the dispatcher + // to skip our shell, and pass the slot to the next one. However, this mechanism is not + // not in place in SFX. + // Another possibility would be to have dedicated shells for the slots which we might + // or might not be able to serve. However, this could probably increase the number of + // shells too much (In theory, nearly every slot could have an own shell then). + + // #i51621# / 2005-08-19 / frank.schoenheit@sun.com + // bool bHaveAnyServeableSlots = m_xActiveTextComponent.is() || !m_aControlFeatures.empty(); + // LEM: not calling m_aControlActivatonHandler causes fdo#63695, so disable this hack for now. + m_aControlActivationHandler.Call( nullptr ); + + m_bNeedClipboardInvalidation = true; + } + + + void FmTextControlShell::fillFeatureDispatchers(const Reference< css::awt::XControl >& _rxControl, SfxSlotId* _pZeroTerminatedSlots, + ControlFeatures& _rDispatchers) + { + Reference< XDispatchProvider > xProvider( _rxControl, UNO_QUERY ); + SfxApplication* pApplication = SfxGetpApp(); + DBG_ASSERT( pApplication, "FmTextControlShell::fillFeatureDispatchers: no SfxApplication!" ); + if ( xProvider.is() && pApplication ) + { + SfxSlotId* pSlots = _pZeroTerminatedSlots; + while ( *pSlots ) + { + rtl::Reference<FmTextControlFeature> pDispatcher = implGetFeatureDispatcher( xProvider, pApplication, *pSlots ); + if ( pDispatcher ) + _rDispatchers.emplace( *pSlots, pDispatcher ); + + ++pSlots; + } + } + } + + + rtl::Reference<FmTextControlFeature> FmTextControlShell::implGetFeatureDispatcher( const Reference< XDispatchProvider >& _rxProvider, SfxApplication const * _pApplication, SfxSlotId _nSlot ) + { + OSL_PRECOND( _rxProvider.is() && _pApplication, "FmTextControlShell::implGetFeatureDispatcher: invalid arg(s)!" ); + URL aFeatureURL; + aFeatureURL.Complete = lcl_getUnoSlotName( _nSlot ); + try + { + if ( !m_xURLTransformer.is() ) + { + m_xURLTransformer = util::URLTransformer::create( ::comphelper::getProcessComponentContext() ); + } + if ( m_xURLTransformer.is() ) + m_xURLTransformer->parseStrict( aFeatureURL ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + Reference< XDispatch > xDispatcher = _rxProvider->queryDispatch( aFeatureURL, OUString(), 0xFF ); + if ( xDispatcher.is() ) + return new FmTextControlFeature( xDispatcher, aFeatureURL, _nSlot, this ); + return nullptr; + } + + + void FmTextControlShell::Invalidate( SfxSlotId _nSlot ) + { + m_rBindings.Invalidate( _nSlot ); + // despite this method being called "Invalidate", we also update here - this gives more immediate + // feedback in the UI + m_rBindings.Update( _nSlot ); + } + + + void FmTextControlShell::focusGained( const css::awt::FocusEvent& _rEvent ) + { + Reference< css::awt::XControl > xControl( _rEvent.Source, UNO_QUERY ); + +#if OSL_DEBUG_LEVEL > 0 + SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(xControl.get()), 16 )); +#endif + + DBG_ASSERT( xControl.is(), "FmTextControlShell::focusGained: suspicious focus event!" ); + if ( xControl.is() ) + controlActivated( xControl ); + } + + + void FmTextControlShell::focusLost( const css::awt::FocusEvent& _rEvent ) + { + Reference< css::awt::XControl > xControl( _rEvent.Source, UNO_QUERY ); + +#if OSL_DEBUG_LEVEL > 0 + SAL_INFO("svx.form", "0x" << OUString::number( reinterpret_cast<sal_IntPtr>(xControl.get()), 16 )); +#endif + + m_bActiveControl = false; + } + + + void FmTextControlShell::ForgetActiveControl() + { + implClearActiveControlRef(); + } + + + void FmTextControlShell::contextMenuRequested() + { + m_rBindings.GetDispatcher()->ExecutePopup( "formrichtext" ); + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmtools.cxx b/svx/source/form/fmtools.cxx new file mode 100644 index 000000000..1089754d5 --- /dev/null +++ b/svx/source/form/fmtools.cxx @@ -0,0 +1,371 @@ +/* -*- 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 <fmprop.hxx> +#include <fmservs.hxx> +#include <svx/fmtools.hxx> +#include <svx/svdobjkind.hxx> + +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/io/XPersistObject.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/sdb/ErrorCondition.hpp> +#include <com/sun/star/sdb/ErrorMessageDialog.hpp> +#include <com/sun/star/sdb/SQLContext.hpp> +#include <com/sun/star/sdb/SQLErrorEvent.hpp> +#include <com/sun/star/sdb/XCompletedConnection.hpp> +#include <com/sun/star/sdb/XResultSetAccess.hpp> +#include <com/sun/star/sdbc/XRowSet.hpp> +#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> +#include <com/sun/star/util/Language.hpp> + +#include <comphelper/processfactory.hxx> +#include <comphelper/property.hxx> +#include <comphelper/types.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::ui::dialogs; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::sdb; +using namespace ::com::sun::star::task; +using namespace ::com::sun::star::form; +using namespace ::svxform; + + +namespace +{ + bool lcl_shouldDisplayError( const Any& _rError ) + { + SQLException aError; + if ( !( _rError >>= aError ) ) + return true; + + if ( ! aError.Message.startsWith( "[OOoBase]" ) ) + // it is an exception *not* thrown by an OOo Base core component + return true; + + // the only exception we do not display ATM is a RowSetVetoException, which + // has been raised because an XRowSetApprovalListener vetoed a change + if ( aError.ErrorCode + ErrorCondition::ROW_SET_OPERATION_VETOED == 0 ) + return false; + + // everything else is to be displayed + return true; + } +} + +void displayException(const Any& _rExcept, const css::uno::Reference<css::awt::XWindow>& rParent) +{ + // check whether we need to display it + if ( !lcl_shouldDisplayError( _rExcept ) ) + return; + + try + { + Reference< XExecutableDialog > xErrorDialog = ErrorMessageDialog::create(::comphelper::getProcessComponentContext(), "", rParent, _rExcept); + xErrorDialog->execute(); + } + catch(const Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", "could not display the error message!"); + } +} + +void displayException(const css::sdbc::SQLException& _rExcept, const css::uno::Reference<css::awt::XWindow>& rParent) +{ + displayException(Any(_rExcept), rParent); +} + +void displayException(const css::sdb::SQLContext& _rExcept, const css::uno::Reference<css::awt::XWindow>& rParent) +{ + displayException(Any(_rExcept), rParent); +} + +void displayException(const css::sdb::SQLErrorEvent& _rEvent, const css::uno::Reference<css::awt::XWindow>& rParent) +{ + displayException(_rEvent.Reason, rParent); +} + +sal_Int32 getElementPos(const Reference< css::container::XIndexAccess>& xCont, const Reference< XInterface >& xElement) +{ + sal_Int32 nIndex = -1; + if (!xCont.is()) + return nIndex; + + + Reference< XInterface > xNormalized( xElement, UNO_QUERY ); + DBG_ASSERT( xNormalized.is(), "getElementPos: invalid element!" ); + if ( xNormalized.is() ) + { + // find child position + nIndex = xCont->getCount(); + while (nIndex--) + { + try + { + Reference< XInterface > xCurrent(xCont->getByIndex( nIndex ),UNO_QUERY); + DBG_ASSERT( xCurrent.get() == Reference< XInterface >( xCurrent, UNO_QUERY ).get(), + "getElementPos: container element not normalized!" ); + if ( xNormalized.get() == xCurrent.get() ) + break; + } + catch(Exception&) + { + TOOLS_WARN_EXCEPTION( "svx", "getElementPos" ); + } + + } + } + return nIndex; +} + + +OUString getLabelName(const Reference< css::beans::XPropertySet>& xControlModel) +{ + if (!xControlModel.is()) + return OUString(); + + if (::comphelper::hasProperty(FM_PROP_CONTROLLABEL, xControlModel)) + { + Reference< css::beans::XPropertySet> xLabelSet; + xControlModel->getPropertyValue(FM_PROP_CONTROLLABEL) >>= xLabelSet; + if (xLabelSet.is() && ::comphelper::hasProperty(FM_PROP_LABEL, xLabelSet)) + { + Any aLabel( xLabelSet->getPropertyValue(FM_PROP_LABEL) ); + if ((aLabel.getValueTypeClass() == TypeClass_STRING) && !::comphelper::getString(aLabel).isEmpty()) + return ::comphelper::getString(aLabel); + } + } + + return ::comphelper::getString(xControlModel->getPropertyValue(FM_PROP_CONTROLSOURCE)); +} + + +// = CursorWrapper + +CursorWrapper::CursorWrapper(const Reference< css::sdbc::XRowSet>& _rxCursor, bool bUseCloned) +{ + ImplConstruct(Reference< css::sdbc::XResultSet>(_rxCursor), bUseCloned); +} + + +CursorWrapper::CursorWrapper(const Reference< css::sdbc::XResultSet>& _rxCursor, bool bUseCloned) +{ + ImplConstruct(_rxCursor, bUseCloned); +} + + +void CursorWrapper::ImplConstruct(const Reference< css::sdbc::XResultSet>& _rxCursor, bool bUseCloned) +{ + if (bUseCloned) + { + Reference< css::sdb::XResultSetAccess> xAccess(_rxCursor, UNO_QUERY); + try + { + m_xMoveOperations = xAccess.is() ? xAccess->createResultSet() : Reference< css::sdbc::XResultSet>(); + } + catch(Exception&) + { + } + } + else + m_xMoveOperations = _rxCursor; + + m_xBookmarkOperations.set(m_xMoveOperations, css::uno::UNO_QUERY); + m_xColumnsSupplier.set(m_xMoveOperations, css::uno::UNO_QUERY); + m_xPropertyAccess.set(m_xMoveOperations, css::uno::UNO_QUERY); + + if ( !m_xMoveOperations.is() || !m_xBookmarkOperations.is() || !m_xColumnsSupplier.is() || !m_xPropertyAccess.is() ) + { // all or nothing !! + m_xMoveOperations = nullptr; + m_xBookmarkOperations = nullptr; + m_xColumnsSupplier = nullptr; + } + else + m_xGeneric = m_xMoveOperations.get(); +} + +CursorWrapper& CursorWrapper::operator=(const Reference< css::sdbc::XRowSet>& _rxCursor) +{ + m_xMoveOperations.set(_rxCursor); + m_xBookmarkOperations.set(_rxCursor, UNO_QUERY); + m_xColumnsSupplier.set(_rxCursor, UNO_QUERY); + if (!m_xMoveOperations.is() || !m_xBookmarkOperations.is() || !m_xColumnsSupplier.is()) + { // all or nothing !! + m_xMoveOperations = nullptr; + m_xBookmarkOperations = nullptr; + m_xColumnsSupplier = nullptr; + } + return *this; +} + +FmXDisposeListener::~FmXDisposeListener() +{ + setAdapter(nullptr); +} + +void FmXDisposeListener::setAdapter(FmXDisposeMultiplexer* pAdapter) +{ + std::scoped_lock aGuard(m_aMutex); + m_pAdapter = pAdapter; +} + +FmXDisposeMultiplexer::FmXDisposeMultiplexer(FmXDisposeListener* _pListener, const Reference< css::lang::XComponent>& _rxObject) + :m_xObject(_rxObject) + ,m_pListener(_pListener) +{ + m_pListener->setAdapter(this); + + if (m_xObject.is()) + m_xObject->addEventListener(this); +} + +FmXDisposeMultiplexer::~FmXDisposeMultiplexer() +{ +} + +// css::lang::XEventListener + +void FmXDisposeMultiplexer::disposing(const css::lang::EventObject& /*Source*/) +{ + Reference< css::lang::XEventListener> xPreventDelete(this); + + if (m_pListener) + { + m_pListener->disposing(0); + m_pListener->setAdapter(nullptr); + m_pListener = nullptr; + } + m_xObject = nullptr; +} + + +void FmXDisposeMultiplexer::dispose() +{ + if (m_xObject.is()) + { + Reference< css::lang::XEventListener> xPreventDelete(this); + + m_xObject->removeEventListener(this); + m_xObject = nullptr; + + m_pListener->setAdapter(nullptr); + m_pListener = nullptr; + } +} + + +SdrObjKind getControlTypeByObject(const Reference< css::lang::XServiceInfo>& _rxObject) +{ + // ask for the persistent service name + Reference< css::io::XPersistObject> xPersistence(_rxObject, UNO_QUERY); + DBG_ASSERT(xPersistence.is(), "::getControlTypeByObject : argument should be a css::io::XPersistObject !"); + if (!xPersistence.is()) + return SdrObjKind::FormControl; + + OUString sPersistentServiceName = xPersistence->getServiceName(); + if (sPersistentServiceName == FM_COMPONENT_EDIT) // 5.0-Name + { + // may be a simple edit field or a formatted field, dependent of the supported services + if (_rxObject->supportsService(FM_SUN_COMPONENT_FORMATTEDFIELD)) + return SdrObjKind::FormFormattedField; + return SdrObjKind::FormEdit; + } + if (sPersistentServiceName == FM_COMPONENT_TEXTFIELD) + return SdrObjKind::FormEdit; + if (sPersistentServiceName == FM_COMPONENT_COMMANDBUTTON) + return SdrObjKind::FormButton; + if (sPersistentServiceName == FM_COMPONENT_FIXEDTEXT) + return SdrObjKind::FormFixedText; + if (sPersistentServiceName == FM_COMPONENT_LISTBOX) + return SdrObjKind::FormListbox; + if (sPersistentServiceName == FM_COMPONENT_CHECKBOX) + return SdrObjKind::FormCheckbox; + if (sPersistentServiceName == FM_COMPONENT_RADIOBUTTON) + return SdrObjKind::FormRadioButton; + if (sPersistentServiceName == FM_COMPONENT_GROUPBOX) + return SdrObjKind::FormGroupBox; + if (sPersistentServiceName == FM_COMPONENT_COMBOBOX) + return SdrObjKind::FormCombobox; + if (sPersistentServiceName == FM_COMPONENT_GRID) // 5.0-Name + return SdrObjKind::FormGrid; + if (sPersistentServiceName == FM_COMPONENT_GRIDCONTROL) + return SdrObjKind::FormGrid; + if (sPersistentServiceName == FM_COMPONENT_IMAGEBUTTON) + return SdrObjKind::FormImageButton; + if (sPersistentServiceName == FM_COMPONENT_FILECONTROL) + return SdrObjKind::FormFileControl; + if (sPersistentServiceName == FM_COMPONENT_DATEFIELD) + return SdrObjKind::FormDateField; + if (sPersistentServiceName == FM_COMPONENT_TIMEFIELD) + return SdrObjKind::FormTimeField; + if (sPersistentServiceName == FM_COMPONENT_NUMERICFIELD) + return SdrObjKind::FormNumericField; + if (sPersistentServiceName == FM_COMPONENT_CURRENCYFIELD) + return SdrObjKind::FormCurrencyField; + if (sPersistentServiceName == FM_COMPONENT_PATTERNFIELD) + return SdrObjKind::FormPatternField; + if (sPersistentServiceName == FM_COMPONENT_HIDDEN) // 5.0-Name + return SdrObjKind::FormHidden; + if (sPersistentServiceName == FM_COMPONENT_HIDDENCONTROL) + return SdrObjKind::FormHidden; + if (sPersistentServiceName == FM_COMPONENT_IMAGECONTROL) + return SdrObjKind::FormImageControl; + if (sPersistentServiceName == FM_COMPONENT_FORMATTEDFIELD) + { + OSL_FAIL("::getControlTypeByObject : suspicious persistent service name (formatted field) !"); + // objects with that service name should exist as they aren't compatible with older versions + return SdrObjKind::FormFormattedField; + } + if ( sPersistentServiceName == FM_SUN_COMPONENT_SCROLLBAR ) + return SdrObjKind::FormScrollbar; + if ( sPersistentServiceName == FM_SUN_COMPONENT_SPINBUTTON ) + return SdrObjKind::FormSpinButton; + if ( sPersistentServiceName == FM_SUN_COMPONENT_NAVIGATIONBAR ) + return SdrObjKind::FormNavigationBar; + + OSL_FAIL("::getControlTypeByObject : unknown object type !"); + return SdrObjKind::FormControl; +} + + +bool isRowSetAlive(const Reference< XInterface >& _rxRowSet) +{ + bool bIsAlive = false; + Reference< css::sdbcx::XColumnsSupplier> xSupplyCols(_rxRowSet, UNO_QUERY); + Reference< css::container::XIndexAccess> xCols; + if (xSupplyCols.is()) + xCols.set(xSupplyCols->getColumns(), UNO_QUERY); + if (xCols.is() && (xCols->getCount() > 0)) + bIsAlive = true; + + return bIsAlive; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmundo.cxx b/svx/source/form/fmundo.cxx new file mode 100644 index 000000000..57593d36c --- /dev/null +++ b/svx/source/form/fmundo.cxx @@ -0,0 +1,1263 @@ +/* -*- 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 <map> + +#include <sal/macros.h> +#include <fmundo.hxx> +#include <fmpgeimp.hxx> +#include <svx/svditer.hxx> +#include <fmobj.hxx> +#include <fmprop.hxx> +#include <svx/strings.hrc> +#include <svx/dialmgr.hxx> +#include <svx/fmmodel.hxx> +#include <svx/fmpage.hxx> + +#include <com/sun/star/util/XModifyBroadcaster.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/container/XContainer.hpp> +#include <com/sun/star/container/XContainerListener.hpp> +#include <com/sun/star/script/XEventAttacherManager.hpp> +#include <com/sun/star/form/binding/XBindableValue.hpp> +#include <com/sun/star/form/binding/XListEntrySink.hpp> +#include <com/sun/star/sdbc/XConnection.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> + +#include <svx/fmtools.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <sfx2/objsh.hxx> +#include <sfx2/event.hxx> +#include <osl/mutex.hxx> +#include <comphelper/property.hxx> +#include <comphelper/types.hxx> +#include <connectivity/dbtools.hxx> +#include <vcl/svapp.hxx> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::script; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::form::binding; +using namespace ::com::sun::star::sdbc; +using namespace ::svxform; +using namespace ::dbtools; + + +#include <com/sun/star/script/XScriptListener.hpp> +#include <comphelper/processfactory.hxx> +#include <cppuhelper/implbase.hxx> + +namespace { + +class ScriptEventListenerWrapper : public cppu::WeakImplHelper< XScriptListener > +{ +public: + /// @throws css::uno::RuntimeException + explicit ScriptEventListenerWrapper( FmFormModel& _rModel) + :m_rModel( _rModel ) + ,m_attemptedListenerCreation( false ) + { + + } + // XEventListener + virtual void SAL_CALL disposing(const EventObject& ) override {} + + // XScriptListener + virtual void SAL_CALL firing(const ScriptEvent& evt) override + { + attemptListenerCreation(); + if ( m_vbaListener.is() ) + { + m_vbaListener->firing( evt ); + } + } + + virtual Any SAL_CALL approveFiring(const ScriptEvent& evt) override + { + attemptListenerCreation(); + if ( m_vbaListener.is() ) + { + return m_vbaListener->approveFiring( evt ); + } + return Any(); + } + +private: + void attemptListenerCreation() + { + if ( m_attemptedListenerCreation ) + return; + m_attemptedListenerCreation = true; + + try + { + css::uno::Reference<css::uno::XComponentContext> context( + comphelper::getProcessComponentContext()); + Reference< XScriptListener > const xScriptListener( + context->getServiceManager()->createInstanceWithContext( + "ooo.vba.EventListener", context), + UNO_QUERY_THROW); + Reference< XPropertySet > const xListenerProps( xScriptListener, UNO_QUERY_THROW ); + // SfxObjectShellRef is good here since the model controls the lifetime of the shell + SfxObjectShellRef const xObjectShell = m_rModel.GetObjectShell(); + ENSURE_OR_THROW( xObjectShell.is(), "no object shell!" ); + xListenerProps->setPropertyValue("Model", Any( xObjectShell->GetModel() ) ); + + m_vbaListener = xScriptListener; + } + catch( Exception const & ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + FmFormModel& m_rModel; + Reference< XScriptListener > m_vbaListener; + bool m_attemptedListenerCreation; + + +}; + + +// some helper structs for caching property infos + +struct PropertyInfo +{ + bool bIsTransientOrReadOnly : 1; // the property is transient or read-only, thus we need no undo action for it + bool bIsValueProperty : 1; // the property is the special value property, thus it may be handled + // as if it's transient or persistent +}; + +struct PropertySetInfo +{ + typedef std::map<OUString, PropertyInfo> AllProperties; + + AllProperties aProps; // all properties of this set which we know so far + bool bHasEmptyControlSource; // sal_True -> the set has a DataField property, and the current value is an empty string + // sal_False -> the set has _no_ such property or its value isn't empty +}; + +} + +typedef std::map<Reference< XPropertySet >, PropertySetInfo> PropertySetInfoCache; + + +static OUString static_STR_UNDO_PROPERTY; + + +FmXUndoEnvironment::FmXUndoEnvironment(FmFormModel& _rModel) + :rModel( _rModel ) + ,m_pPropertySetCache( nullptr ) + ,m_pScriptingEnv( new svxform::FormScriptingEnvironment( _rModel ) ) + ,m_Locks( 0 ) + ,bReadOnly( false ) + ,m_bDisposed( false ) +{ + try + { + m_vbaListener = new ScriptEventListenerWrapper( _rModel ); + } + catch( Exception& ) + { + } +} + +FmXUndoEnvironment::~FmXUndoEnvironment() +{ + if ( !m_bDisposed ) // i120746, call FormScriptingEnvironment::dispose to avoid memory leak + m_pScriptingEnv->dispose(); + + if (m_pPropertySetCache) + delete static_cast<PropertySetInfoCache*>(m_pPropertySetCache); +} + +void FmXUndoEnvironment::dispose() +{ + OSL_ENSURE( !m_bDisposed, "FmXUndoEnvironment::dispose: disposed twice?" ); + if ( !m_bDisposed ) + return; + + Lock(); + + sal_uInt16 nCount = rModel.GetPageCount(); + sal_uInt16 i; + for (i = 0; i < nCount; i++) + { + FmFormPage* pPage = dynamic_cast<FmFormPage*>( rModel.GetPage(i) ); + if ( pPage ) + { + Reference< css::form::XForms > xForms = pPage->GetForms( false ); + if ( xForms.is() ) + RemoveElement( xForms ); + } + } + + nCount = rModel.GetMasterPageCount(); + for (i = 0; i < nCount; i++) + { + FmFormPage* pPage = dynamic_cast<FmFormPage*>( rModel.GetMasterPage(i) ); + if ( pPage ) + { + Reference< css::form::XForms > xForms = pPage->GetForms( false ); + if ( xForms.is() ) + RemoveElement( xForms ); + } + } + + UnLock(); + + OSL_PRECOND( rModel.GetObjectShell(), "FmXUndoEnvironment::dispose: no object shell anymore!" ); + if ( rModel.GetObjectShell() ) + EndListening( *rModel.GetObjectShell() ); + + if ( IsListening( rModel ) ) + EndListening( rModel ); + + m_pScriptingEnv->dispose(); + + m_bDisposed = true; +} + + +void FmXUndoEnvironment::ModeChanged() +{ + OSL_PRECOND( rModel.GetObjectShell(), "FmXUndoEnvironment::ModeChanged: no object shell anymore!" ); + if ( !rModel.GetObjectShell() ) + return; + + if (bReadOnly == (rModel.GetObjectShell()->IsReadOnly() || rModel.GetObjectShell()->IsReadOnlyUI())) + return; + + bReadOnly = !bReadOnly; + + sal_uInt16 nCount = rModel.GetPageCount(); + sal_uInt16 i; + for (i = 0; i < nCount; i++) + { + FmFormPage* pPage = dynamic_cast<FmFormPage*>( rModel.GetPage(i) ); + if ( pPage ) + { + Reference< css::form::XForms > xForms = pPage->GetForms( false ); + if ( xForms.is() ) + TogglePropertyListening( xForms ); + } + } + + nCount = rModel.GetMasterPageCount(); + for (i = 0; i < nCount; i++) + { + FmFormPage* pPage = dynamic_cast<FmFormPage*>( rModel.GetMasterPage(i) ); + if ( pPage ) + { + Reference< css::form::XForms > xForms = pPage->GetForms( false ); + if ( xForms.is() ) + TogglePropertyListening( xForms ); + } + } + + if (!bReadOnly) + StartListening(rModel); + else + EndListening(rModel); +} + + +void FmXUndoEnvironment::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) +{ + if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint) + { + const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint); + switch (pSdrHint->GetKind()) + { + case SdrHintKind::ObjectInserted: + { + SdrObject* pSdrObj = const_cast<SdrObject*>(pSdrHint->GetObject()); + Inserted( pSdrObj ); + } break; + case SdrHintKind::ObjectRemoved: + { + SdrObject* pSdrObj = const_cast<SdrObject*>(pSdrHint->GetObject()); + Removed( pSdrObj ); + } + break; + default: + break; + } + } + else if (rHint.GetId() != SfxHintId::NONE) + { + switch (rHint.GetId()) + { + case SfxHintId::Dying: + dispose(); + rModel.SetObjectShell( nullptr ); + break; + case SfxHintId::ModeChanged: + ModeChanged(); + break; + default: break; + } + } + else if (const SfxEventHint* pEventHint = dynamic_cast<const SfxEventHint*>(&rHint)) + { + switch (pEventHint->GetEventId()) + { + case SfxEventHintId::CreateDoc: + case SfxEventHintId::OpenDoc: + ModeChanged(); + break; + default: break; + } + } +} + +void FmXUndoEnvironment::Inserted(SdrObject* pObj) +{ + if (pObj->GetObjInventor() == SdrInventor::FmForm) + { + FmFormObj* pFormObj = dynamic_cast<FmFormObj*>( pObj ); + Inserted( pFormObj ); + } + else if (pObj->IsGroupObject()) + { + SdrObjListIter aIter(pObj->GetSubList()); + while ( aIter.IsMore() ) + Inserted( aIter.Next() ); + } +} + + +namespace +{ + bool lcl_searchElement(const Reference< XIndexAccess>& xCont, const Reference< XInterface >& xElement) + { + if (!xCont.is() || !xElement.is()) + return false; + + sal_Int32 nCount = xCont->getCount(); + Reference< XInterface > xComp; + for (sal_Int32 i = 0; i < nCount; i++) + { + try + { + xCont->getByIndex(i) >>= xComp; + if (xComp.is()) + { + if ( xElement == xComp ) + return true; + else + { + Reference< XIndexAccess> xCont2(xComp, UNO_QUERY); + if (xCont2.is() && lcl_searchElement(xCont2, xElement)) + return true; + } + } + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + return false; + } +} + + +void FmXUndoEnvironment::Inserted(FmFormObj* pObj) +{ + DBG_ASSERT( pObj, "FmXUndoEnvironment::Inserted: invalid object!" ); + if ( !pObj ) + return; + + // is the control still assigned to a form + Reference< XInterface > xModel(pObj->GetUnoControlModel(), UNO_QUERY); + Reference< XFormComponent > xContent(xModel, UNO_QUERY); + if (!(xContent.is() && pObj->getSdrPageFromSdrObject())) + return; + + // if the component doesn't belong to a form, yet, find one to insert into + if (!xContent->getParent().is()) + { + try + { + const Reference< XIndexContainer >& xObjectParent = pObj->GetOriginalParent(); + + FmFormPage& rPage(dynamic_cast< FmFormPage& >( *pObj->getSdrPageFromSdrObject())); + Reference< XIndexAccess > xForms( rPage.GetForms(), UNO_QUERY_THROW ); + + Reference< XIndexContainer > xNewParent; + Reference< XForm > xForm; + sal_Int32 nPos = -1; + if ( lcl_searchElement( xForms, xObjectParent ) ) + { + // the form which was the parent of the object when it was removed is still + // part of the form component hierarchy of the current page + xNewParent = xObjectParent; + xForm.set( xNewParent, UNO_QUERY_THROW ); + nPos = ::std::min( pObj->GetOriginalIndex(), xNewParent->getCount() ); + } + else + { + xForm.set( rPage.GetImpl().findPlaceInFormComponentHierarchy( xContent ), UNO_SET_THROW ); + xNewParent.set( xForm, UNO_QUERY_THROW ); + nPos = xNewParent->getCount(); + } + + FmFormPageImpl::setUniqueName( xContent, xForm ); + xNewParent->insertByIndex( nPos, Any( xContent ) ); + + Reference< XEventAttacherManager > xManager( xNewParent, UNO_QUERY_THROW ); + xManager->registerScriptEvents( nPos, pObj->GetOriginalEvents() ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + // reset FormObject + pObj->ClearObjEnv(); +} + + +void FmXUndoEnvironment::Removed(SdrObject* pObj) +{ + if ( pObj->IsVirtualObj() ) + // for virtual objects, we've already been notified of the removal of the master + // object, which is sufficient here + return; + + if (pObj->GetObjInventor() == SdrInventor::FmForm) + { + FmFormObj* pFormObj = dynamic_cast<FmFormObj*>( pObj ); + Removed(pFormObj); + } + else if (pObj->IsGroupObject()) + { + SdrObjListIter aIter(pObj->GetSubList()); + while ( aIter.IsMore() ) + Removed( aIter.Next() ); + } +} + + +void FmXUndoEnvironment::Removed(FmFormObj* pObj) +{ + DBG_ASSERT( pObj, "FmXUndoEnvironment::Removed: invalid object!" ); + if ( !pObj ) + return; + + // is the control still assigned to a form + Reference< XFormComponent > xContent(pObj->GetUnoControlModel(), UNO_QUERY); + if (!xContent.is()) + return; + + // The object is taken out of a list. + // If a father exists, the object is removed at the father and + // noted at the FormObject! + + // If the object is reinserted and a parent exists, this parent is set though. + Reference< XIndexContainer > xForm(xContent->getParent(), UNO_QUERY); + if (!xForm.is()) + return; + + // determine which position the child was at + const sal_Int32 nPos = getElementPos(xForm, xContent); + if (nPos < 0) + return; + + Sequence< ScriptEventDescriptor > aEvts; + Reference< XEventAttacherManager > xManager(xForm, UNO_QUERY); + if (xManager.is()) + aEvts = xManager->getScriptEvents(nPos); + + try + { + pObj->SetObjEnv(xForm, nPos, aEvts); + xForm->removeByIndex(nPos); + } + catch(Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + +// XEventListener + +void SAL_CALL FmXUndoEnvironment::disposing(const EventObject& e) +{ + // check if it's an object we have cached information about + if (m_pPropertySetCache) + { + Reference< XPropertySet > xSourceSet(e.Source, UNO_QUERY); + if (xSourceSet.is()) + { + PropertySetInfoCache* pCache = static_cast<PropertySetInfoCache*>(m_pPropertySetCache); + PropertySetInfoCache::iterator aSetPos = pCache->find(xSourceSet); + if (aSetPos != pCache->end()) + pCache->erase(aSetPos); + } + } +} + +// XPropertyChangeListener + +void SAL_CALL FmXUndoEnvironment::propertyChange(const PropertyChangeEvent& evt) +{ + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + + if (!IsLocked()) + { + Reference< XPropertySet > xSet(evt.Source, UNO_QUERY); + if (!xSet.is()) + return; + + // if it's a "default value" property of a control model, set the according "value" property + static constexpr rtl::OUStringConstExpr pDefaultValueProperties[] = { + FM_PROP_DEFAULT_TEXT, FM_PROP_DEFAULTCHECKED, FM_PROP_DEFAULT_DATE, FM_PROP_DEFAULT_TIME, + FM_PROP_DEFAULT_VALUE, FM_PROP_DEFAULT_SELECT_SEQ, FM_PROP_EFFECTIVE_DEFAULT + }; + static constexpr rtl::OUStringConstExpr aValueProperties[] = { + FM_PROP_TEXT, FM_PROP_STATE, FM_PROP_DATE, FM_PROP_TIME, + FM_PROP_VALUE, FM_PROP_SELECT_SEQ, FM_PROP_EFFECTIVE_VALUE + }; + sal_Int32 nDefaultValueProps = SAL_N_ELEMENTS(pDefaultValueProperties); + OSL_ENSURE(SAL_N_ELEMENTS(aValueProperties) == nDefaultValueProps, + "FmXUndoEnvironment::propertyChange: inconsistence!"); + for (sal_Int32 i=0; i<nDefaultValueProps; ++i) + { + if (evt.PropertyName == pDefaultValueProperties[i]) + { + try + { + xSet->setPropertyValue(aValueProperties[i], evt.NewValue); + } + catch(const Exception&) + { + OSL_FAIL("FmXUndoEnvironment::propertyChange: could not adjust the value property!"); + } + } + } + + // no Undo for transient and readonly props. But unfortunately "transient" is not only that the + // "transient" flag is set for the property in question, instead it is somewhat more complex + // Transience criterions are: + // - the "transient" flag is set for the property + // - OR the control has a non-empty COntrolSource property, i.e. is intended to be bound + // to a database column. Note that it doesn't matter here whether the control actually + // *is* bound to a column + // - OR the control is bound to an external value via XBindableValue/XValueBinding + // which does not have a "ExternalData" property being <TRUE/> + + if (!m_pPropertySetCache) + m_pPropertySetCache = new PropertySetInfoCache; + PropertySetInfoCache* pCache = static_cast<PropertySetInfoCache*>(m_pPropertySetCache); + + // let's see if we know something about the set + PropertySetInfoCache::iterator aSetPos = pCache->find(xSet); + if (aSetPos == pCache->end()) + { + PropertySetInfo aNewEntry; + if (!::comphelper::hasProperty(FM_PROP_CONTROLSOURCE, xSet)) + { + aNewEntry.bHasEmptyControlSource = false; + } + else + { + try + { + Any aCurrentControlSource = xSet->getPropertyValue(FM_PROP_CONTROLSOURCE); + aNewEntry.bHasEmptyControlSource = !aCurrentControlSource.hasValue() || ::comphelper::getString(aCurrentControlSource).isEmpty(); + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + aSetPos = pCache->emplace(xSet,aNewEntry).first; + DBG_ASSERT(aSetPos != pCache->end(), "FmXUndoEnvironment::propertyChange : just inserted it ... why it's not there ?"); + } + else + { // is it the DataField property ? + if (evt.PropertyName == FM_PROP_CONTROLSOURCE) + { + aSetPos->second.bHasEmptyControlSource = !evt.NewValue.hasValue() || ::comphelper::getString(evt.NewValue).isEmpty(); + } + } + + // now we have access to the cached info about the set + // let's see what we know about the property + PropertySetInfo::AllProperties& rPropInfos = aSetPos->second.aProps; + PropertySetInfo::AllProperties::iterator aPropertyPos = rPropInfos.find(evt.PropertyName); + if (aPropertyPos == rPropInfos.end()) + { // nothing 'til now ... have to change this... + PropertyInfo aNewEntry; + + // the attributes + sal_Int32 nAttributes = xSet->getPropertySetInfo()->getPropertyByName(evt.PropertyName).Attributes; + aNewEntry.bIsTransientOrReadOnly = ((nAttributes & PropertyAttribute::READONLY) != 0) || ((nAttributes & PropertyAttribute::TRANSIENT) != 0); + + // check if it is the special "DataFieldProperty" + aNewEntry.bIsValueProperty = false; + try + { + if (::comphelper::hasProperty(FM_PROP_CONTROLSOURCEPROPERTY, xSet)) + { + Any aControlSourceProperty = xSet->getPropertyValue(FM_PROP_CONTROLSOURCEPROPERTY); + OUString sControlSourceProperty; + aControlSourceProperty >>= sControlSourceProperty; + + aNewEntry.bIsValueProperty = (sControlSourceProperty == evt.PropertyName); + } + } + catch(const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + // insert the new entry + aPropertyPos = rPropInfos.emplace(evt.PropertyName,aNewEntry).first; + DBG_ASSERT(aPropertyPos != rPropInfos.end(), "FmXUndoEnvironment::propertyChange : just inserted it ... why it's not there ?"); + } + + // now we have access to the cached info about the property affected + // and are able to decide whether or not we need an undo action + + bool bAddUndoAction = rModel.IsUndoEnabled(); + // no UNDO for transient/readonly properties + if ( bAddUndoAction && aPropertyPos->second.bIsTransientOrReadOnly ) + bAddUndoAction = false; + + if ( bAddUndoAction && aPropertyPos->second.bIsValueProperty ) + { + // no UNDO when the "value" property changes, but the ControlSource is non-empty + // (in this case the control is intended to be bound to a database column) + if ( !aSetPos->second.bHasEmptyControlSource ) + bAddUndoAction = false; + + // no UNDO if the control is currently bound to an external value + if ( bAddUndoAction ) + { + Reference< XBindableValue > xBindable( evt.Source, UNO_QUERY ); + Reference< XValueBinding > xBinding; + if ( xBindable.is() ) + xBinding = xBindable->getValueBinding(); + + Reference< XPropertySet > xBindingProps; + Reference< XPropertySetInfo > xBindingPropsPSI; + if ( xBindable.is() ) + xBindingProps.set( xBinding, UNO_QUERY ); + if ( xBindingProps.is() ) + xBindingPropsPSI = xBindingProps->getPropertySetInfo(); + // TODO: we should cache all those things, else this might be too expensive. + // However, this requires we're notified of changes in the value binding + + static constexpr OUStringLiteral s_sExternalData = u"ExternalData"; + if ( xBindingPropsPSI.is() && xBindingPropsPSI->hasPropertyByName( s_sExternalData ) ) + { + bool bExternalData = true; + OSL_VERIFY( xBindingProps->getPropertyValue( s_sExternalData ) >>= bExternalData ); + bAddUndoAction = !bExternalData; + } + else + bAddUndoAction = !xBinding.is(); + } + } + + if ( bAddUndoAction && ( evt.PropertyName == FM_PROP_STRINGITEMLIST ) ) + { + Reference< XListEntrySink > xSink( evt.Source, UNO_QUERY ); + if ( xSink.is() && xSink->getListEntrySource().is() ) + // #i41029# / 2005-01-31 / frank.schoenheit@sun.com + bAddUndoAction = false; + } + + if ( bAddUndoAction ) + { + aGuard.clear(); + // TODO: this is a potential race condition: two threads here could in theory + // add their undo actions out-of-order + + SolarMutexGuard aSolarGuard; + rModel.AddUndo(std::make_unique<FmUndoPropertyAction>(rModel, evt)); + } + } + else + { + // if it's the DataField property we may have to adjust our cache + if (m_pPropertySetCache && evt.PropertyName == FM_PROP_CONTROLSOURCE) + { + Reference< XPropertySet > xSet(evt.Source, UNO_QUERY); + PropertySetInfoCache* pCache = static_cast<PropertySetInfoCache*>(m_pPropertySetCache); + PropertySetInfo& rSetInfo = (*pCache)[xSet]; + rSetInfo.bHasEmptyControlSource = !evt.NewValue.hasValue() || ::comphelper::getString(evt.NewValue).isEmpty(); + } + } +} + +// XContainerListener + +void SAL_CALL FmXUndoEnvironment::elementInserted(const ContainerEvent& evt) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + // new object for listening + Reference< XInterface > xIface; + evt.Element >>= xIface; + OSL_ENSURE(xIface.is(), "FmXUndoEnvironment::elementInserted: invalid container notification!"); + AddElement(xIface); + + implSetModified(); +} + + +void FmXUndoEnvironment::implSetModified() +{ + if ( !IsLocked() && rModel.GetObjectShell() ) + { + rModel.GetObjectShell()->SetModified(); + } +} + + +void SAL_CALL FmXUndoEnvironment::elementReplaced(const ContainerEvent& evt) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + Reference< XInterface > xIface; + evt.ReplacedElement >>= xIface; + OSL_ENSURE(xIface.is(), "FmXUndoEnvironment::elementReplaced: invalid container notification!"); + RemoveElement(xIface); + + evt.Element >>= xIface; + AddElement(xIface); + + implSetModified(); +} + + +void SAL_CALL FmXUndoEnvironment::elementRemoved(const ContainerEvent& evt) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + Reference< XInterface > xIface( evt.Element, UNO_QUERY ); + OSL_ENSURE(xIface.is(), "FmXUndoEnvironment::elementRemoved: invalid container notification!"); + RemoveElement(xIface); + + implSetModified(); +} + + +void SAL_CALL FmXUndoEnvironment::modified( const EventObject& /*aEvent*/ ) +{ + implSetModified(); +} + + +void FmXUndoEnvironment::AddForms(const Reference< XNameContainer > & rForms) +{ + Lock(); + AddElement(Reference<XInterface>( rForms, UNO_QUERY )); + UnLock(); +} + + +void FmXUndoEnvironment::RemoveForms(const Reference< XNameContainer > & rForms) +{ + Lock(); + RemoveElement(Reference<XInterface>( rForms, UNO_QUERY )); + UnLock(); +} + + +void FmXUndoEnvironment::TogglePropertyListening(const Reference< XInterface > & Element) +{ + // listen at the container + Reference< XIndexContainer > xContainer(Element, UNO_QUERY); + if (xContainer.is()) + { + sal_uInt32 nCount = xContainer->getCount(); + Reference< XInterface > xIface; + for (sal_uInt32 i = 0; i < nCount; i++) + { + xContainer->getByIndex(i) >>= xIface; + TogglePropertyListening(xIface); + } + } + + Reference< XPropertySet > xSet(Element, UNO_QUERY); + if (xSet.is()) + { + if (!bReadOnly) + xSet->addPropertyChangeListener( OUString(), this ); + else + xSet->removePropertyChangeListener( OUString(), this ); + } +} + + +void FmXUndoEnvironment::switchListening( const Reference< XIndexContainer >& _rxContainer, bool _bStartListening ) +{ + OSL_PRECOND( _rxContainer.is(), "FmXUndoEnvironment::switchListening: invalid container!" ); + if ( !_rxContainer.is() ) + return; + + try + { + // if it's an EventAttacherManager, then we need to listen for + // script events + Reference< XEventAttacherManager > xManager( _rxContainer, UNO_QUERY ); + if ( xManager.is() ) + { + if ( _bStartListening ) + { + m_pScriptingEnv->registerEventAttacherManager( xManager ); + if ( m_vbaListener.is() ) + xManager->addScriptListener( m_vbaListener ); + } + else + { + m_pScriptingEnv->revokeEventAttacherManager( xManager ); + if ( m_vbaListener.is() ) + xManager->removeScriptListener( m_vbaListener ); + } + } + + // also handle all children of this element + sal_uInt32 nCount = _rxContainer->getCount(); + Reference< XInterface > xInterface; + for ( sal_uInt32 i = 0; i < nCount; ++i ) + { + _rxContainer->getByIndex( i ) >>= xInterface; + if ( _bStartListening ) + AddElement( xInterface ); + else + RemoveElement( xInterface ); + } + + // be notified of any changes in the container elements + Reference< XContainer > xSimpleContainer( _rxContainer, UNO_QUERY ); + OSL_ENSURE( xSimpleContainer.is(), "FmXUndoEnvironment::switchListening: how are we expected to be notified of changes in the container?" ); + if ( xSimpleContainer.is() ) + { + if ( _bStartListening ) + xSimpleContainer->addContainerListener( this ); + else + xSimpleContainer->removeContainerListener( this ); + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmXUndoEnvironment::switchListening" ); + } +} + + +void FmXUndoEnvironment::switchListening( const Reference< XInterface >& _rxObject, bool _bStartListening ) +{ + OSL_PRECOND( _rxObject.is(), "FmXUndoEnvironment::switchListening: how should I listen at a NULL object?" ); + + try + { + if ( !bReadOnly ) + { + Reference< XPropertySet > xProps( _rxObject, UNO_QUERY ); + if ( xProps.is() ) + { + if ( _bStartListening ) + xProps->addPropertyChangeListener( OUString(), this ); + else + xProps->removePropertyChangeListener( OUString(), this ); + } + } + + Reference< XModifyBroadcaster > xBroadcaster( _rxObject, UNO_QUERY ); + if ( xBroadcaster.is() ) + { + if ( _bStartListening ) + xBroadcaster->addModifyListener( this ); + else + xBroadcaster->removeModifyListener( this ); + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmXUndoEnvironment::switchListening" ); + } +} + + +void FmXUndoEnvironment::AddElement(const Reference< XInterface >& _rxElement ) +{ + OSL_ENSURE( !m_bDisposed, "FmXUndoEnvironment::AddElement: not when I'm already disposed!" ); + + // listen at the container + Reference< XIndexContainer > xContainer( _rxElement, UNO_QUERY ); + if ( xContainer.is() ) + switchListening( xContainer, true ); + + switchListening( _rxElement, true ); +} + + +void FmXUndoEnvironment::RemoveElement(const Reference< XInterface >& _rxElement) +{ + if ( m_bDisposed ) + return; + + switchListening( _rxElement, false ); + + if (!bReadOnly) + { + // reset the ActiveConnection if the form is to be removed. This will (should) free the resources + // associated with this connection + // 86299 - 05/02/2001 - frank.schoenheit@germany.sun.com + Reference< XForm > xForm( _rxElement, UNO_QUERY ); + Reference< XPropertySet > xFormProperties( xForm, UNO_QUERY ); + if ( xFormProperties.is() ) + { + Reference< XConnection > xDummy; + if ( !isEmbeddedInDatabase( _rxElement, xDummy ) ) + // (if there is a connection in the context of the component, setting + // a new connection would be vetoed, anyway) + // #i34196# + xFormProperties->setPropertyValue( FM_PROP_ACTIVE_CONNECTION, Any() ); + } + } + + Reference< XIndexContainer > xContainer( _rxElement, UNO_QUERY ); + if ( xContainer.is() ) + switchListening( xContainer, false ); +} + + +FmUndoPropertyAction::FmUndoPropertyAction(FmFormModel& rNewMod, const PropertyChangeEvent& evt) + :SdrUndoAction(rNewMod) + ,xObj(evt.Source, UNO_QUERY) + ,aPropertyName(evt.PropertyName) + ,aNewValue(evt.NewValue) + ,aOldValue(evt.OldValue) +{ + if (rNewMod.GetObjectShell()) + rNewMod.GetObjectShell()->SetModified(); + if(static_STR_UNDO_PROPERTY.isEmpty()) + static_STR_UNDO_PROPERTY = SvxResId(RID_STR_UNDO_PROPERTY); +} + + +void FmUndoPropertyAction::Undo() +{ + FmXUndoEnvironment& rEnv = static_cast<FmFormModel&>(rMod).GetUndoEnv(); + + if (!xObj.is() || rEnv.IsLocked()) + return; + + rEnv.Lock(); + try + { + xObj->setPropertyValue( aPropertyName, aOldValue ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmUndoPropertyAction::Undo" ); + } + rEnv.UnLock(); +} + + +void FmUndoPropertyAction::Redo() +{ + FmXUndoEnvironment& rEnv = static_cast<FmFormModel&>(rMod).GetUndoEnv(); + + if (!xObj.is() || rEnv.IsLocked()) + return; + + rEnv.Lock(); + try + { + xObj->setPropertyValue( aPropertyName, aNewValue ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmUndoPropertyAction::Redo" ); + } + rEnv.UnLock(); +} + + +OUString FmUndoPropertyAction::GetComment() const +{ + OUString aStr = static_STR_UNDO_PROPERTY.replaceFirst( "#", aPropertyName ); + return aStr; +} + + +FmUndoContainerAction::FmUndoContainerAction(FmFormModel& _rMod, + Action _eAction, + const Reference< XIndexContainer > & xCont, + const Reference< XInterface > & xElem, + sal_Int32 nIdx) + :SdrUndoAction( _rMod ) + ,m_xContainer( xCont ) + ,m_nIndex( nIdx ) + ,m_eAction( _eAction ) +{ + OSL_ENSURE( nIdx >= 0, "FmUndoContainerAction::FmUndoContainerAction: invalid index!" ); + // some old code suggested this could be a valid argument. However, this code was + // buggy, and it *seemed* that nobody used it - so it was removed. + + if ( !(xCont.is() && xElem.is()) ) + return; + + // normalize + m_xElement = xElem; + if ( m_eAction != Removed ) + return; + + if (m_nIndex >= 0) + { + Reference< XEventAttacherManager > xManager( xCont, UNO_QUERY ); + if ( xManager.is() ) + m_aEvents = xManager->getScriptEvents(m_nIndex); + } + else + m_xElement = nullptr; + + // we now own the element + m_xOwnElement = m_xElement; +} + + +FmUndoContainerAction::~FmUndoContainerAction() +{ + // if we own the object... + DisposeElement( m_xOwnElement ); +} + + +void FmUndoContainerAction::DisposeElement( const Reference< XInterface > & xElem ) +{ + Reference< XComponent > xComp( xElem, UNO_QUERY ); + if ( xComp.is() ) + { + // and the object does not have a parent + Reference< XChild > xChild( xElem, UNO_QUERY ); + if ( xChild.is() && !xChild->getParent().is() ) + // -> dispose it + xComp->dispose(); + } +} + + +void FmUndoContainerAction::implReInsert( ) +{ + if ( m_xContainer->getCount() < m_nIndex ) + return; + + // insert the element + Any aVal; + if ( m_xContainer->getElementType() == cppu::UnoType<XFormComponent>::get() ) + { + aVal <<= Reference< XFormComponent >( m_xElement, UNO_QUERY ); + } + else + { + aVal <<= Reference< XForm >( m_xElement, UNO_QUERY ); + } + m_xContainer->insertByIndex( m_nIndex, aVal ); + + OSL_ENSURE( getElementPos( m_xContainer, m_xElement ) == m_nIndex, "FmUndoContainerAction::implReInsert: insertion did not work!" ); + + // register the events + Reference< XEventAttacherManager > xManager( m_xContainer, UNO_QUERY ); + if ( xManager.is() ) + xManager->registerScriptEvents( m_nIndex, m_aEvents ); + + // we don't own the object anymore + m_xOwnElement = nullptr; +} + + +void FmUndoContainerAction::implReRemove( ) +{ + Reference< XInterface > xElement; + if ( ( m_nIndex >= 0 ) && ( m_nIndex < m_xContainer->getCount() ) ) + m_xContainer->getByIndex( m_nIndex ) >>= xElement; + + if ( xElement != m_xElement ) + { + // the indexes in the container changed. Okay, so go the long way and + // manually determine the index + m_nIndex = getElementPos( m_xContainer, m_xElement ); + if ( m_nIndex != -1 ) + xElement = m_xElement; + } + + OSL_ENSURE( xElement == m_xElement, "FmUndoContainerAction::implReRemove: cannot find the element which I'm responsible for!" ); + if ( xElement == m_xElement ) + { + Reference< XEventAttacherManager > xManager( m_xContainer, UNO_QUERY ); + if ( xManager.is() ) + m_aEvents = xManager->getScriptEvents( m_nIndex ); + m_xContainer->removeByIndex( m_nIndex ); + // from now on, we own this object + m_xOwnElement = m_xElement; + } +} + + +void FmUndoContainerAction::Undo() +{ + FmXUndoEnvironment& rEnv = static_cast< FmFormModel& >( rMod ).GetUndoEnv(); + + if ( !(m_xContainer.is() && !rEnv.IsLocked() && m_xElement.is()) ) + return; + + rEnv.Lock(); + try + { + switch ( m_eAction ) + { + case Inserted: + implReRemove(); + break; + + case Removed: + implReInsert(); + break; + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmUndoContainerAction::Undo" ); + } + rEnv.UnLock(); +} + + +void FmUndoContainerAction::Redo() +{ + FmXUndoEnvironment& rEnv = static_cast< FmFormModel& >( rMod ).GetUndoEnv(); + if ( !(m_xContainer.is() && !rEnv.IsLocked() && m_xElement.is()) ) + return; + + rEnv.Lock(); + try + { + switch ( m_eAction ) + { + case Inserted: + implReInsert(); + break; + + case Removed: + implReRemove(); + break; + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmUndoContainerAction::Redo" ); + } + rEnv.UnLock(); +} + + +FmUndoModelReplaceAction::FmUndoModelReplaceAction(FmFormModel& _rMod, SdrUnoObj* _pObject, const Reference< XControlModel > & _xReplaced) + :SdrUndoAction(_rMod) + ,m_xReplaced(_xReplaced) + ,m_pObject(_pObject) +{ +} + + +FmUndoModelReplaceAction::~FmUndoModelReplaceAction() +{ + // dispose our element if nobody else is responsible for + DisposeElement(m_xReplaced); +} + + +void FmUndoModelReplaceAction::DisposeElement( const css::uno::Reference< css::awt::XControlModel>& xReplaced ) +{ + Reference< XComponent > xComp(xReplaced, UNO_QUERY); + if (xComp.is()) + { + Reference< XChild > xChild(xReplaced, UNO_QUERY); + if (!xChild.is() || !xChild->getParent().is()) + xComp->dispose(); + } +} + + +void FmUndoModelReplaceAction::Undo() +{ + try + { + Reference< XControlModel > xCurrentModel( m_pObject->GetUnoControlModel() ); + + // replace the model within the parent + Reference< XChild > xCurrentAsChild( xCurrentModel, UNO_QUERY ); + Reference< XNameContainer > xCurrentsParent; + if ( xCurrentAsChild.is() ) + xCurrentsParent.set(xCurrentAsChild->getParent(), css::uno::UNO_QUERY); + DBG_ASSERT( xCurrentsParent.is(), "FmUndoModelReplaceAction::Undo: invalid current model!" ); + + if ( xCurrentsParent.is() ) + { + // the form container works with FormComponents + Reference< XFormComponent > xComponent( m_xReplaced, UNO_QUERY ); + DBG_ASSERT( xComponent.is(), "FmUndoModelReplaceAction::Undo: the new model is no form component !" ); + + Reference< XPropertySet > xCurrentAsSet( xCurrentModel, UNO_QUERY ); + DBG_ASSERT( ::comphelper::hasProperty(FM_PROP_NAME, xCurrentAsSet ), "FmUndoModelReplaceAction::Undo : one of the models is invalid !"); + + OUString sName; + xCurrentAsSet->getPropertyValue( FM_PROP_NAME ) >>= sName; + xCurrentsParent->replaceByName( sName, Any( xComponent ) ); + + m_pObject->SetUnoControlModel(m_xReplaced); + m_pObject->SetChanged(); + + m_xReplaced = xCurrentModel; + } + } + catch(Exception&) + { + OSL_FAIL("FmUndoModelReplaceAction::Undo : could not replace the model !"); + } +} + + +OUString FmUndoModelReplaceAction::GetComment() const +{ + return SvxResId(RID_STR_UNDO_MODEL_REPLACE); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmview.cxx b/svx/source/form/fmview.cxx new file mode 100644 index 000000000..141bdc097 --- /dev/null +++ b/svx/source/form/fmview.cxx @@ -0,0 +1,599 @@ +/* -*- 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/docfile.hxx> +#ifdef REFERENCE +#undef REFERENCE +#endif +#include <com/sun/star/sdb/SQLContext.hpp> +#include <com/sun/star/sdbc/XConnection.hpp> +#include <com/sun/star/form/XLoadable.hpp> +#include <fmvwimp.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/bindings.hxx> +#include <fmobj.hxx> +#include <svx/svditer.hxx> +#include <svx/svdpagv.hxx> +#include <svx/fmview.hxx> +#include <svx/fmmodel.hxx> +#include <svx/fmpage.hxx> +#include <svx/fmshell.hxx> +#include <fmshimp.hxx> +#include <fmservs.hxx> +#include <fmundo.hxx> +#include <svx/dataaccessdescriptor.hxx> +#include <comphelper/namedvaluecollection.hxx> +#include <o3tl/deleter.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/awt/XControl.hpp> +#include <tools/debug.hxx> +#include <svx/sdrpagewindow.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <svx/svxids.hrc> +#include <vcl/i18nhelp.hxx> +#include <vcl/window.hxx> +#include <o3tl/string_view.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdb; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::util; +using namespace ::svxform; +using namespace ::svx; + +FmFormView::FmFormView( + SdrModel& rSdrModel, + OutputDevice* pOut) +: E3dView(rSdrModel, pOut) +{ + Init(); +} + +void FmFormView::Init() +{ + pFormShell = nullptr; + pImpl = new FmXFormView(this); + + // set model + SdrModel* pModel = GetModel(); + + DBG_ASSERT( dynamic_cast<const FmFormModel*>( pModel) != nullptr, "Wrong model" ); + FmFormModel* pFormModel = dynamic_cast<FmFormModel*>(pModel); + if( !pFormModel ) + return; + + // get DesignMode from model + bool bInitDesignMode = pFormModel->GetOpenInDesignMode(); + if ( pFormModel->OpenInDesignModeIsDefaulted( ) ) + { // this means that nobody ever explicitly set this on the model, and the model has never + // been loaded from a stream. + // This means this is a newly created document. This means, we want to have it in design + // mode by default (though a newly created model returns true for GetOpenInDesignMode). + // We _want_ to have this because it makes a lot of hacks following the original fix + DBG_ASSERT( !bInitDesignMode, "FmFormView::Init: doesn't the model default to FALSE anymore?" ); + // if this asserts, either the on-construction default in the model has changed (then this here + // may not be necessary anymore), or we're not dealing with a new document... + bInitDesignMode = true; + } + + SfxObjectShell* pObjShell = pFormModel->GetObjectShell(); + if ( pObjShell && pObjShell->GetMedium() ) + { + if ( const SfxUnoAnyItem *pItem = pObjShell->GetMedium()->GetItemSet()->GetItemIfSet( SID_COMPONENTDATA, false ) ) + { + ::comphelper::NamedValueCollection aComponentData( pItem->GetValue() ); + bInitDesignMode = aComponentData.getOrDefault( "ApplyFormDesignMode", bInitDesignMode ); + } + } + + // this will be done in the shell + // bDesignMode = !bInitDesignMode; // forces execution of SetDesignMode + SetDesignMode( bInitDesignMode ); +} + +FmFormView::~FmFormView() +{ + if (pFormShell) + suppress_fun_call_w_exception(pFormShell->SetView(nullptr)); + + pImpl->notifyViewDying(); +} + +FmFormPage* FmFormView::GetCurPage() +{ + SdrPageView* pPageView = GetSdrPageView(); + FmFormPage* pCurPage = pPageView ? dynamic_cast<FmFormPage*>( pPageView->GetPage() ) : nullptr; + return pCurPage; +} + +void FmFormView::MarkListHasChanged() +{ + E3dView::MarkListHasChanged(); + + if ( !(pFormShell && IsDesignMode()) ) + return; + + FmFormObj* pObj = getMarkedGrid(); + if ( pImpl->m_pMarkedGrid && pImpl->m_pMarkedGrid != pObj ) + { + pImpl->m_pMarkedGrid = nullptr; + if ( pImpl->m_xWindow.is() ) + { + pImpl->m_xWindow->removeFocusListener(pImpl); + pImpl->m_xWindow = nullptr; + } + SetMoveOutside(false); + //OLMRefreshAllIAOManagers(); + } + + pFormShell->GetImpl()->SetSelectionDelayed_Lock(); +} + +namespace +{ + const SdrPageWindow* findPageWindow( const SdrPaintView* _pView, OutputDevice const * _pWindow ) + { + SdrPageView* pPageView = _pView->GetSdrPageView(); + if(pPageView) + { + for ( sal_uInt32 window = 0; window < pPageView->PageWindowCount(); ++window ) + { + const SdrPageWindow* pPageWindow = pPageView->GetPageWindow( window ); + if ( !pPageWindow || &pPageWindow->GetPaintWindow().GetOutputDevice() != _pWindow ) + continue; + + return pPageWindow; + } + } + return nullptr; + } +} + + +void FmFormView::AddWindowToPaintView(OutputDevice* pNewWin, vcl::Window* pWindow) +{ + E3dView::AddWindowToPaintView(pNewWin, pWindow); + + if ( !pNewWin ) + return; + + // look up the PageViewWindow for the newly inserted window, and care for it + // #i39269# / 2004-12-20 / frank.schoenheit@sun.com + const SdrPageWindow* pPageWindow = findPageWindow( this, pNewWin ); + if ( pPageWindow ) + pImpl->addWindow( *pPageWindow ); +} + + +void FmFormView::DeleteWindowFromPaintView(OutputDevice* pNewWin) +{ + const SdrPageWindow* pPageWindow = findPageWindow( this, pNewWin ); + if ( pPageWindow ) + pImpl->removeWindow( pPageWindow->GetControlContainer() ); + + E3dView::DeleteWindowFromPaintView(pNewWin); +} + + +void FmFormView::ChangeDesignMode(bool bDesign) +{ + if (bDesign == IsDesignMode()) + return; + + FmFormModel* pModel = dynamic_cast<FmFormModel*>( GetModel() ); + if (pModel) + { // For the duration of the transition the Undo-Environment is disabled. This ensures that non-transient Properties can + // also be changed (this should be done with care and also reversed before switching the mode back. An example is the + // setting of the maximal length of the text by FmXEditModel on its control.) + pModel->GetUndoEnv().Lock(); + } + + // --- 1. deactivate all controls if we are switching to design mode + if ( bDesign ) + DeactivateControls( GetSdrPageView() ); + + // --- 2. simulate a deactivation (the shell will handle some things there ...?) + if ( pFormShell && pFormShell->GetImpl() ) + pFormShell->GetImpl()->viewDeactivated_Lock(*this); + else + pImpl->Deactivate(); + + // --- 3. activate all controls, if we're switching to alive mode + if ( !bDesign ) + ActivateControls( GetSdrPageView() ); + + // --- 4. load resp. unload the forms + FmFormPage* pCurPage = GetCurPage(); + if ( pCurPage ) + { + if ( pFormShell && pFormShell->GetImpl() ) + pFormShell->GetImpl()->loadForms_Lock(pCurPage, (bDesign ? LoadFormsFlags::Unload : LoadFormsFlags::Load)); + } + + // --- 5. base class functionality + SetDesignMode( bDesign ); + + // --- 6. simulate an activation (the shell will handle some things there ...?) + OSL_PRECOND( pFormShell && pFormShell->GetImpl(), "FmFormView::ChangeDesignMode: is this really allowed? No shell?" ); + if ( pFormShell && pFormShell->GetImpl() ) + pFormShell->GetImpl()->viewActivated_Lock(*this); + else + pImpl->Activate(); + + if ( pCurPage ) + { + if ( bDesign ) + { + if ( GetActualOutDev() && GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW ) + { + const vcl::Window* pWindow = GetActualOutDev()->GetOwnerWindow(); + const_cast< vcl::Window* >( pWindow )->GrabFocus(); + } + + // redraw UNO objects + if ( GetSdrPageView() ) + { + SdrObjListIter aIter(pCurPage); + while( aIter.IsMore() ) + { + SdrObject* pObj = aIter.Next(); + if (pObj && pObj->IsUnoObj()) + { + // For redraw just use ActionChanged() + // pObj->BroadcastObjectChange(); + pObj->ActionChanged(); + } + } + } + } + else + { + // set the auto focus to the first control (if indicated by the model to do so) + bool bForceControlFocus = pModel && pModel->GetAutoControlFocus(); + if (bForceControlFocus) + pImpl->AutoFocus(); + } + } + + // Unlock Undo-Environment + if (pModel) + pModel->GetUndoEnv().UnLock(); +} + + +void FmFormView::GrabFirstControlFocus() +{ + if ( !IsDesignMode() ) + pImpl->AutoFocus(); +} + + +SdrPageView* FmFormView::ShowSdrPage(SdrPage* pPage) +{ + SdrPageView* pPV = E3dView::ShowSdrPage(pPage); + + if (pPage) + { + if (!IsDesignMode()) + { + // creating the controllers + ActivateControls(pPV); + + // Deselect all + UnmarkAll(); + } + else if ( pFormShell && pFormShell->IsDesignMode() ) + { + FmXFormShell* pFormShellImpl = pFormShell->GetImpl(); + pFormShellImpl->UpdateForms_Lock(true); + + // so that the form navigator can react to the pagechange + pFormShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_FMEXPLORER_CONTROL, true); + + pFormShellImpl->SetSelection_Lock(GetMarkedObjectList()); + } + } + + // notify our shell that we have been activated + if ( pFormShell && pFormShell->GetImpl() ) + pFormShell->GetImpl()->viewActivated_Lock(*this); + else + pImpl->Activate(); + + return pPV; +} + + +void FmFormView::HideSdrPage() +{ + // --- 1. deactivate controls + if ( !IsDesignMode() ) + DeactivateControls(GetSdrPageView()); + + // --- 2. tell the shell the view is (going to be) deactivated + if ( pFormShell && pFormShell->GetImpl() ) + pFormShell->GetImpl()->viewDeactivated_Lock(*this); + else + pImpl->Deactivate(); + + // --- 3. base class behavior + E3dView::HideSdrPage(); +} + + +void FmFormView::ActivateControls(SdrPageView const * pPageView) +{ + if (!pPageView) + return; + + for (sal_uInt32 i = 0; i < pPageView->PageWindowCount(); ++i) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i); + pImpl->addWindow(rPageWindow); + } +} + + +void FmFormView::DeactivateControls(SdrPageView const * pPageView) +{ + if( !pPageView ) + return; + + for (sal_uInt32 i = 0; i < pPageView->PageWindowCount(); ++i) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i); + pImpl->removeWindow(rPageWindow.GetControlContainer() ); + } +} + + +SdrObjectUniquePtr FmFormView::CreateFieldControl( const ODataAccessDescriptor& _rColumnDescriptor ) +{ + return pImpl->implCreateFieldControl( _rColumnDescriptor ); +} + + +SdrObjectUniquePtr FmFormView::CreateXFormsControl( const OXFormsDescriptor &_rDesc ) +{ + return pImpl->implCreateXFormsControl(_rDesc); +} + + +SdrObjectUniquePtr FmFormView::CreateFieldControl(std::u16string_view rFieldDesc) const +{ + sal_Int32 nIdx{ 0 }; + OUString sDataSource( o3tl::getToken(rFieldDesc, 0, u'\x000B', nIdx)); + OUString sObjectName( o3tl::getToken(rFieldDesc, 0, u'\x000B', nIdx)); + sal_uInt16 nObjectType = static_cast<sal_uInt16>(o3tl::toInt32(o3tl::getToken(rFieldDesc, 0, u'\x000B', nIdx))); + OUString sFieldName( o3tl::getToken(rFieldDesc, 0, u'\x000B', nIdx)); + + if (sFieldName.isEmpty() || sObjectName.isEmpty() || sDataSource.isEmpty()) + return nullptr; + + ODataAccessDescriptor aColumnDescriptor; + aColumnDescriptor.setDataSource(sDataSource); + aColumnDescriptor[ DataAccessDescriptorProperty::Command ] <<= sObjectName; + aColumnDescriptor[ DataAccessDescriptorProperty::CommandType ] <<= nObjectType; + aColumnDescriptor[ DataAccessDescriptorProperty::ColumnName ] <<= sFieldName; + + return pImpl->implCreateFieldControl( aColumnDescriptor ); +} + + +void FmFormView::InsertControlContainer(const Reference< css::awt::XControlContainer > & xCC) +{ + if( IsDesignMode() ) + return; + + SdrPageView* pPageView = GetSdrPageView(); + if( !pPageView ) + return; + + for( sal_uInt32 i = 0; i < pPageView->PageWindowCount(); i++ ) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i); + + if( rPageWindow.GetControlContainer( false ) == xCC ) + { + pImpl->addWindow(rPageWindow); + break; + } + } +} + + +void FmFormView::RemoveControlContainer(const Reference< css::awt::XControlContainer > & xCC) +{ + if( !IsDesignMode() ) + { + pImpl->removeWindow( xCC ); + } +} + + +SdrPaintWindow* FmFormView::BeginCompleteRedraw(OutputDevice* pOut) +{ + SdrPaintWindow* pPaintWindow = E3dView::BeginCompleteRedraw( pOut ); + pImpl->suspendTabOrderUpdate(); + return pPaintWindow; +} + + +void FmFormView::EndCompleteRedraw( SdrPaintWindow& rPaintWindow, bool bPaintFormLayer ) +{ + E3dView::EndCompleteRedraw( rPaintWindow, bPaintFormLayer ); + pImpl->resumeTabOrderUpdate(); +} + + +bool FmFormView::KeyInput(const KeyEvent& rKEvt, vcl::Window* pWin) +{ + bool bDone = false; + const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode(); + if ( IsDesignMode() + && rKeyCode.GetCode() == KEY_RETURN + ) + { + // RETURN alone enters grid controls, for keyboard accessibility + if ( pWin + && !rKeyCode.IsShift() + && !rKeyCode.IsMod1() + && !rKeyCode.IsMod2() + ) + { + FmFormObj* pObj = getMarkedGrid(); + if ( pObj ) + { + Reference< awt::XWindow > xWindow( pObj->GetUnoControl( *this, *pWin->GetOutDev() ), UNO_QUERY ); + if ( xWindow.is() ) + { + pImpl->m_pMarkedGrid = pObj; + pImpl->m_xWindow = xWindow; + // add as listener to get notified when ESC will be pressed inside the grid + pImpl->m_xWindow->addFocusListener(pImpl); + SetMoveOutside(true); + //OLMRefreshAllIAOManagers(); + xWindow->setFocus(); + bDone = true; + } + } + } + // Alt-RETURN alone shows the properties of the selection + if ( pFormShell + && pFormShell->GetImpl() + && !rKeyCode.IsShift() + && !rKeyCode.IsMod1() + && rKeyCode.IsMod2() + ) + { + pFormShell->GetImpl()->handleShowPropertiesRequest_Lock(); + } + + } + + // tdf#139804 Allow selecting form controls with Alt-<Mnemonic> + if (rKeyCode.IsMod2() && rKeyCode.GetCode()) + { + if (FmFormPage* pCurPage = GetCurPage()) + { + for (size_t a = 0; a < pCurPage->GetObjCount(); ++a) + { + SdrObject* pObj = pCurPage->GetObj(a); + FmFormObj* pFormObject = FmFormObj::GetFormObject(pObj); + if (!pFormObject) + continue; + + Reference<awt::XControl> xControl = pFormObject->GetUnoControl(*this, *pWin->GetOutDev()); + if (!xControl.is()) + continue; + const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper(); + VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(xControl->getPeer()); + if (rI18nHelper.MatchMnemonic(pWindow->GetText(), rKEvt.GetCharCode())) + { + pWindow->GrabFocus(); + pWindow->KeyInput(rKEvt); + bDone = true; + break; + } + } + } + } + + if ( !bDone ) + bDone = E3dView::KeyInput(rKEvt,pWin); + return bDone; +} + +bool FmFormView::checkUnMarkAll(const Reference< XInterface >& _xSource) +{ + Reference< css::awt::XControl> xControl(pImpl->m_xWindow,UNO_QUERY); + bool bRet = !xControl.is() || !_xSource.is() || _xSource != xControl->getModel(); + if ( bRet ) + UnmarkAll(); + + return bRet; +} + + +bool FmFormView::MouseButtonDown( const MouseEvent& _rMEvt, OutputDevice* _pWin ) +{ + bool bReturn = E3dView::MouseButtonDown( _rMEvt, _pWin ); + + if ( pFormShell && pFormShell->GetImpl() ) + { + SdrViewEvent aViewEvent; + PickAnything( _rMEvt, SdrMouseEventKind::BUTTONDOWN, aViewEvent ); + pFormShell->GetImpl()->handleMouseButtonDown_Lock(aViewEvent); + } + + return bReturn; +} + + +FmFormObj* FmFormView::getMarkedGrid() const +{ + FmFormObj* pFormObject = nullptr; + const SdrMarkList& rMarkList = GetMarkedObjectList(); + if ( 1 == rMarkList.GetMarkCount() ) + { + SdrMark* pMark = rMarkList.GetMark(0); + if ( pMark ) + { + pFormObject = FmFormObj::GetFormObject( pMark->GetMarkedSdrObj() ); + if ( pFormObject ) + { + Reference< XServiceInfo > xServInfo( pFormObject->GetUnoControlModel(), UNO_QUERY ); + if ( !xServInfo.is() || !xServInfo->supportsService( FM_SUN_COMPONENT_GRIDCONTROL ) ) + pFormObject = nullptr; + } + } + } + return pFormObject; +} + +void FmFormView::createControlLabelPair( OutputDevice const * _pOutDev, sal_Int32 _nXOffsetMM, sal_Int32 _nYOffsetMM, + const Reference< XPropertySet >& _rxField, const Reference< XNumberFormats >& _rxNumberFormats, + SdrObjKind _nControlObjectID, SdrInventor _nInventor, SdrObjKind _nLabelObjectID, + SdrModel& _rModel, + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp>& _rpLabel, + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp>& _rpControl ) +{ + FmXFormView::createControlLabelPair( + *_pOutDev, _nXOffsetMM, _nYOffsetMM, + _rxField, _rxNumberFormats, + _nControlObjectID, u"", _nInventor, _nLabelObjectID, + _rModel, + _rpLabel, _rpControl + ); +} + +Reference< runtime::XFormController > FmFormView::GetFormController( const Reference< XForm >& _rxForm, const OutputDevice& _rDevice ) const +{ + return pImpl->getFormController( _rxForm, _rDevice ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/fmvwimp.cxx b/svx/source/form/fmvwimp.cxx new file mode 100644 index 000000000..c95c5d710 --- /dev/null +++ b/svx/source/form/fmvwimp.cxx @@ -0,0 +1,1918 @@ +/* -*- 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 <fmdocumentclassification.hxx> +#include <fmobj.hxx> +#include <fmpgeimp.hxx> +#include <fmprop.hxx> +#include <svx/strings.hrc> +#include <fmservs.hxx> +#include <fmshimp.hxx> +#include <svx/fmtools.hxx> +#include <fmvwimp.hxx> +#include <formcontrolfactory.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <svx/svditer.hxx> +#include <svx/dataaccessdescriptor.hxx> +#include <svx/dialmgr.hxx> +#include <svx/svdobjkind.hxx> +#include <svx/fmmodel.hxx> +#include <svx/fmpage.hxx> +#include <svx/fmshell.hxx> +#include <svx/fmview.hxx> +#include <svx/sdrpagewindow.hxx> +#include <svx/svdogrp.hxx> +#include <svx/svdpagv.hxx> +#include <svx/xmlexchg.hxx> +#include <toolkit/helper/vclunohelper.hxx> + +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> +#include <com/sun/star/sdbc/XRowSet.hpp> +#include <com/sun/star/util/XNumberFormatsSupplier.hpp> +#include <com/sun/star/util/XNumberFormats.hpp> +#include <com/sun/star/sdb/CommandType.hpp> +#include <com/sun/star/sdbc/DataType.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/form/FormButtonType.hpp> +#include <com/sun/star/form/binding/XBindableValue.hpp> +#include <com/sun/star/form/binding/XValueBinding.hpp> +#include <com/sun/star/form/runtime/FormController.hpp> +#include <com/sun/star/form/submission/XSubmissionSupplier.hpp> +#include <com/sun/star/awt/XTabControllerModel.hpp> +#include <com/sun/star/awt/XControlContainer.hpp> +#include <com/sun/star/awt/XTabController.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/awt/XControl.hpp> +#include <com/sun/star/sdbc/SQLException.hpp> +#include <com/sun/star/sdb/XQueriesSupplier.hpp> +#include <com/sun/star/container/XContainer.hpp> + +#include <comphelper/namedvaluecollection.hxx> +#include <comphelper/property.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/types.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <unotools/moduleoptions.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <sal/log.hxx> +#include <vcl/svapp.hxx> +#include <vcl/stdtext.hxx> +#include <vcl/window.hxx> +#include <connectivity/dbtools.hxx> + +#include <algorithm> + +using namespace ::comphelper; +using namespace ::svx; +using namespace ::svxform; +using namespace ::dbtools; + + using namespace ::com::sun::star; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::uno::UNO_SET_THROW; + using ::com::sun::star::uno::Type; + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::Any; + using ::com::sun::star::uno::XComponentContext; + using ::com::sun::star::form::FormButtonType_SUBMIT; + using ::com::sun::star::form::binding::XValueBinding; + using ::com::sun::star::form::binding::XBindableValue; + using ::com::sun::star::lang::XComponent; + using ::com::sun::star::container::XIndexAccess; + using ::com::sun::star::form::runtime::FormController; + using ::com::sun::star::form::runtime::XFormController; + using ::com::sun::star::script::XEventAttacherManager; + using ::com::sun::star::awt::XTabControllerModel; + using ::com::sun::star::container::XChild; + using ::com::sun::star::task::XInteractionHandler; + using ::com::sun::star::awt::XTabController; + using ::com::sun::star::awt::XControlContainer; + using ::com::sun::star::awt::XControl; + using ::com::sun::star::form::XFormComponent; + using ::com::sun::star::form::XForm; + using ::com::sun::star::lang::IndexOutOfBoundsException; + using ::com::sun::star::container::XContainer; + using ::com::sun::star::container::ContainerEvent; + using ::com::sun::star::lang::EventObject; + using ::com::sun::star::sdb::SQLErrorEvent; + using ::com::sun::star::sdbc::XRowSet; + using ::com::sun::star::beans::XPropertySet; + using ::com::sun::star::container::XElementAccess; + using ::com::sun::star::awt::XWindow; + using ::com::sun::star::awt::FocusEvent; + using ::com::sun::star::ui::dialogs::XExecutableDialog; + using ::com::sun::star::sdbc::XDataSource; + using ::com::sun::star::container::XIndexContainer; + using ::com::sun::star::sdbc::XConnection; + using ::com::sun::star::container::XNameAccess; + using ::com::sun::star::sdbc::SQLException; + using ::com::sun::star::util::XNumberFormatsSupplier; + using ::com::sun::star::util::XNumberFormats; + using ::com::sun::star::beans::XPropertySetInfo; + + namespace FormComponentType = ::com::sun::star::form::FormComponentType; + namespace CommandType = ::com::sun::star::sdb::CommandType; + namespace DataType = ::com::sun::star::sdbc::DataType; + + +class FmXFormView::ObjectRemoveListener : public SfxListener +{ + FmXFormView* m_pParent; +public: + explicit ObjectRemoveListener( FmXFormView* pParent ); + virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; +}; + +FormViewPageWindowAdapter::FormViewPageWindowAdapter( const css::uno::Reference<css::uno::XComponentContext>& _rContext, const SdrPageWindow& _rWindow, FmXFormView* _pViewImpl ) +: m_xControlContainer( _rWindow.GetControlContainer() ), + m_xContext( _rContext ), + m_pViewImpl( _pViewImpl ), + m_pWindow( _rWindow.GetPaintWindow().GetOutputDevice().GetOwnerWindow() ) +{ + + // create an XFormController for every form + FmFormPage* pFormPage = dynamic_cast< FmFormPage* >( _rWindow.GetPageView().GetPage() ); + DBG_ASSERT( pFormPage, "FormViewPageWindowAdapter::FormViewPageWindowAdapter: no FmFormPage found!" ); + if ( !pFormPage ) + return; + + try + { + Reference< XIndexAccess > xForms( pFormPage->GetForms(), UNO_QUERY_THROW ); + sal_uInt32 nLength = xForms->getCount(); + for (sal_uInt32 i = 0; i < nLength; i++) + { + Reference< XForm > xForm( xForms->getByIndex(i), UNO_QUERY ); + if ( xForm.is() ) + setController( xForm, nullptr ); + } + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + +FormViewPageWindowAdapter::~FormViewPageWindowAdapter() +{ +} + +void FormViewPageWindowAdapter::dispose() +{ + for ( ::std::vector< Reference< XFormController > >::const_iterator i = m_aControllerList.begin(); + i != m_aControllerList.end(); + ++i + ) + { + try + { + Reference< XFormController > xController( *i, UNO_SET_THROW ); + + // detaching the events + Reference< XChild > xControllerModel( xController->getModel(), UNO_QUERY ); + if ( xControllerModel.is() ) + { + Reference< XEventAttacherManager > xEventManager( xControllerModel->getParent(), UNO_QUERY_THROW ); + Reference< XInterface > xControllerNormalized( xController, UNO_QUERY_THROW ); + xEventManager->detach( i - m_aControllerList.begin(), xControllerNormalized ); + } + + // dispose the formcontroller + xController->dispose(); + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + m_aControllerList.clear(); +} + +sal_Bool SAL_CALL FormViewPageWindowAdapter::hasElements() +{ + return getCount() != 0; +} + +Type SAL_CALL FormViewPageWindowAdapter::getElementType() +{ + return cppu::UnoType<XFormController>::get(); +} + +// XIndexAccess +sal_Int32 SAL_CALL FormViewPageWindowAdapter::getCount() +{ + return m_aControllerList.size(); +} + +Any SAL_CALL FormViewPageWindowAdapter::getByIndex(sal_Int32 nIndex) +{ + if (nIndex < 0 || + nIndex >= getCount()) + throw IndexOutOfBoundsException(); + + Any aElement; + aElement <<= m_aControllerList[nIndex]; + return aElement; +} + +void SAL_CALL FormViewPageWindowAdapter::makeVisible( const Reference< XControl >& Control ) +{ + SolarMutexGuard aSolarGuard; + + Reference< XWindow > xWindow( Control, UNO_QUERY ); + if ( xWindow.is() && m_pViewImpl->getView() && m_pWindow ) + { + awt::Rectangle aRect = xWindow->getPosSize(); + ::tools::Rectangle aNewRect( aRect.X, aRect.Y, aRect.X + aRect.Width, aRect.Y + aRect.Height ); + aNewRect = m_pWindow->PixelToLogic( aNewRect ); + m_pViewImpl->getView()->MakeVisible( aNewRect, *m_pWindow ); + } +} + +static Reference< XFormController > getControllerSearchChildren( const Reference< XIndexAccess > & xIndex, const Reference< XTabControllerModel > & xModel) +{ + if (xIndex.is() && xIndex->getCount()) + { + Reference< XFormController > xController; + + for (sal_Int32 n = xIndex->getCount(); n-- && !xController.is(); ) + { + xIndex->getByIndex(n) >>= xController; + if (xModel.get() == xController->getModel().get()) + return xController; + else + { + xController = getControllerSearchChildren(xController, xModel); + if ( xController.is() ) + return xController; + } + } + } + return Reference< XFormController > (); +} + +// Search the according controller +Reference< XFormController > FormViewPageWindowAdapter::getController( const Reference< XForm > & xForm ) const +{ + Reference< XTabControllerModel > xModel(xForm, UNO_QUERY); + for (const auto& rpController : m_aControllerList) + { + if (rpController->getModel().get() == xModel.get()) + return rpController; + + // the current-round controller isn't the right one. perhaps one of its children ? + Reference< XFormController > xChildSearch = getControllerSearchChildren(Reference< XIndexAccess > (rpController, UNO_QUERY), xModel); + if (xChildSearch.is()) + return xChildSearch; + } + return Reference< XFormController > (); +} + + +void FormViewPageWindowAdapter::setController(const Reference< XForm > & xForm, const Reference< XFormController >& _rxParentController ) +{ + DBG_ASSERT( xForm.is(), "FormViewPageWindowAdapter::setController: there should be a form!" ); + Reference< XIndexAccess > xFormCps(xForm, UNO_QUERY); + if (!xFormCps.is()) + return; + + Reference< XTabControllerModel > xTabOrder(xForm, UNO_QUERY); + + // create a form controller + Reference< XFormController > xController( FormController::create(m_xContext) ); + + Reference< XInteractionHandler > xHandler; + if ( _rxParentController.is() ) + xHandler = _rxParentController->getInteractionHandler(); + else + { + // TODO: should we create a default handler? Not really necessary, since the + // FormController itself has a default fallback + } + if ( xHandler.is() ) + xController->setInteractionHandler( xHandler ); + + xController->setContext( this ); + + xController->setModel( xTabOrder ); + xController->setContainer( m_xControlContainer ); + xController->activateTabOrder(); + xController->addActivateListener( m_pViewImpl ); + + if ( _rxParentController.is() ) + _rxParentController->addChildController( xController ); + else + { + m_aControllerList.push_back(xController); + + xController->setParent( *this ); + + // attaching the events + Reference< XEventAttacherManager > xEventManager( xForm->getParent(), UNO_QUERY ); + xEventManager->attach(m_aControllerList.size() - 1, Reference<XInterface>( xController, UNO_QUERY ), Any(xController) ); + } + + // now go through the subforms + sal_uInt32 nLength = xFormCps->getCount(); + Reference< XForm > xSubForm; + for (sal_uInt32 i = 0; i < nLength; i++) + { + if ( xFormCps->getByIndex(i) >>= xSubForm ) + setController( xSubForm, xController ); + } +} + + +void FormViewPageWindowAdapter::updateTabOrder( const Reference< XForm >& _rxForm ) +{ + OSL_PRECOND( _rxForm.is(), "FormViewPageWindowAdapter::updateTabOrder: illegal argument!" ); + if ( !_rxForm.is() ) + return; + + try + { + Reference< XTabController > xTabCtrl( getController( _rxForm ) ); + if ( xTabCtrl.is() ) + { // if there already is a TabController for this form, then delegate the "updateTabOrder" request + xTabCtrl->activateTabOrder(); + } + else + { // otherwise, create a TabController + + // if it's a sub form, then we must ensure there exist TabControllers + // for all its ancestors, too + Reference< XForm > xParentForm( _rxForm->getParent(), UNO_QUERY ); + // there is a parent form -> look for the respective controller + Reference< XFormController > xParentController; + if ( xParentForm.is() ) + xParentController = getController( xParentForm ); + + setController( _rxForm, xParentController ); + } + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +FmXFormView::FmXFormView(FmFormView* _pView ) + :m_pMarkedGrid(nullptr) + ,m_pView(_pView) + ,m_nActivationEvent(nullptr) + ,m_nErrorMessageEvent( nullptr ) + ,m_nAutoFocusEvent( nullptr ) + ,m_nControlWizardEvent( nullptr ) + ,m_bFirstActivation( true ) + ,m_isTabOrderUpdateSuspended( false ) +{ +} + + +void FmXFormView::cancelEvents() +{ + if ( m_nActivationEvent ) + { + Application::RemoveUserEvent( m_nActivationEvent ); + m_nActivationEvent = nullptr; + } + + if ( m_nErrorMessageEvent ) + { + Application::RemoveUserEvent( m_nErrorMessageEvent ); + m_nErrorMessageEvent = nullptr; + } + + if ( m_nAutoFocusEvent ) + { + Application::RemoveUserEvent( m_nAutoFocusEvent ); + m_nAutoFocusEvent = nullptr; + } + + if ( m_nControlWizardEvent ) + { + Application::RemoveUserEvent( m_nControlWizardEvent ); + m_nControlWizardEvent = nullptr; + } +} + + +void FmXFormView::notifyViewDying( ) +{ + DBG_ASSERT( m_pView, "FmXFormView::notifyViewDying: my view already died!" ); + m_pView = nullptr; + cancelEvents(); +} + + +FmXFormView::~FmXFormView() +{ + DBG_ASSERT( m_aPageWindowAdapters.empty(), "FmXFormView::~FmXFormView: Window list not empty!" ); + for (const auto& rpAdapter : m_aPageWindowAdapters) + { + rpAdapter->dispose(); + } + + cancelEvents(); +} + +// EventListener + +void SAL_CALL FmXFormView::disposing(const EventObject& Source) +{ + if ( m_xWindow.is() && Source.Source == m_xWindow ) + { + m_xWindow->removeFocusListener(this); + if ( m_pView ) + { + m_pView->SetMoveOutside( false, FmFormView::ImplAccess() ); + } + m_xWindow = nullptr; + } +} + +// XFormControllerListener + +void SAL_CALL FmXFormView::formActivated(const EventObject& rEvent) +{ + if ( m_pView && m_pView->GetFormShell() && m_pView->GetFormShell()->GetImpl() ) + m_pView->GetFormShell()->GetImpl()->formActivated( rEvent ); +} + + +void SAL_CALL FmXFormView::formDeactivated(const EventObject& rEvent) +{ + if ( m_pView && m_pView->GetFormShell() && m_pView->GetFormShell()->GetImpl() ) + m_pView->GetFormShell()->GetImpl()->formDeactivated( rEvent ); +} + +// XContainerListener + +void SAL_CALL FmXFormView::elementInserted(const ContainerEvent& evt) +{ + try + { + Reference< XControlContainer > xControlContainer( evt.Source, UNO_QUERY_THROW ); + Reference< XControl > xControl( evt.Element, UNO_QUERY_THROW ); + Reference< XFormComponent > xControlModel( xControl->getModel(), UNO_QUERY_THROW ); + Reference< XForm > xForm( xControlModel->getParent(), UNO_QUERY_THROW ); + + if ( m_isTabOrderUpdateSuspended ) + { + // remember the container and the control, so we can update the tab order on resumeTabOrderUpdate + m_aNeedTabOrderUpdate[ xControlContainer ].insert( xForm ); + } + else + { + rtl::Reference< FormViewPageWindowAdapter > pAdapter = findWindow( xControlContainer ); + if ( pAdapter.is() ) + pAdapter->updateTabOrder( xForm ); + } + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void SAL_CALL FmXFormView::elementReplaced(const ContainerEvent& evt) +{ + elementInserted(evt); +} + + +void SAL_CALL FmXFormView::elementRemoved(const ContainerEvent& /*evt*/) +{ +} + + +rtl::Reference< FormViewPageWindowAdapter > FmXFormView::findWindow( const Reference< XControlContainer >& _rxCC ) const +{ + auto i = std::find_if(m_aPageWindowAdapters.begin(), m_aPageWindowAdapters.end(), + [&_rxCC](const rtl::Reference< FormViewPageWindowAdapter >& rpAdapter) { return _rxCC == rpAdapter->getControlContainer(); }); + if (i != m_aPageWindowAdapters.end()) + return *i; + return nullptr; +} + + +void FmXFormView::addWindow(const SdrPageWindow& rWindow) +{ + FmFormPage* pFormPage = dynamic_cast<FmFormPage*>( rWindow.GetPageView().GetPage() ); + if ( !pFormPage ) + return; + + const Reference< XControlContainer >& xCC = rWindow.GetControlContainer(); + if ( xCC.is() + && ( !findWindow( xCC ).is() ) + ) + { + rtl::Reference< FormViewPageWindowAdapter > pAdapter = new FormViewPageWindowAdapter( comphelper::getProcessComponentContext(), rWindow, this ); + m_aPageWindowAdapters.push_back( pAdapter ); + + // listen at the ControlContainer to notice changes + Reference< XContainer > xContainer( xCC, UNO_QUERY ); + if ( xContainer.is() ) + xContainer->addContainerListener( this ); + } +} + + +void FmXFormView::removeWindow( const Reference< XControlContainer >& _rxCC ) +{ + // Is called if + // - the design mode is being switched to + // - a window is deleted while in the design mode + // - the control container for a window is removed while the active mode is on + + auto i = std::find_if(m_aPageWindowAdapters.begin(), m_aPageWindowAdapters.end(), + [&_rxCC](const rtl::Reference< FormViewPageWindowAdapter >& rpAdapter) { return _rxCC == rpAdapter->getControlContainer(); }); + if (i != m_aPageWindowAdapters.end()) + { + Reference< XContainer > xContainer( _rxCC, UNO_QUERY ); + if ( xContainer.is() ) + xContainer->removeContainerListener( this ); + + (*i)->dispose(); + m_aPageWindowAdapters.erase( i ); + } +} + +void FmXFormView::displayAsyncErrorMessage( const SQLErrorEvent& _rEvent ) +{ + DBG_ASSERT( nullptr == m_nErrorMessageEvent, "FmXFormView::displayAsyncErrorMessage: not too fast, please!" ); + // This should not happen - usually, the PostUserEvent is faster than any possible user + // interaction which could trigger a new error. If it happens, we need a queue for the events. + m_aAsyncError = _rEvent; + m_nErrorMessageEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnDelayedErrorMessage ) ); +} + +IMPL_LINK_NOARG(FmXFormView, OnDelayedErrorMessage, void*, void) +{ + m_nErrorMessageEvent = nullptr; + displayException(m_aAsyncError, GetParentWindow()); +} + +void FmXFormView::onFirstViewActivation( const FmFormModel* _pDocModel ) +{ + if ( _pDocModel && _pDocModel->GetAutoControlFocus() ) + m_nAutoFocusEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnAutoFocus ) ); +} + +void FmXFormView::suspendTabOrderUpdate() +{ + OSL_ENSURE( !m_isTabOrderUpdateSuspended, "FmXFormView::suspendTabOrderUpdate: nesting not allowed!" ); + m_isTabOrderUpdateSuspended = true; +} + +void FmXFormView::resumeTabOrderUpdate() +{ + OSL_ENSURE( m_isTabOrderUpdateSuspended, "FmXFormView::resumeTabOrderUpdate: not suspended!" ); + m_isTabOrderUpdateSuspended = false; + + // update the tab orders for all components which were collected since the suspendTabOrderUpdate call. + for (const auto& rContainer : m_aNeedTabOrderUpdate) + { + rtl::Reference< FormViewPageWindowAdapter > pAdapter = findWindow( rContainer.first ); + if ( !pAdapter.is() ) + continue; + + for (const auto& rForm : rContainer.second) + { + pAdapter->updateTabOrder( rForm ); + } + } + m_aNeedTabOrderUpdate.clear(); +} + +namespace +{ + bool isActivableDatabaseForm(const Reference< XFormController > &xController) + { + // only database forms are to be activated + Reference< XRowSet > xForm(xController->getModel(), UNO_QUERY); + if ( !xForm.is() || !getConnection( xForm ).is() ) + return false; + + Reference< XPropertySet > xFormSet( xForm, UNO_QUERY ); + if ( !xFormSet.is() ) + { + SAL_WARN( "svx.form", "FmXFormView::OnActivate: a form which does not have properties?" ); + return false; + } + + const OUString aSource = ::comphelper::getString( xFormSet->getPropertyValue( FM_PROP_COMMAND ) ); + + return !aSource.isEmpty(); + } + + class find_active_databaseform + { + const Reference< XFormController > xActiveController; + + public: + + explicit find_active_databaseform( const Reference< XFormController >& _xActiveController ) + : xActiveController(_xActiveController ) + {} + + Reference < XFormController > operator() (const Reference< XFormController > &xController) + { + if(xController == xActiveController && isActivableDatabaseForm(xController)) + return xController; + + if ( !xController.is() ) + { + SAL_WARN( "svx.form", "FmXFormView::OnActivate: a form controller which does not have children?" ); + return nullptr; + } + + for(sal_Int32 i = 0; i < xController->getCount(); ++i) + { + const Any a(xController->getByIndex(i)); + Reference < XFormController > xI; + if ((a >>= xI) && xI.is()) + { + Reference < XFormController > xRes(operator()(xI)); + if (xRes.is()) + return xRes; + } + } + + return nullptr; + } + }; +} + + +IMPL_LINK_NOARG(FmXFormView, OnActivate, void*, void) +{ + m_nActivationEvent = nullptr; + + if ( !m_pView ) + { + OSL_FAIL( "FmXFormView::OnActivate: well... seems we have a timing problem (the view already died)!" ); + return; + } + + // setting the controller to activate + if (!(m_pView->GetFormShell() && m_pView->GetActualOutDev() && m_pView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW)) + return; + + FmXFormShell* const pShImpl = m_pView->GetFormShell()->GetImpl(); + + if(!pShImpl) + return; + + find_active_databaseform fad(pShImpl->getActiveController_Lock()); + + vcl::Window* pWindow = m_pView->GetActualOutDev()->GetOwnerWindow(); + rtl::Reference< FormViewPageWindowAdapter > pAdapter = m_aPageWindowAdapters.empty() ? nullptr : m_aPageWindowAdapters[0]; + for (const auto& rpPageWindowAdapter : m_aPageWindowAdapters) + { + if ( pWindow == rpPageWindowAdapter->getWindow() ) + pAdapter = rpPageWindowAdapter; + } + + if ( !pAdapter.is() ) + return; + + Reference< XFormController > xControllerToActivate; + for (const Reference< XFormController > & xController : pAdapter->GetList()) + { + if ( !xController.is() ) + continue; + + { + Reference< XFormController > xActiveController(fad(xController)); + if (xActiveController.is()) + { + xControllerToActivate = xActiveController; + break; + } + } + + if(xControllerToActivate.is() || !isActivableDatabaseForm(xController)) + continue; + + xControllerToActivate = xController; + } + pShImpl->setActiveController_Lock(xControllerToActivate); +} + + +void FmXFormView::Activate(bool bSync) +{ + if (m_nActivationEvent) + { + Application::RemoveUserEvent(m_nActivationEvent); + m_nActivationEvent = nullptr; + } + + if (bSync) + { + LINK(this,FmXFormView,OnActivate).Call(nullptr); + } + else + m_nActivationEvent = Application::PostUserEvent(LINK(this,FmXFormView,OnActivate)); +} + + +void FmXFormView::Deactivate(bool bDeactivateController) +{ + if (m_nActivationEvent) + { + Application::RemoveUserEvent(m_nActivationEvent); + m_nActivationEvent = nullptr; + } + + FmXFormShell* pShImpl = m_pView->GetFormShell() ? m_pView->GetFormShell()->GetImpl() : nullptr; + if (pShImpl && bDeactivateController) + pShImpl->setActiveController_Lock(nullptr); +} + + +FmFormShell* FmXFormView::GetFormShell() const +{ + return m_pView ? m_pView->GetFormShell() : nullptr; +} + +void FmXFormView::AutoFocus() +{ + if (m_nAutoFocusEvent) + Application::RemoveUserEvent(m_nAutoFocusEvent); + + m_nAutoFocusEvent = Application::PostUserEvent(LINK(this, FmXFormView, OnAutoFocus)); +} + + +bool FmXFormView::isFocusable( const Reference< XControl >& i_rControl ) +{ + if ( !i_rControl.is() ) + return false; + + try + { + Reference< XPropertySet > xModelProps( i_rControl->getModel(), UNO_QUERY_THROW ); + + // only enabled controls are allowed to participate + bool bEnabled = false; + OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_ENABLED ) >>= bEnabled ); + if ( !bEnabled ) + return false; + + // check the class id of the control model + sal_Int16 nClassId = FormComponentType::CONTROL; + OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId ); + + // controls which are not focussable + if ( ( FormComponentType::CONTROL != nClassId ) + && ( FormComponentType::IMAGEBUTTON != nClassId ) + && ( FormComponentType::GROUPBOX != nClassId ) + && ( FormComponentType::FIXEDTEXT != nClassId ) + && ( FormComponentType::HIDDENCONTROL != nClassId ) + && ( FormComponentType::IMAGECONTROL != nClassId ) + && ( FormComponentType::SCROLLBAR != nClassId ) + && ( FormComponentType::SPINBUTTON!= nClassId ) + ) + { + return true; + } + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return false; +} + + +static Reference< XControl > lcl_firstFocussableControl( const Sequence< Reference< XControl > >& _rControls ) +{ + Reference< XControl > xReturn; + + // loop through all the controls + for ( auto const & control : _rControls ) + { + if ( !control.is() ) + continue; + + if ( FmXFormView::isFocusable( control ) ) + { + xReturn = control; + break; + } + } + + if ( !xReturn.is() && _rControls.hasElements() ) + xReturn = _rControls[0]; + + return xReturn; +} + + +namespace +{ + + void lcl_ensureControlsOfFormExist_nothrow( const SdrPage& _rPage, const SdrView& _rView, const vcl::Window& _rWindow, const Reference< XForm >& _rxForm ) + { + try + { + Reference< XInterface > xNormalizedForm( _rxForm, UNO_QUERY_THROW ); + + SdrObjListIter aSdrObjectLoop( &_rPage, SdrIterMode::DeepNoGroups ); + while ( aSdrObjectLoop.IsMore() ) + { + FmFormObj* pFormObject = FmFormObj::GetFormObject( aSdrObjectLoop.Next() ); + if ( !pFormObject ) + continue; + + Reference< XChild > xModel( pFormObject->GetUnoControlModel(), UNO_QUERY_THROW ); + Reference< XInterface > xModelParent( xModel->getParent(), UNO_QUERY ); + + if ( xNormalizedForm.get() != xModelParent.get() ) + continue; + + pFormObject->GetUnoControl( _rView, *_rWindow.GetOutDev() ); + } + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } +} + + +Reference< XFormController > FmXFormView::getFormController( const Reference< XForm >& _rxForm, const OutputDevice& _rDevice ) const +{ + Reference< XFormController > xController; + + for (const rtl::Reference< FormViewPageWindowAdapter >& pAdapter : m_aPageWindowAdapters) + { + if ( !pAdapter ) + { + SAL_WARN( "svx.form", "FmXFormView::getFormController: invalid page window adapter!" ); + continue; + } + + if ( pAdapter->getWindow() != _rDevice.GetOwnerWindow() ) + // wrong device + continue; + + xController = pAdapter->getController( _rxForm ); + if ( xController.is() ) + break; + } + return xController; +} + + +IMPL_LINK_NOARG(FmXFormView, OnAutoFocus, void*, void) +{ + m_nAutoFocusEvent = nullptr; + + // go to the first form of our page, examine it's TabController, go to its first (in terms of the tab order) + // control, give it the focus + + SdrPageView *pPageView = m_pView ? m_pView->GetSdrPageView() : nullptr; + SdrPage *pSdrPage = pPageView ? pPageView->GetPage() : nullptr; + // get the forms collection of the page we belong to + FmFormPage* pPage = dynamic_cast<FmFormPage*>( pSdrPage ); + Reference< XIndexAccess > xForms( pPage ? Reference< XIndexAccess >( pPage->GetForms() ) : Reference< XIndexAccess >() ); + + const rtl::Reference< FormViewPageWindowAdapter > pAdapter = m_aPageWindowAdapters.empty() ? nullptr : m_aPageWindowAdapters[0]; + const vcl::Window* pWindow = pAdapter ? pAdapter->getWindow() : nullptr; + + ENSURE_OR_RETURN_VOID( xForms.is() && pWindow, "FmXFormView::OnAutoFocus: could not collect all essentials!" ); + + try + { + // go for the tab controller of the first form + if ( !xForms->getCount() ) + return; + Reference< XForm > xForm( xForms->getByIndex( 0 ), UNO_QUERY_THROW ); + Reference< XTabController > xTabController( pAdapter->getController( xForm ), UNO_QUERY_THROW ); + + // go for the first control of the controller + Sequence< Reference< XControl > > aControls( xTabController->getControls() ); + if ( !aControls.hasElements() ) + { + Reference< XElementAccess > xFormElementAccess( xForm, UNO_QUERY_THROW ); + if (xFormElementAccess->hasElements() && pPage && m_pView) + { + // there are control models in the form, but no controls, yet. + // Well, since some time controls are created on demand only. In particular, + // they're normally created when they're first painted. + // Unfortunately, the FormController does not have any way to + // trigger the creation itself, so we must hack this ... + lcl_ensureControlsOfFormExist_nothrow( *pPage, *m_pView, *pWindow, xForm ); + aControls = xTabController->getControls(); + OSL_ENSURE( aControls.hasElements(), "FmXFormView::OnAutoFocus: no controls at all!" ); + } + } + + // set the focus to this first control + Reference< XWindow > xControlWindow( lcl_firstFocussableControl( aControls ), UNO_QUERY ); + if ( !xControlWindow.is() ) + return; + + xControlWindow->setFocus(); + + // ensure that the control is visible + // 80210 - 12/07/00 - FS + const OutputDevice* pOut = m_pView ? m_pView->GetActualOutDev() : nullptr; + const vcl::Window* pCurrentWindow = pOut ? pOut->GetOwnerWindow() : nullptr; + if ( pCurrentWindow ) + { + awt::Rectangle aRect = xControlWindow->getPosSize(); + ::tools::Rectangle aNonUnoRect( aRect.X, aRect.Y, aRect.X + aRect.Width, aRect.Y + aRect.Height ); + m_pView->MakeVisible( pCurrentWindow->PixelToLogic( aNonUnoRect ), *const_cast< vcl::Window* >( pCurrentWindow ) ); + } + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FmXFormView::onCreatedFormObject( FmFormObj const & _rFormObject ) +{ + FmFormShell* pShell = m_pView ? m_pView->GetFormShell() : nullptr; + FmXFormShell* pShellImpl = pShell ? pShell->GetImpl() : nullptr; + OSL_ENSURE( pShellImpl, "FmXFormView::onCreatedFormObject: no form shell!" ); + if ( !pShellImpl ) + return; + + // it is valid that the form shell's forms collection is not initialized, yet + pShellImpl->UpdateForms_Lock(true); + + m_xLastCreatedControlModel.set( _rFormObject.GetUnoControlModel(), UNO_QUERY ); + if ( !m_xLastCreatedControlModel.is() ) + return; + + // some initial property defaults + FormControlFactory aControlFactory; + aControlFactory.initializeControlModel(pShellImpl->getDocumentType_Lock(), _rFormObject); + + if (!pShellImpl->GetWizardUsing_Lock()) + return; + + // #i31958# don't call wizards in XForms mode + if (pShellImpl->isEnhancedForm_Lock()) + return; + + // #i46898# no wizards if there is no Base installed - currently, all wizards are + // database related + if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) ) + return; + + if ( m_nControlWizardEvent ) + Application::RemoveUserEvent( m_nControlWizardEvent ); + m_nControlWizardEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnStartControlWizard ) ); +} + +void FmXFormView::breakCreateFormObject() +{ + if (m_nControlWizardEvent != nullptr) + { + Application::RemoveUserEvent(m_nControlWizardEvent); + m_nControlWizardEvent = nullptr; + } + m_xLastCreatedControlModel.clear(); +} + +Reference<XWindow> FmXFormView::GetParentWindow() const +{ + const OutputDevice* pOut = m_pView ? m_pView->GetActualOutDev() : nullptr; + const vcl::Window* pCurrentWindow = pOut ? pOut->GetOwnerWindow() : nullptr; + return VCLUnoHelper::GetInterface(const_cast<vcl::Window*>(pCurrentWindow)); +} + +IMPL_LINK_NOARG( FmXFormView, OnStartControlWizard, void*, void ) +{ + m_nControlWizardEvent = nullptr; + OSL_PRECOND( m_xLastCreatedControlModel.is(), "FmXFormView::OnStartControlWizard: illegal call!" ); + if ( !m_xLastCreatedControlModel.is() ) + return; + + sal_Int16 nClassId = FormComponentType::CONTROL; + try + { + OSL_VERIFY( m_xLastCreatedControlModel->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId ); + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + const char* pWizardAsciiName = nullptr; + switch ( nClassId ) + { + case FormComponentType::GRIDCONTROL: + pWizardAsciiName = "com.sun.star.sdb.GridControlAutoPilot"; + break; + case FormComponentType::LISTBOX: + case FormComponentType::COMBOBOX: + pWizardAsciiName = "com.sun.star.sdb.ListComboBoxAutoPilot"; + break; + case FormComponentType::GROUPBOX: + pWizardAsciiName = "com.sun.star.sdb.GroupBoxAutoPilot"; + break; + } + + if ( pWizardAsciiName ) + { + // build the argument list + ::comphelper::NamedValueCollection aWizardArgs; + aWizardArgs.put("ObjectModel", m_xLastCreatedControlModel); + aWizardArgs.put("ParentWindow", GetParentWindow()); + + // create the wizard object + Reference< XExecutableDialog > xWizard; + try + { + Reference<XComponentContext> xContext = comphelper::getProcessComponentContext(); + xWizard.set( xContext->getServiceManager()->createInstanceWithArgumentsAndContext( OUString::createFromAscii(pWizardAsciiName), aWizardArgs.getWrappedPropertyValues(), xContext ), UNO_QUERY); + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + if ( !xWizard.is() ) + { + ShowServiceNotAvailableError( nullptr, OUString::createFromAscii(pWizardAsciiName), true ); + } + else + { + // execute the wizard + try + { + xWizard->execute(); + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + + m_xLastCreatedControlModel.clear(); +} + + +namespace +{ + void lcl_insertIntoFormComponentHierarchy_throw( const FmFormView& _rView, const SdrUnoObj& _rSdrObj, + const Reference< XDataSource >& _rxDataSource, const OUString& _rDataSourceName, + const OUString& _rCommand, const sal_Int32 _nCommandType ) + { + FmFormPage& rPage = static_cast< FmFormPage& >( *_rView.GetSdrPageView()->GetPage() ); + + Reference< XFormComponent > xFormComponent( _rSdrObj.GetUnoControlModel(), UNO_QUERY_THROW ); + Reference< XForm > xTargetForm( + rPage.GetImpl().findPlaceInFormComponentHierarchy( xFormComponent, _rxDataSource, _rDataSourceName, _rCommand, _nCommandType ), + UNO_SET_THROW ); + + FmFormPageImpl::setUniqueName( xFormComponent, xTargetForm ); + + Reference< XIndexContainer > xFormAsContainer( xTargetForm, UNO_QUERY_THROW ); + xFormAsContainer->insertByIndex( xFormAsContainer->getCount(), Any( xFormComponent ) ); + } +} + + +SdrObjectUniquePtr FmXFormView::implCreateFieldControl( const svx::ODataAccessDescriptor& _rColumnDescriptor ) +{ + // not if we're in design mode + if ( !m_pView->IsDesignMode() ) + return nullptr; + + OUString sCommand, sFieldName; + sal_Int32 nCommandType = CommandType::COMMAND; + SharedConnection xConnection; + + OUString sDataSource = _rColumnDescriptor.getDataSource(); + _rColumnDescriptor[ DataAccessDescriptorProperty::Command ] >>= sCommand; + _rColumnDescriptor[ DataAccessDescriptorProperty::ColumnName ] >>= sFieldName; + _rColumnDescriptor[ DataAccessDescriptorProperty::CommandType ] >>= nCommandType; + { + Reference< XConnection > xExternalConnection; + _rColumnDescriptor[ DataAccessDescriptorProperty::Connection ] >>= xExternalConnection; + xConnection.reset( xExternalConnection, SharedConnection::NoTakeOwnership ); + } + + if ( sCommand.isEmpty() + || sFieldName.isEmpty() + || ( sDataSource.isEmpty() + && !xConnection.is() + ) + ) + { + OSL_FAIL( "FmXFormView::implCreateFieldControl: nonsense!" ); + } + + Reference< XDataSource > xDataSource; + SQLErrorEvent aError; + try + { + if ( xConnection.is() && !xDataSource.is() && sDataSource.isEmpty() ) + { + Reference< XChild > xChild( xConnection, UNO_QUERY ); + if ( xChild.is() ) + xDataSource.set(xChild->getParent(), css::uno::UNO_QUERY); + } + + // obtain the data source + if ( !xDataSource.is() ) + xDataSource = getDataSource( sDataSource, comphelper::getProcessComponentContext() ); + + // and the connection, if necessary + if ( !xConnection.is() ) + xConnection.reset( getConnection_withFeedback( + sDataSource, + OUString(), + OUString(), + comphelper::getProcessComponentContext(), + nullptr + ) ); + } + catch (const SQLException&) + { + aError.Reason = ::cppu::getCaughtException(); + } + catch (const Exception& ) + { + /* will be asserted below */ + } + if (aError.Reason.hasValue()) + { + displayAsyncErrorMessage( aError ); + return nullptr; + } + + // need a data source and a connection here + if (!xDataSource.is() || !xConnection.is()) + { + OSL_FAIL("FmXFormView::implCreateFieldControl : could not retrieve the data source or the connection!"); + return nullptr; + } + + Reference< XComponent > xKeepFieldsAlive; + // go + try + { + // determine the table/query field which we should create a control for + Reference< XPropertySet > xField; + + Reference< XNameAccess > xFields = getFieldsByCommandDescriptor( + xConnection, nCommandType, sCommand, xKeepFieldsAlive ); + + if (xFields.is() && xFields->hasByName(sFieldName)) + xFields->getByName(sFieldName) >>= xField; + if ( !xField.is() ) + return nullptr; + + Reference< XNumberFormatsSupplier > xSupplier( getNumberFormats( xConnection ), UNO_SET_THROW ); + Reference< XNumberFormats > xNumberFormats( xSupplier->getNumberFormats(), UNO_SET_THROW ); + + OUString sLabelPostfix; + + + // only for text size + OutputDevice* pOutDev = nullptr; + if (m_pView->GetActualOutDev() && m_pView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW) + pOutDev = const_cast<OutputDevice*>(m_pView->GetActualOutDev()); + else + {// find OutDev + if (SdrPageView* pPageView = m_pView->GetSdrPageView()) + { + // const SdrPageViewWinList& rWinList = pPageView->GetWinList(); + // const SdrPageViewWindows& rPageViewWindows = pPageView->GetPageViewWindows(); + + for( sal_uInt32 i = 0; i < pPageView->PageWindowCount(); i++ ) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i); + + if( rPageWindow.GetPaintWindow().OutputToWindow()) + { + pOutDev = &rPageWindow.GetPaintWindow().GetOutputDevice(); + break; + } + } + } + } + + if ( !pOutDev ) + return nullptr; + + sal_Int32 nDataType = ::comphelper::getINT32(xField->getPropertyValue(FM_PROP_FIELDTYPE)); + if ((DataType::BINARY == nDataType) || (DataType::VARBINARY == nDataType)) + return nullptr; + + + // determine the control type by examining the data type of the bound column + SdrObjKind nOBJID = SdrObjKind::NONE; + bool bDateNTimeField = false; + + bool bIsCurrency = false; + if (::comphelper::hasProperty(FM_PROP_ISCURRENCY, xField)) + bIsCurrency = ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_ISCURRENCY)); + + if (bIsCurrency) + nOBJID = SdrObjKind::FormCurrencyField; + else + switch (nDataType) + { + case DataType::BLOB: + case DataType::LONGVARBINARY: + nOBJID = SdrObjKind::FormImageControl; + break; + case DataType::LONGVARCHAR: + case DataType::CLOB: + nOBJID = SdrObjKind::FormEdit; + break; + case DataType::BINARY: + case DataType::VARBINARY: + return nullptr; + case DataType::BIT: + case DataType::BOOLEAN: + nOBJID = SdrObjKind::FormCheckbox; + break; + case DataType::TINYINT: + case DataType::SMALLINT: + case DataType::INTEGER: + nOBJID = SdrObjKind::FormNumericField; + break; + case DataType::REAL: + case DataType::DOUBLE: + case DataType::NUMERIC: + case DataType::DECIMAL: + nOBJID = SdrObjKind::FormFormattedField; + break; + case DataType::TIMESTAMP: + bDateNTimeField = true; + sLabelPostfix = SvxResId(RID_STR_POSTFIX_DATE); + [[fallthrough]]; + case DataType::DATE: + nOBJID = SdrObjKind::FormDateField; + break; + case DataType::TIME: + nOBJID = SdrObjKind::FormTimeField; + break; + case DataType::CHAR: + case DataType::VARCHAR: + default: + nOBJID = SdrObjKind::FormEdit; + break; + } + if (nOBJID == SdrObjKind::NONE) + return nullptr; + + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp> pLabel; + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp> pControl; + if ( !createControlLabelPair( *pOutDev, 0, 0, xField, xNumberFormats, nOBJID, sLabelPostfix, + pLabel, pControl, xDataSource, sDataSource, sCommand, nCommandType ) + ) + { + return nullptr; + } + + + // group objects + bool bCheckbox = ( SdrObjKind::FormCheckbox == nOBJID ); + OSL_ENSURE( !bCheckbox || !pLabel, "FmXFormView::implCreateFieldControl: why was there a label created for a check box?" ); + if ( bCheckbox ) + return SdrObjectUniquePtr(pControl.release()); + + SdrObjGroup* pGroup = new SdrObjGroup(getView()->getSdrModelFromSdrView()); + SdrObjList* pObjList = pGroup->GetSubList(); + pObjList->InsertObject( pLabel.release() ); + pObjList->InsertObject( pControl.release() ); + + if ( bDateNTimeField ) + { // so far we created a date field only, but we also need a time field + if ( createControlLabelPair( *pOutDev, 0, 1000, xField, xNumberFormats, SdrObjKind::FormTimeField, + SvxResId(RID_STR_POSTFIX_TIME), pLabel, pControl, + xDataSource, sDataSource, sCommand, nCommandType ) + ) + { + pObjList->InsertObject( pLabel.release() ); + pObjList->InsertObject( pControl.release() ); + } + } + + return SdrObjectUniquePtr(pGroup); // and done + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + + return nullptr; +} + + +SdrObjectUniquePtr FmXFormView::implCreateXFormsControl( const svx::OXFormsDescriptor &_rDesc ) +{ + // not if we're in design mode + if ( !m_pView->IsDesignMode() ) + return nullptr; + + // go + try + { + // determine the table/query field which we should create a control for + Reference< XNumberFormats > xNumberFormats; + OUString sLabelPostfix = _rDesc.szName; + + + // only for text size + OutputDevice* pOutDev = nullptr; + if (m_pView->GetActualOutDev() && m_pView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW) + pOutDev = const_cast<OutputDevice*>(m_pView->GetActualOutDev()); + else + {// find OutDev + if (SdrPageView* pPageView = m_pView->GetSdrPageView()) + { + // const SdrPageViewWinList& rWinList = pPageView->GetWinList(); + // const SdrPageViewWindows& rPageViewWindows = pPageView->GetPageViewWindows(); + + for( sal_uInt32 i = 0; i < pPageView->PageWindowCount(); i++ ) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i); + + if( rPageWindow.GetPaintWindow().GetOutputDevice().GetOutDevType() == OUTDEV_WINDOW) + { + pOutDev = &rPageWindow.GetPaintWindow().GetOutputDevice(); + break; + } + } + } + } + + if ( !pOutDev ) + return nullptr; + + + // The service name decides which control should be created + SdrObjKind nOBJID = SdrObjKind::FormEdit; + if(_rDesc.szServiceName == FM_SUN_COMPONENT_NUMERICFIELD) + nOBJID = SdrObjKind::FormNumericField; + if(_rDesc.szServiceName == FM_SUN_COMPONENT_CHECKBOX) + nOBJID = SdrObjKind::FormCheckbox; + if(_rDesc.szServiceName == FM_COMPONENT_COMMANDBUTTON) + nOBJID = SdrObjKind::FormButton; + + Reference< css::form::submission::XSubmission > xSubmission(_rDesc.xPropSet, UNO_QUERY); + + // xform control or submission button? + if ( !xSubmission.is() ) + { + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp> pLabel; + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp> pControl; + if ( !createControlLabelPair( *pOutDev, 0, 0, nullptr, xNumberFormats, nOBJID, sLabelPostfix, + pLabel, pControl, nullptr, "", "", -1 ) + ) + { + return nullptr; + } + + + // Now build the connection between the control and the data item. + Reference< XValueBinding > xValueBinding(_rDesc.xPropSet,UNO_QUERY); + Reference< XBindableValue > xBindableValue(pControl->GetUnoControlModel(),UNO_QUERY); + + DBG_ASSERT( xBindableValue.is(), "FmXFormView::implCreateXFormsControl: control's not bindable!" ); + if ( xBindableValue.is() ) + xBindableValue->setValueBinding(xValueBinding); + + bool bCheckbox = ( SdrObjKind::FormCheckbox == nOBJID ); + OSL_ENSURE( !bCheckbox || !pLabel, "FmXFormView::implCreateXFormsControl: why was there a label created for a check box?" ); + if ( bCheckbox ) + return SdrObjectUniquePtr(pControl.release()); + + + // group objects + SdrObjGroup* pGroup = new SdrObjGroup(getView()->getSdrModelFromSdrView()); + SdrObjList* pObjList = pGroup->GetSubList(); + pObjList->InsertObject(pLabel.release()); + pObjList->InsertObject(pControl.release()); + + return SdrObjectUniquePtr(pGroup); + } + else { + + // create a button control + const MapMode& eTargetMode( pOutDev->GetMapMode() ); + const MapMode eSourceMode(MapUnit::Map100thMM); + const SdrObjKind nObjID = SdrObjKind::FormButton; + ::Size controlSize(4000, 500); + FmFormObj *pControl = static_cast<FmFormObj*>( + SdrObjFactory::MakeNewObject( + getView()->getSdrModelFromSdrView(), + SdrInventor::FmForm, + nObjID)); + controlSize.setWidth( tools::Long(controlSize.Width() * eTargetMode.GetScaleX()) ); + controlSize.setHeight( tools::Long(controlSize.Height() * eTargetMode.GetScaleY()) ); + ::Point controlPos( OutputDevice::LogicToLogic( ::Point( controlSize.Width(), 0 ), eSourceMode, eTargetMode ) ); + ::tools::Rectangle controlRect( controlPos, OutputDevice::LogicToLogic( controlSize, eSourceMode, eTargetMode ) ); + pControl->SetLogicRect(controlRect); + + // set the button label + Reference< XPropertySet > xControlSet(pControl->GetUnoControlModel(), UNO_QUERY); + xControlSet->setPropertyValue(FM_PROP_LABEL, Any(_rDesc.szName)); + + // connect the submission with the submission supplier (aka the button) + xControlSet->setPropertyValue( FM_PROP_BUTTON_TYPE, + Any( FormButtonType_SUBMIT ) ); + Reference< css::form::submission::XSubmissionSupplier > xSubmissionSupplier(pControl->GetUnoControlModel(), UNO_QUERY); + xSubmissionSupplier->setSubmission(xSubmission); + + return SdrObjectUniquePtr(pControl); + } + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION("svx.form", "caught an exception while creating the control !"); + } + + + return nullptr; +} + +bool FmXFormView::createControlLabelPair( OutputDevice const & _rOutDev, sal_Int32 _nXOffsetMM, sal_Int32 _nYOffsetMM, + const Reference< XPropertySet >& _rxField, const Reference< XNumberFormats >& _rxNumberFormats, + SdrObjKind _nControlObjectID, std::u16string_view _rFieldPostfix, + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp>& _rpLabel, + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp>& _rpControl, + const Reference< XDataSource >& _rxDataSource, const OUString& _rDataSourceName, + const OUString& _rCommand, const sal_Int32 _nCommandType ) +{ + if(!createControlLabelPair( + _rOutDev, + _nXOffsetMM, + _nYOffsetMM, + _rxField, + _rxNumberFormats, + _nControlObjectID, + _rFieldPostfix, + SdrInventor::FmForm, + SdrObjKind::FormFixedText, + + // tdf#118963 Hand over a SdrModel to SdrObject-creation. It uses the local m_pView + // and already returning false when nullptr == getView() could be done, but m_pView + // is already dereferenced here in many places (see below), so just use it for now. + getView()->getSdrModelFromSdrView(), + + _rpLabel, + _rpControl)) + { + return false; + } + + // insert the control model(s) into the form component hierarchy + if ( _rpLabel ) + lcl_insertIntoFormComponentHierarchy_throw( *m_pView, *_rpLabel, _rxDataSource, _rDataSourceName, _rCommand, _nCommandType ); + lcl_insertIntoFormComponentHierarchy_throw( *m_pView, *_rpControl, _rxDataSource, _rDataSourceName, _rCommand, _nCommandType ); + + // some context-dependent initializations + FormControlFactory aControlFactory; + if ( _rpLabel ) + aControlFactory.initializeControlModel( impl_getDocumentType(), *_rpLabel ); + aControlFactory.initializeControlModel( impl_getDocumentType(), *_rpControl ); + + return true; +} + + +bool FmXFormView::createControlLabelPair( OutputDevice const & _rOutDev, sal_Int32 _nXOffsetMM, sal_Int32 _nYOffsetMM, + const Reference< XPropertySet >& _rxField, + const Reference< XNumberFormats >& _rxNumberFormats, SdrObjKind _nControlObjectID, + std::u16string_view _rFieldPostfix, SdrInventor _nInventor, SdrObjKind _nLabelObjectID, + SdrModel& _rModel, + std::unique_ptr<SdrUnoObj, SdrObjectFreeOp>& _rpLabel, std::unique_ptr<SdrUnoObj, SdrObjectFreeOp>& _rpControl) +{ + sal_Int32 nDataType = 0; + OUString sFieldName; + Any aFieldName; + if ( _rxField.is() ) + { + nDataType = ::comphelper::getINT32(_rxField->getPropertyValue(FM_PROP_FIELDTYPE)); + aFieldName = _rxField->getPropertyValue(FM_PROP_NAME); + aFieldName >>= sFieldName; + } + + // calculate the positions, respecting the settings of the target device + ::Size aTextSize( _rOutDev.GetTextWidth(sFieldName + _rFieldPostfix), _rOutDev.GetTextHeight() ); + + MapMode eTargetMode( _rOutDev.GetMapMode() ), + eSourceMode( MapUnit::Map100thMM ); + + // text width is at least 4 centimeters + // text height is always half a centimeter + ::Size aDefTxtSize(4000, 500); + ::Size aDefSize(4000, 500); + ::Size aDefImageSize(4000, 4000); + + ::Size aRealSize = OutputDevice::LogicToLogic(aTextSize, eTargetMode, eSourceMode); + aRealSize.setWidth( std::max(aRealSize.Width(), aDefTxtSize.Width()) ); + aRealSize.setHeight( aDefSize.Height() ); + + // adjust to scaling of the target device (#53523#) + aRealSize.setWidth( tools::Long(Fraction(aRealSize.Width(), 1) * eTargetMode.GetScaleX()) ); + aRealSize.setHeight( tools::Long(Fraction(aRealSize.Height(), 1) * eTargetMode.GetScaleY()) ); + + // for boolean fields, we do not create a label, but just a checkbox + bool bNeedLabel = ( _nControlObjectID != SdrObjKind::FormCheckbox ); + + // the label + ::std::unique_ptr< SdrUnoObj, SdrObjectFreeOp > pLabel; + Reference< XPropertySet > xLabelModel; + + if ( bNeedLabel ) + { + pLabel.reset( dynamic_cast< SdrUnoObj* >( + SdrObjFactory::MakeNewObject( + _rModel, + _nInventor, + _nLabelObjectID))); + + OSL_ENSURE(pLabel, "FmXFormView::createControlLabelPair: could not create the label!"); + + if (!pLabel) + return false; + + xLabelModel.set( pLabel->GetUnoControlModel(), UNO_QUERY ); + if ( xLabelModel.is() ) + { + OUString sLabel; + if ( _rxField.is() && _rxField->getPropertySetInfo()->hasPropertyByName(FM_PROP_LABEL) ) + _rxField->getPropertyValue(FM_PROP_LABEL) >>= sLabel; + if ( sLabel.isEmpty() ) + sLabel = sFieldName; + + xLabelModel->setPropertyValue( FM_PROP_LABEL, Any( sLabel + _rFieldPostfix ) ); + OUString sObjectLabel(SvxResId(RID_STR_OBJECT_LABEL).replaceAll("#object#", sFieldName)); + xLabelModel->setPropertyValue(FM_PROP_NAME, Any(sObjectLabel)); + } + + pLabel->SetLogicRect( ::tools::Rectangle( + OutputDevice::LogicToLogic( ::Point( _nXOffsetMM, _nYOffsetMM ), eSourceMode, eTargetMode ), + OutputDevice::LogicToLogic( aRealSize, eSourceMode, eTargetMode ) + ) ); + } + + // the control + ::std::unique_ptr< SdrUnoObj, SdrObjectFreeOp > pControl( dynamic_cast< SdrUnoObj* >( + SdrObjFactory::MakeNewObject( + _rModel, + _nInventor, + _nControlObjectID))); + + OSL_ENSURE(pControl, "FmXFormView::createControlLabelPair: could not create the control!"); + + if (!pControl) + return false; + + Reference< XPropertySet > xControlSet( pControl->GetUnoControlModel(), UNO_QUERY ); + if ( !xControlSet.is() ) + return false; + + // size of the control + ::Size aControlSize( aDefSize ); + switch ( nDataType ) + { + case DataType::BIT: + case DataType::BOOLEAN: + aControlSize = aDefSize; + break; + case DataType::LONGVARCHAR: + case DataType::CLOB: + case DataType::LONGVARBINARY: + case DataType::BLOB: + aControlSize = aDefImageSize; + break; + } + + if ( SdrObjKind::FormImageControl == _nControlObjectID ) + aControlSize = aDefImageSize; + + aControlSize.setWidth( tools::Long(Fraction(aControlSize.Width(), 1) * eTargetMode.GetScaleX()) ); + aControlSize.setHeight( tools::Long(Fraction(aControlSize.Height(), 1) * eTargetMode.GetScaleY()) ); + + pControl->SetLogicRect( ::tools::Rectangle( + OutputDevice::LogicToLogic( ::Point( aRealSize.Width() + _nXOffsetMM, _nYOffsetMM ), eSourceMode, eTargetMode ), + OutputDevice::LogicToLogic( aControlSize, eSourceMode, eTargetMode ) + ) ); + + // some initializations + Reference< XPropertySetInfo > xControlPropInfo = xControlSet->getPropertySetInfo(); + + if ( aFieldName.hasValue() ) + { + xControlSet->setPropertyValue( FM_PROP_CONTROLSOURCE, aFieldName ); + xControlSet->setPropertyValue( FM_PROP_NAME, aFieldName ); + if ( !bNeedLabel ) + { + // no dedicated label control => use the label property + if ( xControlPropInfo->hasPropertyByName( FM_PROP_LABEL ) ) + xControlSet->setPropertyValue( FM_PROP_LABEL, Any( sFieldName + _rFieldPostfix ) ); + else + OSL_FAIL( "FmXFormView::createControlLabelPair: can't set a label for the control!" ); + } + } + + if ( (nDataType == DataType::LONGVARCHAR || nDataType == DataType::CLOB) && xControlPropInfo->hasPropertyByName( FM_PROP_MULTILINE ) ) + { + xControlSet->setPropertyValue( FM_PROP_MULTILINE, Any( true ) ); + } + + // announce the label to the control + if ( xControlPropInfo->hasPropertyByName( FM_PROP_CONTROLLABEL ) && xLabelModel.is() ) + { + try + { + xControlSet->setPropertyValue( FM_PROP_CONTROLLABEL, Any( xLabelModel ) ); + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + if ( _rxField.is() ) + { + FormControlFactory::initializeFieldDependentProperties( _rxField, xControlSet, _rxNumberFormats ); + } + + _rpLabel = std::move(pLabel); + _rpControl = std::move(pControl); + return true; +} + + +FmXFormView::ObjectRemoveListener::ObjectRemoveListener( FmXFormView* pParent ) + :m_pParent( pParent ) +{ +} + + +void FmXFormView::ObjectRemoveListener::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) +{ + if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint) + return; + const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint); + if (pSdrHint->GetKind() == SdrHintKind::ObjectRemoved) + m_pParent->ObjectRemovedInAliveMode(pSdrHint->GetObject()); +} + + +void FmXFormView::ObjectRemovedInAliveMode( const SdrObject* pObject ) +{ + // if the remote object in my MarkList, which I have memorized when switching to the + // Alive mode, I have to take it out now, because I otherwise try to set the mark + // again when switching back (interestingly, this fails only with grouped objects + // (when accessing their ObjList GPF), not with individual ones) + + const size_t nCount = m_aMark.GetMarkCount(); + for (size_t i = 0; i < nCount; ++i) + { + SdrMark* pMark = m_aMark.GetMark(i); + SdrObject* pCurrent = pMark->GetMarkedSdrObj(); + if (pObject == pCurrent) + { + m_aMark.DeleteMark(i); + return; + } + // I do not need to descend into GroupObjects: if an object is deleted there, + // then the pointer, which I have, to the GroupObject still remains valid ... + } +} + + +void FmXFormView::stopMarkListWatching() +{ + if ( m_pWatchStoredList ) + { + m_pWatchStoredList->EndListeningAll(); + m_pWatchStoredList.reset(); + } +} + + +void FmXFormView::startMarkListWatching() +{ + if ( !m_pWatchStoredList ) + { + FmFormModel* pModel = GetFormShell() ? GetFormShell()->GetFormModel() : nullptr; + DBG_ASSERT( pModel != nullptr, "FmXFormView::startMarkListWatching: shell has no model!" ); + if (pModel) + { + m_pWatchStoredList.reset(new ObjectRemoveListener( this )); + m_pWatchStoredList->StartListening( *static_cast< SfxBroadcaster* >( pModel ) ); + } + } + else + { + OSL_FAIL( "FmXFormView::startMarkListWatching: already listening!" ); + } +} + +void FmXFormView::saveMarkList() +{ + if ( m_pView ) + { + m_aMark = m_pView->GetMarkedObjectList(); + const size_t nCount = m_aMark.GetMarkCount( ); + for ( size_t i = 0; i < nCount; ++i ) + { + SdrMark* pMark = m_aMark.GetMark(i); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + + if ( m_pView->IsObjMarked( pObj ) ) + { + if ( pObj->IsGroupObject() ) + { + SdrObjListIter aIter( pObj->GetSubList() ); + bool bMixed = false; + while ( aIter.IsMore() && !bMixed ) + bMixed = ( aIter.Next()->GetObjInventor() != SdrInventor::FmForm ); + + if ( !bMixed ) + { + // all objects in the group are form objects + m_pView->MarkObj( pMark->GetMarkedSdrObj(), pMark->GetPageView(), true /* unmark! */ ); + } + } + else + { + if ( pObj->GetObjInventor() == SdrInventor::FmForm ) + { // this is a form layer object + m_pView->MarkObj( pMark->GetMarkedSdrObj(), pMark->GetPageView(), true /* unmark! */ ); + } + } + } + } + } + else + { + OSL_FAIL( "FmXFormView::saveMarkList: invalid view!" ); + m_aMark.Clear(); + } +} + +static bool lcl_hasObject( SdrObjListIter& rIter, SdrObject const * pObj ) +{ + bool bFound = false; + while (rIter.IsMore() && !bFound) + bFound = pObj == rIter.Next(); + + rIter.Reset(); + return bFound; +} + + +void FmXFormView::restoreMarkList( SdrMarkList& _rRestoredMarkList ) +{ + if ( !m_pView ) + return; + + _rRestoredMarkList.Clear(); + + const SdrMarkList& rCurrentList = m_pView->GetMarkedObjectList(); + FmFormPage* pPage = GetFormShell() ? GetFormShell()->GetCurPage() : nullptr; + if (!pPage) + return; + + if (rCurrentList.GetMarkCount()) + { // there is a current mark ... hmm. Is it a subset of the mark we remembered in saveMarkList? + bool bMisMatch = false; + + // loop through all current marks + const size_t nCurrentCount = rCurrentList.GetMarkCount(); + for ( size_t i=0; i<nCurrentCount && !bMisMatch; ++i ) + { + const SdrObject* pCurrentMarked = rCurrentList.GetMark( i )->GetMarkedSdrObj(); + + // loop through all saved marks, check for equality + bool bFound = false; + const size_t nSavedCount = m_aMark.GetMarkCount(); + for ( size_t j=0; j<nSavedCount && !bFound; ++j ) + { + if ( m_aMark.GetMark( j )->GetMarkedSdrObj() == pCurrentMarked ) + bFound = true; + } + + // did not find a current mark in the saved marks + if ( !bFound ) + bMisMatch = true; + } + + if ( bMisMatch ) + { + m_aMark.Clear(); + _rRestoredMarkList = rCurrentList; + return; + } + } + // it is important that the objects of the mark list are not accessed, + // because they can be already destroyed + SdrPageView* pCurPageView = m_pView->GetSdrPageView(); + SdrObjListIter aPageIter( pPage ); + bool bFound = true; + + // do all objects still exist + const size_t nCount = m_aMark.GetMarkCount(); + for (size_t i = 0; i < nCount && bFound; ++i) + { + SdrMark* pMark = m_aMark.GetMark(i); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + if (pObj->IsGroupObject()) + { + SdrObjListIter aIter(pObj->GetSubList()); + while (aIter.IsMore() && bFound) + bFound = lcl_hasObject(aPageIter, aIter.Next()); + } + else + bFound = lcl_hasObject(aPageIter, pObj); + + bFound = bFound && pCurPageView == pMark->GetPageView(); + } + + if (bFound) + { + // evaluate the LastObject + if (nCount) // now mark the objects + { + for (size_t i = 0; i < nCount; ++i) + { + SdrMark* pMark = m_aMark.GetMark(i); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + if ( pObj->GetObjInventor() == SdrInventor::FmForm ) + if ( !m_pView->IsObjMarked( pObj ) ) + m_pView->MarkObj( pObj, pMark->GetPageView() ); + } + + _rRestoredMarkList = m_aMark; + } + } + m_aMark.Clear(); +} + +void SAL_CALL FmXFormView::focusGained( const FocusEvent& /*e*/ ) +{ + if ( m_xWindow.is() && m_pView ) + { + m_pView->SetMoveOutside( true, FmFormView::ImplAccess() ); + } +} + +void SAL_CALL FmXFormView::focusLost( const FocusEvent& /*e*/ ) +{ + // when switch the focus outside the office the mark didn't change + // so we can not remove us as focus listener + if ( m_xWindow.is() && m_pView ) + { + m_pView->SetMoveOutside( false, FmFormView::ImplAccess() ); + } +} + +DocumentType FmXFormView::impl_getDocumentType() const +{ + if ( GetFormShell() && GetFormShell()->GetImpl() ) + return GetFormShell()->GetImpl()->getDocumentType_Lock(); + return eUnknownDocumentType; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/formcontrolfactory.cxx b/svx/source/form/formcontrolfactory.cxx new file mode 100644 index 000000000..61a28b21a --- /dev/null +++ b/svx/source/form/formcontrolfactory.cxx @@ -0,0 +1,702 @@ +/* -*- 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 <formcontrolfactory.hxx> +#include <fmcontrollayout.hxx> +#include <fmprop.hxx> +#include <svx/strings.hrc> +#include <fmservs.hxx> +#include <svx/dialmgr.hxx> +#include <svx/svdouno.hxx> + +#include <com/sun/star/form/XFormComponent.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/awt/ScrollBarOrientation.hpp> +#include <com/sun/star/awt/MouseWheelBehavior.hpp> +#include <com/sun/star/form/XGridColumnFactory.hpp> +#include <com/sun/star/style/VerticalAlignment.hpp> +#include <com/sun/star/awt/LineEndFormat.hpp> +#include <com/sun/star/awt/ImageScaleMode.hpp> +#include <com/sun/star/sdbc/DataType.hpp> +#include <com/sun/star/sdbc/XDataSource.hpp> +#include <com/sun/star/util/XNumberFormatTypes.hpp> +#include <com/sun/star/sdbc/ColumnValue.hpp> +#include <com/sun/star/text/WritingMode2.hpp> + +#include <comphelper/numbers.hxx> +#include <comphelper/processfactory.hxx> +#include <unotools/syslocale.hxx> +#include <tools/gen.hxx> +#include <tools/diagnose_ex.h> +#include <connectivity/dbtools.hxx> +#include <i18nlangtag/languagetag.hxx> + +#include <set> + +using namespace ::dbtools; + +namespace svxform +{ + + + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::uno::UNO_SET_THROW; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::uno::Any; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::uno::XComponentContext; + using ::com::sun::star::beans::XPropertySet; + using ::com::sun::star::form::XFormComponent; + using ::com::sun::star::container::XIndexAccess; + using ::com::sun::star::beans::XPropertySetInfo; + using ::com::sun::star::beans::PropertyValue; + using ::com::sun::star::container::XChild; + using ::com::sun::star::form::XGridColumnFactory; + using ::com::sun::star::style::VerticalAlignment_MIDDLE; + using ::com::sun::star::beans::Property; + using ::com::sun::star::uno::TypeClass_DOUBLE; + using ::com::sun::star::uno::TypeClass_LONG; + using ::com::sun::star::util::XNumberFormats; + using ::com::sun::star::util::XNumberFormatTypes; + using ::com::sun::star::lang::XServiceInfo; + using ::com::sun::star::container::XNameAccess; + + namespace FormComponentType = ::com::sun::star::form::FormComponentType; + namespace ScrollBarOrientation = ::com::sun::star::awt::ScrollBarOrientation; + namespace MouseWheelBehavior = ::com::sun::star::awt::MouseWheelBehavior; + namespace LineEndFormat = ::com::sun::star::awt::LineEndFormat; + namespace ImageScaleMode = ::com::sun::star::awt::ImageScaleMode; + namespace DataType = ::com::sun::star::sdbc::DataType; + namespace ColumnValue = ::com::sun::star::sdbc::ColumnValue; + namespace WritingMode2 = ::com::sun::star::text::WritingMode2; + + FormControlFactory::FormControlFactory( const Reference<XComponentContext>& _rContext ) + :m_xContext( _rContext ) + { + } + + FormControlFactory::FormControlFactory( ) + :m_xContext( comphelper::getProcessComponentContext() ) + { + } + + + FormControlFactory::~FormControlFactory() + { + } + + + sal_Int16 FormControlFactory::initializeControlModel( const DocumentType _eDocType, const SdrUnoObj& _rObject ) + { + return initializeControlModel( + _eDocType, + Reference< XPropertySet >( _rObject.GetUnoControlModel(), UNO_QUERY ), + _rObject.GetCurrentBoundRect() + ); + } + + + void FormControlFactory::initializeControlModel( const DocumentType _eDocType, const Reference< XPropertySet >& _rxControlModel ) + { + initializeControlModel( + _eDocType, _rxControlModel, tools::Rectangle() + ); + } + + + namespace + { + + OUString lcl_getUniqueLabel_nothrow( const Reference< XPropertySet >& _rxControlModel, const OUString& _rBaseLabel ) + { + OUString sLabel( _rBaseLabel ); + try + { + typedef ::std::set< OUString > StringBag; + StringBag aUsedLabels; + + Reference< XFormComponent > xFormComponent( _rxControlModel, UNO_QUERY_THROW ); + Reference< XIndexAccess > xContainer( xFormComponent->getParent(), UNO_QUERY_THROW ); + // loop through all siblings of the control model, and collect their labels + for ( sal_Int32 index=xContainer->getCount(); index>0; ) + { + Reference< XPropertySet > xElement( xContainer->getByIndex( --index ), UNO_QUERY_THROW ); + if ( xElement == _rxControlModel ) + continue; + + Reference< XPropertySetInfo > xPSI( xElement->getPropertySetInfo(), UNO_SET_THROW ); + if ( !xPSI->hasPropertyByName( FM_PROP_LABEL ) ) + continue; + + OUString sElementLabel; + OSL_VERIFY( xElement->getPropertyValue( FM_PROP_LABEL ) >>= sElementLabel ); + aUsedLabels.insert( sElementLabel ); + } + + // now find a free label + sal_Int32 i=2; + while ( aUsedLabels.find( sLabel ) != aUsedLabels.end() ) + { + OUStringBuffer aBuffer( _rBaseLabel ); + aBuffer.append( " " ); + aBuffer.append( i++ ); + sLabel = aBuffer.makeStringAndClear(); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return sLabel; + } + + + Sequence< PropertyValue > lcl_getDataSourceIndirectProperties( const Reference< XPropertySet >& _rxControlModel, + const Reference<XComponentContext>& _rContext ) + { + OSL_PRECOND( _rxControlModel.is(), "lcl_getDataSourceIndirectProperties: invalid model!" ); + + Sequence< PropertyValue > aInfo; + try + { + Reference< XChild > xChild( _rxControlModel, UNO_QUERY ); + Reference< XPropertySet > xForm; + if ( xChild.is() ) + xForm.set(xChild->getParent(), css::uno::UNO_QUERY); + + if ( Reference< XGridColumnFactory >( xForm, UNO_QUERY ).is() ) + { // hmm. the model is a grid column, in real + xChild.set(xForm, css::uno::UNO_QUERY); + xForm.set(xChild->getParent(), css::uno::UNO_QUERY); + } + + OSL_ENSURE( xForm.is(), "lcl_getDataSourceIndirectProperties: could not determine the form!" ); + if ( !xForm.is() ) + return aInfo; + OUString sDataSourceName; + xForm->getPropertyValue( FM_PROP_DATASOURCE ) >>= sDataSourceName; + + Reference< XPropertySet > xDsProperties; + if ( !sDataSourceName.isEmpty() ) + xDsProperties.set(getDataSource( sDataSourceName, _rContext ), css::uno::UNO_QUERY); + if ( xDsProperties.is() ) + xDsProperties->getPropertyValue("Info") >>= aInfo; + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "lcl_getDataSourceIndirectProperties" ); + } + return aInfo; + } + + + const char* aCharacterAndParagraphProperties[] = + { + "CharFontName", + "CharFontStyleName", + "CharFontFamily", + "CharFontCharSet", + "CharFontPitch", + "CharColor", + "CharEscapement", + "CharHeight", + "CharUnderline", + "CharWeight", + "CharPosture", + "CharAutoKerning", + "CharBackColor", + "CharBackTransparent", + "CharCaseMap", + "CharCrossedOut", + "CharFlash", + "CharStrikeout", + "CharWordMode", + "CharKerning", + "CharLocale", + "CharKeepTogether", + "CharNoLineBreak", + "CharShadowed", + "CharFontType", + "CharStyleName", + "CharContoured", + "CharCombineIsOn", + "CharCombinePrefix", + "CharCombineSuffix", + "CharEmphasize", + "CharRelief", + "RubyText", + "RubyAdjust", + "RubyCharStyleName", + "RubyIsAbove", + "CharRotation", + "CharRotationIsFitToLine", + "CharScaleWidth", + "HyperLinkURL", + "HyperLinkTarget", + "HyperLinkName", + "VisitedCharStyleName", + "UnvisitedCharStyleName", + "CharEscapementHeight", + "CharNoHyphenation", + "CharUnderlineColor", + "CharUnderlineHasColor", + "CharStyleNames", + "CharHeightAsian", + "CharWeightAsian", + "CharFontNameAsian", + "CharFontStyleNameAsian", + "CharFontFamilyAsian", + "CharFontCharSetAsian", + "CharFontPitchAsian", + "CharPostureAsian", + "CharLocaleAsian", + "ParaIsCharacterDistance", + "ParaIsForbiddenRules", + "ParaIsHangingPunctuation", + "CharHeightComplex", + "CharWeightComplex", + "CharFontNameComplex", + "CharFontStyleNameComplex", + "CharFontFamilyComplex", + "CharFontCharSetComplex", + "CharFontPitchComplex", + "CharPostureComplex", + "CharLocaleComplex", + "ParaAdjust", + "ParaLineSpacing", + "ParaBackColor", + "ParaBackTransparent", + "ParaBackGraphic", + "ParaBackGraphicURL", + "ParaBackGraphicFilter", + "ParaBackGraphicLocation", + "ParaLastLineAdjust", + "ParaExpandSingleWord", + "ParaLeftMargin", + "ParaRightMargin", + "ParaTopMargin", + "ParaBottomMargin", + "ParaLineNumberCount", + "ParaLineNumberStartValue", + "PageDescName", + "PageNumberOffset", + "ParaRegisterModeActive", + "ParaTabStops", + "ParaStyleName", + "DropCapFormat", + "DropCapWholeWord", + "ParaKeepTogether", + "Setting", + "ParaSplit", + "Setting", + "NumberingLevel", + "NumberingRules", + "NumberingStartValue", + "ParaIsNumberingRestart", + "NumberingStyleName", + "ParaOrphans", + "ParaWidows", + "ParaShadowFormat", + "LeftBorder", + "RightBorder", + "TopBorder", + "BottomBorder", + "BorderDistance", + "LeftBorderDistance", + "RightBorderDistance", + "TopBorderDistance", + "BottomBorderDistance", + "BreakType", + "DropCapCharStyleName", + "ParaFirstLineIndent", + "ParaIsAutoFirstLineIndent", + "ParaIsHyphenation", + "ParaHyphenationMaxHyphens", + "ParaHyphenationMaxLeadingChars", + "ParaHyphenationMaxTrailingChars", + "ParaVertAlignment", + "ParaUserDefinedAttributes", + "NumberingIsNumber", + "ParaIsConnectBorder", + nullptr + }; + + + void lcl_initializeCharacterAttributes( const Reference< XPropertySet >& _rxModel ) + { + try + { + Reference< XPropertySet > xStyle( ControlLayouter::getDefaultDocumentTextStyle( _rxModel ), UNO_SET_THROW ); + + // transfer all properties which are described by the style + Reference< XPropertySetInfo > xSourcePropInfo( xStyle->getPropertySetInfo(), UNO_SET_THROW ); + Reference< XPropertySetInfo > xDestPropInfo( _rxModel->getPropertySetInfo(), UNO_SET_THROW ); + + OUString sPropertyName; + const char** pCharacterProperty = aCharacterAndParagraphProperties; + while ( *pCharacterProperty ) + { + sPropertyName = OUString::createFromAscii( *pCharacterProperty ); + + if ( xSourcePropInfo->hasPropertyByName( sPropertyName ) && xDestPropInfo->hasPropertyByName( sPropertyName ) ) + _rxModel->setPropertyValue( sPropertyName, xStyle->getPropertyValue( sPropertyName ) ); + + ++pCharacterProperty; + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + + + sal_Int16 FormControlFactory::initializeControlModel( const DocumentType _eDocType, const Reference< XPropertySet >& _rxControlModel, + const tools::Rectangle& _rControlBoundRect ) + { + sal_Int16 nClassId = FormComponentType::CONTROL; + + OSL_ENSURE( _rxControlModel.is(), "FormControlFactory::initializeControlModel: invalid model!" ); + if ( !_rxControlModel.is() ) + return nClassId; + + try + { + ControlLayouter::initializeControlLayout( _rxControlModel, _eDocType ); + + _rxControlModel->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId; + Reference< XPropertySetInfo > xPSI( _rxControlModel->getPropertySetInfo(), UNO_SET_THROW ); + switch ( nClassId ) + { + case FormComponentType::SCROLLBAR: + _rxControlModel->setPropertyValue("LiveScroll", Any( true ) ); + [[fallthrough]]; + case FormComponentType::SPINBUTTON: + { + sal_Int32 eOrientation = ScrollBarOrientation::HORIZONTAL; + if ( !_rControlBoundRect.IsEmpty() && ( _rControlBoundRect.GetWidth() < _rControlBoundRect.GetHeight() ) ) + eOrientation = ScrollBarOrientation::VERTICAL; + _rxControlModel->setPropertyValue( FM_PROP_ORIENTATION, Any( eOrientation ) ); + } + break; + + case FormComponentType::LISTBOX: + case FormComponentType::COMBOBOX: + { + bool bDropDown = !_rControlBoundRect.IsEmpty() && ( _rControlBoundRect.GetWidth() >= 3 * _rControlBoundRect.GetHeight() ); + if ( xPSI->hasPropertyByName( FM_PROP_DROPDOWN ) ) + _rxControlModel->setPropertyValue( FM_PROP_DROPDOWN, Any( bDropDown ) ); + _rxControlModel->setPropertyValue( FM_PROP_LINECOUNT, Any( sal_Int16( 20 ) ) ); + } + break; + + case FormComponentType::TEXTFIELD: + { + initializeTextFieldLineEnds( _rxControlModel ); + lcl_initializeCharacterAttributes( _rxControlModel ); + + if ( !_rControlBoundRect.IsEmpty() + && ( _rControlBoundRect.GetWidth() <= 4 * _rControlBoundRect.GetHeight() ) + ) + { + if ( xPSI->hasPropertyByName( FM_PROP_MULTILINE ) ) + _rxControlModel->setPropertyValue( FM_PROP_MULTILINE, Any( true ) ); + } + } + break; + + case FormComponentType::RADIOBUTTON: + case FormComponentType::CHECKBOX: + case FormComponentType::FIXEDTEXT: + { + OUString sVertAlignPropertyName( "VerticalAlign" ); + if ( xPSI->hasPropertyByName( sVertAlignPropertyName ) ) + _rxControlModel->setPropertyValue( sVertAlignPropertyName, Any( VerticalAlignment_MIDDLE ) ); + } + break; + + case FormComponentType::IMAGEBUTTON: + case FormComponentType::IMAGECONTROL: + { + static const OUStringLiteral sScaleModeProperty( u"ScaleMode" ); + if ( xPSI->hasPropertyByName( sScaleModeProperty ) ) + _rxControlModel->setPropertyValue( sScaleModeProperty, Any( ImageScaleMode::ISOTROPIC ) ); + } + break; + } + + // initial default label for the control + if ( xPSI->hasPropertyByName( FM_PROP_LABEL ) ) + { + OUString sExistingLabel; + OSL_VERIFY( _rxControlModel->getPropertyValue( FM_PROP_LABEL ) >>= sExistingLabel ); + if ( sExistingLabel.isEmpty() ) + { + OUString sInitialLabel; + OSL_VERIFY( _rxControlModel->getPropertyValue( FM_PROP_NAME ) >>= sInitialLabel ); + + TranslateId pTitleResId; + switch ( nClassId ) + { + case FormComponentType::COMMANDBUTTON: pTitleResId = RID_STR_PROPTITLE_PUSHBUTTON; break; + case FormComponentType::RADIOBUTTON: pTitleResId = RID_STR_PROPTITLE_RADIOBUTTON; break; + case FormComponentType::CHECKBOX: pTitleResId = RID_STR_PROPTITLE_CHECKBOX; break; + case FormComponentType::GROUPBOX: pTitleResId = RID_STR_PROPTITLE_GROUPBOX; break; + case FormComponentType::FIXEDTEXT: pTitleResId = RID_STR_PROPTITLE_FIXEDTEXT; break; + } + + if (pTitleResId) + sInitialLabel = SvxResId(pTitleResId); + + _rxControlModel->setPropertyValue( + FM_PROP_LABEL, + Any( lcl_getUniqueLabel_nothrow( _rxControlModel, sInitialLabel ) ) + ); + } + } + + // strict format = yes is the default (i93467) + if ( xPSI->hasPropertyByName( FM_PROP_STRICTFORMAT ) ) + { + _rxControlModel->setPropertyValue( FM_PROP_STRICTFORMAT, Any( true ) ); + } + + // mouse wheel: don't use it for scrolling by default (i110036) + if ( xPSI->hasPropertyByName( FM_PROP_MOUSE_WHEEL_BEHAVIOR ) ) + { + _rxControlModel->setPropertyValue( FM_PROP_MOUSE_WHEEL_BEHAVIOR, Any( MouseWheelBehavior::SCROLL_DISABLED ) ); + } + + if ( xPSI->hasPropertyByName( FM_PROP_WRITING_MODE ) ) + _rxControlModel->setPropertyValue( FM_PROP_WRITING_MODE, Any( WritingMode2::CONTEXT ) ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return nClassId; + } + + + void FormControlFactory::initializeTextFieldLineEnds( const Reference< XPropertySet >& _rxModel ) + { + OSL_PRECOND( _rxModel.is(), "initializeTextFieldLineEnds: invalid model!" ); + if ( !_rxModel.is() ) + return; + + try + { + Reference< XPropertySetInfo > xInfo = _rxModel->getPropertySetInfo(); + if ( !xInfo.is() || !xInfo->hasPropertyByName( FM_PROP_LINEENDFORMAT ) ) + return; + + // let's see if the data source which the form belongs to (if any) + // has a setting for the preferred line end format + bool bDosLineEnds = false; + const Sequence< PropertyValue > aInfo = lcl_getDataSourceIndirectProperties( _rxModel, m_xContext ); + const PropertyValue* pInfo = std::find_if(aInfo.begin(), aInfo.end(), + [](const PropertyValue& rInfo) { return rInfo.Name == "PreferDosLikeLineEnds"; }); + if (pInfo != aInfo.end()) + pInfo->Value >>= bDosLineEnds; + + sal_Int16 nLineEndFormat = bDosLineEnds ? LineEndFormat::CARRIAGE_RETURN_LINE_FEED : LineEndFormat::LINE_FEED; + _rxModel->setPropertyValue( FM_PROP_LINEENDFORMAT, Any( nLineEndFormat ) ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void FormControlFactory::initializeFieldDependentProperties( const Reference< XPropertySet >& _rxDatabaseField, + const Reference< XPropertySet >& _rxControlModel, const Reference< XNumberFormats >& _rxNumberFormats ) + { + OSL_PRECOND( _rxDatabaseField.is() && _rxControlModel.is(), + "FormControlFactory::initializeFieldDependentProperties: illegal params!" ); + if ( !_rxDatabaseField.is() || !_rxControlModel.is() ) + return; + + try + { + + // if the field has a numeric format, and the model has a "Scale" property, sync it + Reference< XPropertySetInfo > xFieldPSI( _rxDatabaseField->getPropertySetInfo(), UNO_SET_THROW ); + Reference< XPropertySetInfo > xModelPSI( _rxControlModel->getPropertySetInfo(), UNO_SET_THROW ); + + if ( xModelPSI->hasPropertyByName( FM_PROP_DECIMAL_ACCURACY ) ) + { + sal_Int32 nFormatKey = 0; + if ( xFieldPSI->hasPropertyByName( FM_PROP_FORMATKEY ) ) + { + _rxDatabaseField->getPropertyValue( FM_PROP_FORMATKEY ) >>= nFormatKey; + } + else + { + nFormatKey = getDefaultNumberFormat( + _rxDatabaseField, + Reference< XNumberFormatTypes >( _rxNumberFormats, UNO_QUERY ), + SvtSysLocale().GetLanguageTag().getLocale() + ); + } + + Any aScaleVal( ::comphelper::getNumberFormatDecimals( _rxNumberFormats, nFormatKey ) ); + _rxControlModel->setPropertyValue( FM_PROP_DECIMAL_ACCURACY, aScaleVal ); + } + + + // minimum and maximum of the control according to the type of the database field + sal_Int32 nDataType = DataType::OTHER; + OSL_VERIFY( _rxDatabaseField->getPropertyValue( FM_PROP_FIELDTYPE ) >>= nDataType ); + + if ( xModelPSI->hasPropertyByName( FM_PROP_VALUEMIN ) + && xModelPSI->hasPropertyByName( FM_PROP_VALUEMAX ) + ) + { + sal_Int32 nMinValue = -1000000000, nMaxValue = 1000000000; + switch ( nDataType ) + { + case DataType::TINYINT : nMinValue = 0; nMaxValue = 255; break; + case DataType::SMALLINT : nMinValue = -32768; nMaxValue = 32767; break; + case DataType::INTEGER : nMinValue = 0x80000000; nMaxValue = 0x7FFFFFFF; break; + // double and singles are ignored + } + + Any aValue; + + // both the minimum and the maximum value properties can be either Long or Double + Property aProperty = xModelPSI->getPropertyByName( FM_PROP_VALUEMIN ); + if ( aProperty.Type.getTypeClass() == TypeClass_DOUBLE ) + aValue <<= static_cast<double>(nMinValue); + else if ( aProperty.Type.getTypeClass() == TypeClass_LONG ) + aValue <<= nMinValue; + else + { + OSL_FAIL( "FormControlFactory::initializeFieldDependentProperties: unexpected property type (MinValue)!" ); + } + _rxControlModel->setPropertyValue( FM_PROP_VALUEMIN, aValue ); + + // both the minimum and the maximum value properties can be either Long or Double + aProperty = xModelPSI->getPropertyByName( FM_PROP_VALUEMAX ); + if ( aProperty.Type.getTypeClass() == TypeClass_DOUBLE ) + aValue <<= static_cast<double>(nMaxValue); + else if ( aProperty.Type.getTypeClass() == TypeClass_LONG ) + aValue <<= nMaxValue; + else + { + OSL_FAIL( "FormControlFactory::initializeFieldDependentProperties: unexpected property type (MaxValue)!" ); + } + _rxControlModel->setPropertyValue( FM_PROP_VALUEMAX, aValue ); + } + + + // a check box can be tristate if and only if the column it is bound to is nullable + sal_Int16 nClassId = FormComponentType::CONTROL; + OSL_VERIFY( _rxControlModel->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId ); + if ( nClassId == FormComponentType::CHECKBOX ) + { + sal_Int32 nNullable = ColumnValue::NULLABLE_UNKNOWN; + OSL_VERIFY( _rxDatabaseField->getPropertyValue( FM_PROP_ISNULLABLE ) >>= nNullable ); + _rxControlModel->setPropertyValue( FM_PROP_TRISTATE, Any( ColumnValue::NO_NULLS != nNullable ) ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + OUString FormControlFactory::getDefaultName( sal_Int16 _nClassId, const Reference< XServiceInfo >& _rxObject ) + { + TranslateId pResId; + + switch ( _nClassId ) + { + case FormComponentType::COMMANDBUTTON: pResId = RID_STR_PROPTITLE_PUSHBUTTON; break; + case FormComponentType::RADIOBUTTON: pResId = RID_STR_PROPTITLE_RADIOBUTTON; break; + case FormComponentType::CHECKBOX: pResId = RID_STR_PROPTITLE_CHECKBOX; break; + case FormComponentType::LISTBOX: pResId = RID_STR_PROPTITLE_LISTBOX; break; + case FormComponentType::COMBOBOX: pResId = RID_STR_PROPTITLE_COMBOBOX; break; + case FormComponentType::GROUPBOX: pResId = RID_STR_PROPTITLE_GROUPBOX; break; + case FormComponentType::IMAGEBUTTON: pResId = RID_STR_PROPTITLE_IMAGEBUTTON; break; + case FormComponentType::FIXEDTEXT: pResId = RID_STR_PROPTITLE_FIXEDTEXT; break; + case FormComponentType::GRIDCONTROL: pResId = RID_STR_PROPTITLE_DBGRID; break; + case FormComponentType::FILECONTROL: pResId = RID_STR_PROPTITLE_FILECONTROL; break; + case FormComponentType::DATEFIELD: pResId = RID_STR_PROPTITLE_DATEFIELD; break; + case FormComponentType::TIMEFIELD: pResId = RID_STR_PROPTITLE_TIMEFIELD; break; + case FormComponentType::NUMERICFIELD: pResId = RID_STR_PROPTITLE_NUMERICFIELD; break; + case FormComponentType::CURRENCYFIELD: pResId = RID_STR_PROPTITLE_CURRENCYFIELD; break; + case FormComponentType::PATTERNFIELD: pResId = RID_STR_PROPTITLE_PATTERNFIELD; break; + case FormComponentType::IMAGECONTROL: pResId = RID_STR_PROPTITLE_IMAGECONTROL; break; + case FormComponentType::HIDDENCONTROL: pResId = RID_STR_PROPTITLE_HIDDEN; break; + case FormComponentType::SCROLLBAR: pResId = RID_STR_PROPTITLE_SCROLLBAR; break; + case FormComponentType::SPINBUTTON: pResId = RID_STR_PROPTITLE_SPINBUTTON; break; + case FormComponentType::NAVIGATIONBAR: pResId = RID_STR_PROPTITLE_NAVBAR; break; + + case FormComponentType::TEXTFIELD: + pResId = RID_STR_PROPTITLE_EDIT; + if ( _rxObject.is() && _rxObject->supportsService( FM_SUN_COMPONENT_FORMATTEDFIELD ) ) + pResId = RID_STR_PROPTITLE_FORMATTED; + break; + + default: + pResId = RID_STR_CONTROL; break; + } + + return SvxResId(pResId); + } + + + OUString FormControlFactory::getDefaultUniqueName_ByComponentType( const Reference< XNameAccess >& _rxContainer, + const Reference< XPropertySet >& _rxObject ) + { + sal_Int16 nClassId = FormComponentType::CONTROL; + OSL_VERIFY( _rxObject->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId ); + OUString sBaseName = getDefaultName( nClassId, Reference< XServiceInfo >( _rxObject, UNO_QUERY ) ); + + return getUniqueName( _rxContainer, sBaseName ); + } + + + OUString FormControlFactory::getUniqueName( const Reference< XNameAccess >& _rxContainer, std::u16string_view _rBaseName ) + { + sal_Int32 n = 0; + OUString sName; + do + { + OUStringBuffer aBuf( _rBaseName ); + aBuf.append( " " ); + aBuf.append( ++n ); + sName = aBuf.makeStringAndClear(); + } + while ( _rxContainer->hasByName( sName ) ); + + return sName; + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/formcontroller.cxx b/svx/source/form/formcontroller.cxx new file mode 100644 index 000000000..d53b58939 --- /dev/null +++ b/svx/source/form/formcontroller.cxx @@ -0,0 +1,4168 @@ +/* -*- 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 <fmcontrolbordermanager.hxx> +#include <fmcontrollayout.hxx> +#include <formcontroller.hxx> +#include <formfeaturedispatcher.hxx> +#include <fmdocumentclassification.hxx> +#include <formcontrolling.hxx> +#include <fmprop.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <fmservs.hxx> +#include <svx/fmtools.hxx> +#include <fmurl.hxx> + +#include <com/sun/star/awt/FocusChangeReason.hpp> +#include <com/sun/star/awt/XCheckBox.hpp> +#include <com/sun/star/awt/XComboBox.hpp> +#include <com/sun/star/awt/XListBox.hpp> +#include <com/sun/star/awt/XVclWindowPeer.hpp> +#include <com/sun/star/awt/TabController.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/container/XIdentifierReplace.hpp> +#include <com/sun/star/form/TabulatorCycle.hpp> +#include <com/sun/star/form/validation/XValidatableFormComponent.hpp> +#include <com/sun/star/form/XBoundComponent.hpp> +#include <com/sun/star/form/XBoundControl.hpp> +#include <com/sun/star/form/XGridControl.hpp> +#include <com/sun/star/form/XLoadable.hpp> +#include <com/sun/star/form/XReset.hpp> +#include <com/sun/star/form/control/FilterControl.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/NoSupportException.hpp> +#include <com/sun/star/sdb/ParametersRequest.hpp> +#include <com/sun/star/sdb/RowChangeAction.hpp> +#include <com/sun/star/sdb/SQLFilterOperator.hpp> +#include <com/sun/star/sdb/XInteractionSupplyParameters.hpp> +#include <com/sun/star/sdbc/ColumnValue.hpp> +#include <com/sun/star/task/InteractionHandler.hpp> +#include <com/sun/star/form/runtime/FormOperations.hpp> +#include <com/sun/star/form/runtime/FormFeature.hpp> +#include <com/sun/star/container/XContainer.hpp> +#include <com/sun/star/sdbcx/XColumnsSupplier.hpp> +#include <com/sun/star/util/NumberFormatter.hpp> +#include <com/sun/star/sdb/SQLContext.hpp> +#include <com/sun/star/sdb/XColumn.hpp> + +#include <comphelper/enumhelper.hxx> +#include <comphelper/interaction.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/property.hxx> +#include <comphelper/sequence.hxx> +#include <comphelper/flagguard.hxx> +#include <comphelper/types.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <connectivity/IParseContext.hxx> +#include <connectivity/dbtools.hxx> +#include <connectivity/sqlparse.hxx> +#include <toolkit/controls/unocontrol.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <unotools/localedatawrapper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <o3tl/safeint.hxx> +#include <osl/mutex.hxx> +#include <sal/log.hxx> + +#include <algorithm> +#include <iterator> + +using namespace ::com::sun::star; +using namespace ::comphelper; +using namespace ::connectivity; +using namespace ::dbtools; + + +css::uno::Reference< css::uno::XInterface > + FormController_NewInstance_Impl( const css::uno::Reference< css::lang::XMultiServiceFactory > & _rxORB ) +{ + return *( new ::svxform::FormController( comphelper::getComponentContext(_rxORB) ) ); +} + +namespace svxform +{ + + using ::com::sun::star::sdb::XColumn; + using ::com::sun::star::awt::XControl; + using ::com::sun::star::awt::TabController; + using ::com::sun::star::awt::XToolkit; + using ::com::sun::star::awt::XWindowPeer; + using ::com::sun::star::form::XGrid; + using ::com::sun::star::beans::XPropertySet; + using ::com::sun::star::uno::UNO_SET_THROW; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::container::XIndexAccess; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::uno::Reference; + using ::com::sun::star::beans::XPropertySetInfo; + using ::com::sun::star::beans::PropertyValue; + using ::com::sun::star::lang::IndexOutOfBoundsException; + using ::com::sun::star::sdb::XInteractionSupplyParameters; + using ::com::sun::star::awt::XTextComponent; + using ::com::sun::star::awt::XTextListener; + using ::com::sun::star::uno::Any; + using ::com::sun::star::frame::XDispatch; + using ::com::sun::star::lang::XMultiServiceFactory; + using ::com::sun::star::uno::Type; + using ::com::sun::star::lang::IllegalArgumentException; + using ::com::sun::star::sdbc::XConnection; + using ::com::sun::star::sdbc::XRowSet; + using ::com::sun::star::sdbc::XDatabaseMetaData; + using ::com::sun::star::util::XNumberFormatsSupplier; + using ::com::sun::star::util::NumberFormatter; + using ::com::sun::star::util::XNumberFormatter; + using ::com::sun::star::sdbcx::XColumnsSupplier; + using ::com::sun::star::container::XNameAccess; + using ::com::sun::star::lang::EventObject; + using ::com::sun::star::beans::Property; + using ::com::sun::star::container::XEnumeration; + using ::com::sun::star::form::XFormComponent; + using ::com::sun::star::form::runtime::XFormOperations; + using ::com::sun::star::form::runtime::FilterEvent; + using ::com::sun::star::form::runtime::XFilterControllerListener; + using ::com::sun::star::awt::XControlContainer; + using ::com::sun::star::container::XIdentifierReplace; + using ::com::sun::star::form::XFormControllerListener; + using ::com::sun::star::awt::XWindow; + using ::com::sun::star::sdbc::XResultSet; + using ::com::sun::star::awt::XControlModel; + using ::com::sun::star::awt::XTabControllerModel; + using ::com::sun::star::beans::PropertyChangeEvent; + using ::com::sun::star::form::validation::XValidatableFormComponent; + using ::com::sun::star::form::XLoadable; + using ::com::sun::star::form::XBoundControl; + using ::com::sun::star::beans::XPropertyChangeListener; + using ::com::sun::star::awt::TextEvent; + using ::com::sun::star::form::XBoundComponent; + using ::com::sun::star::awt::XCheckBox; + using ::com::sun::star::awt::XComboBox; + using ::com::sun::star::awt::XListBox; + using ::com::sun::star::awt::ItemEvent; + using ::com::sun::star::util::XModifyListener; + using ::com::sun::star::form::XReset; + using ::com::sun::star::frame::XDispatchProviderInterception; + using ::com::sun::star::form::XGridControl; + using ::com::sun::star::awt::XVclWindowPeer; + using ::com::sun::star::form::validation::XValidator; + using ::com::sun::star::awt::FocusEvent; + using ::com::sun::star::sdb::SQLContext; + using ::com::sun::star::container::XChild; + using ::com::sun::star::form::TabulatorCycle_RECORDS; + using ::com::sun::star::container::ContainerEvent; + using ::com::sun::star::lang::DisposedException; + using ::com::sun::star::lang::Locale; + using ::com::sun::star::lang::NoSupportException; + using ::com::sun::star::sdb::RowChangeEvent; + using ::com::sun::star::frame::XStatusListener; + using ::com::sun::star::frame::XDispatchProviderInterceptor; + using ::com::sun::star::sdb::SQLErrorEvent; + using ::com::sun::star::form::DatabaseParameterEvent; + using ::com::sun::star::sdb::ParametersRequest; + using ::com::sun::star::task::XInteractionRequest; + using ::com::sun::star::util::URL; + using ::com::sun::star::frame::FeatureStateEvent; + using ::com::sun::star::form::runtime::XFormControllerContext; + using ::com::sun::star::task::InteractionHandler; + using ::com::sun::star::task::XInteractionHandler; + using ::com::sun::star::form::runtime::FormOperations; + using ::com::sun::star::container::XContainer; + using ::com::sun::star::sdbc::SQLWarning; + + namespace ColumnValue = ::com::sun::star::sdbc::ColumnValue; + namespace PropertyAttribute = ::com::sun::star::beans::PropertyAttribute; + namespace FocusChangeReason = ::com::sun::star::awt::FocusChangeReason; + namespace RowChangeAction = ::com::sun::star::sdb::RowChangeAction; + namespace FormFeature = ::com::sun::star::form::runtime::FormFeature; + +namespace { + +struct ColumnInfo +{ + // information about the column itself + Reference< XColumn > xColumn; + sal_Int32 nNullable; + bool bAutoIncrement; + bool bReadOnly; + OUString sName; + + // information about the control(s) bound to this column + + /// the first control which is bound to the given column, and which requires input + Reference< XControl > xFirstControlWithInputRequired; + /** the first grid control which contains a column which is bound to the given database column, and requires + input + */ + Reference< XGrid > xFirstGridWithInputRequiredColumn; + /** if xFirstControlWithInputRequired is a grid control, then nRequiredGridColumn specifies the position + of the grid column which is actually bound + */ + sal_Int32 nRequiredGridColumn; + + ColumnInfo() + :nNullable( ColumnValue::NULLABLE_UNKNOWN ) + ,bAutoIncrement( false ) + ,bReadOnly( false ) + ,nRequiredGridColumn( -1 ) + { + } +}; + +} + +class ColumnInfoCache +{ +public: + explicit ColumnInfoCache( const Reference< XColumnsSupplier >& _rxColSupplier ); + + size_t getColumnCount() const { return m_aColumns.size(); } + const ColumnInfo& getColumnInfo( size_t _pos ); + + bool controlsInitialized() const { return m_bControlsInitialized; } + void initializeControls( const Sequence< Reference< XControl > >& _rControls ); + void deinitializeControls(); + +private: + typedef ::std::vector< ColumnInfo > ColumnInfos; + ColumnInfos m_aColumns; + bool m_bControlsInitialized; +}; + + +ColumnInfoCache::ColumnInfoCache( const Reference< XColumnsSupplier >& _rxColSupplier ) + :m_bControlsInitialized( false ) +{ + try + { + m_aColumns.clear(); + + Reference< XIndexAccess > xColumns( _rxColSupplier->getColumns(), UNO_QUERY_THROW ); + sal_Int32 nColumnCount = xColumns->getCount(); + m_aColumns.reserve( nColumnCount ); + + Reference< XPropertySet > xColumnProps; + for ( sal_Int32 i = 0; i < nColumnCount; ++i ) + { + ColumnInfo aColInfo; + aColInfo.xColumn.set( xColumns->getByIndex(i), UNO_QUERY_THROW ); + + xColumnProps.set( aColInfo.xColumn, UNO_QUERY_THROW ); + OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_ISNULLABLE ) >>= aColInfo.nNullable ); + OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_AUTOINCREMENT ) >>= aColInfo.bAutoIncrement ); + OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_NAME ) >>= aColInfo.sName ); + OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_ISREADONLY ) >>= aColInfo.bReadOnly ); + + m_aColumns.push_back( aColInfo ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +namespace +{ + bool lcl_isBoundTo( const Reference< XPropertySet >& _rxControlModel, const Reference< XInterface >& _rxNormDBField ) + { + Reference< XInterface > xNormBoundField( _rxControlModel->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY ); + return ( xNormBoundField == _rxNormDBField ); + } + + bool lcl_isInputRequired( const Reference< XPropertySet >& _rxControlModel ) + { + bool bInputRequired = false; + OSL_VERIFY( _rxControlModel->getPropertyValue( FM_PROP_INPUT_REQUIRED ) >>= bInputRequired ); + return bInputRequired; + } + + void lcl_resetColumnControlInfo( ColumnInfo& _rColInfo ) + { + _rColInfo.xFirstControlWithInputRequired.clear(); + _rColInfo.xFirstGridWithInputRequiredColumn.clear(); + _rColInfo.nRequiredGridColumn = -1; + } +} + + +void ColumnInfoCache::deinitializeControls() +{ + for (auto& rCol : m_aColumns) + { + lcl_resetColumnControlInfo( rCol ); + } + m_bControlsInitialized = false; +} + + +void ColumnInfoCache::initializeControls( const Sequence< Reference< XControl > >& _rControls ) +{ + try + { + // for every of our known columns, find the controls which are bound to this column + for (auto& rCol : m_aColumns) + { + OSL_ENSURE( !rCol.xFirstControlWithInputRequired.is() && !rCol.xFirstGridWithInputRequiredColumn.is() + && ( rCol.nRequiredGridColumn == -1 ), "ColumnInfoCache::initializeControls: called me twice?" ); + + lcl_resetColumnControlInfo( rCol ); + + Reference< XInterface > xNormColumn( rCol.xColumn, UNO_QUERY_THROW ); + + const Reference< XControl >* pControl( _rControls.getConstArray() ); + const Reference< XControl >* pControlEnd( pControl + _rControls.getLength() ); + for ( ; pControl != pControlEnd; ++pControl ) + { + if ( !pControl->is() ) + continue; + + Reference< XPropertySet > xModel( (*pControl)->getModel(), UNO_QUERY_THROW ); + Reference< XPropertySetInfo > xModelPSI( xModel->getPropertySetInfo(), UNO_SET_THROW ); + + // special handling for grid controls + Reference< XGrid > xGrid( *pControl, UNO_QUERY ); + if ( xGrid.is() ) + { + Reference< XIndexAccess > xGridColAccess( xModel, UNO_QUERY_THROW ); + sal_Int32 gridColCount = xGridColAccess->getCount(); + sal_Int32 gridCol = 0; + for ( gridCol = 0; gridCol < gridColCount; ++gridCol ) + { + Reference< XPropertySet > xGridColumnModel( xGridColAccess->getByIndex( gridCol ), UNO_QUERY_THROW ); + + if ( !lcl_isBoundTo( xGridColumnModel, xNormColumn ) + || !lcl_isInputRequired( xGridColumnModel ) + ) + continue; // with next grid column + + break; + } + + if ( gridCol < gridColCount ) + { + // found a grid column which is bound to the given + rCol.xFirstGridWithInputRequiredColumn = xGrid; + rCol.nRequiredGridColumn = gridCol; + break; + } + + continue; // with next control + } + + if ( !xModelPSI->hasPropertyByName( FM_PROP_BOUNDFIELD ) + || !lcl_isBoundTo( xModel, xNormColumn ) + || !lcl_isInputRequired( xModel ) + ) + continue; // with next control + + break; + } + + if ( pControl == pControlEnd ) + // did not find a control which is bound to this particular column, and for which the input is required + continue; // with next DB column + + rCol.xFirstControlWithInputRequired = *pControl; + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + m_bControlsInitialized = true; +} + + +const ColumnInfo& ColumnInfoCache::getColumnInfo( size_t _pos ) +{ + if ( _pos >= m_aColumns.size() ) + throw IndexOutOfBoundsException(); + + return m_aColumns[ _pos ]; +} + +namespace { + +class OParameterContinuation : public OInteraction< XInteractionSupplyParameters > +{ + Sequence< PropertyValue > m_aValues; + +public: + OParameterContinuation() { } + + const Sequence< PropertyValue >& getValues() const { return m_aValues; } + +// XInteractionSupplyParameters + virtual void SAL_CALL setParameters( const Sequence< PropertyValue >& _rValues ) override; +}; + +} + +void SAL_CALL OParameterContinuation::setParameters( const Sequence< PropertyValue >& _rValues ) +{ + m_aValues = _rValues; +} + + +// FmXAutoControl + +struct FmFieldInfo +{ + OUString aFieldName; + Reference< XPropertySet > xField; + Reference< XTextComponent > xText; + + FmFieldInfo(const Reference< XPropertySet >& _xField, const Reference< XTextComponent >& _xText) + :xField(_xField) + ,xText(_xText) + {xField->getPropertyValue(FM_PROP_NAME) >>= aFieldName;} +}; + +namespace { + +class FmXAutoControl: public UnoControl + +{ +public: + FmXAutoControl() + { + } + + virtual OUString GetComponentServiceName() const override {return "Edit";} + virtual void SAL_CALL createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer > & rParentPeer ) override; + +protected: + virtual void ImplSetPeerProperty( const OUString& rPropName, const Any& rVal ) override; +}; + +} + +void FmXAutoControl::createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer > & rParentPeer ) +{ + UnoControl::createPeer( rxToolkit, rParentPeer ); + + Reference< XTextComponent > xText(getPeer() , UNO_QUERY); + if (xText.is()) + { + xText->setText(SvxResId(RID_STR_AUTOFIELD)); + xText->setEditable(false); + } +} + + +void FmXAutoControl::ImplSetPeerProperty( const OUString& rPropName, const Any& rVal ) +{ + // these properties are ignored + if (rPropName == FM_PROP_TEXT) + return; + + UnoControl::ImplSetPeerProperty( rPropName, rVal ); +} + + +IMPL_LINK_NOARG( FormController, OnActivateTabOrder, Timer*, void ) +{ + activateTabOrder(); +} + +namespace { + +struct UpdateAllListeners +{ + bool operator()( const Reference< XDispatch >& _rxDispatcher ) const + { + static_cast< svx::OSingleFeatureDispatcher* >( _rxDispatcher.get() )->updateAllListeners(); + // the return is a dummy only so we can use this struct in a lambda expression + return true; + } +}; + +} + +IMPL_LINK_NOARG( FormController, OnInvalidateFeatures, Timer*, void ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + for (const auto& rFeature : m_aInvalidFeatures) + { + DispatcherContainer::const_iterator aDispatcherPos = m_aFeatureDispatchers.find( rFeature ); + if ( aDispatcherPos != m_aFeatureDispatchers.end() ) + { + // TODO: for the real and actual listener notifications, we should release + // our mutex + UpdateAllListeners( )( aDispatcherPos->second ); + } + } +} + +FormController::FormController(const Reference< css::uno::XComponentContext > & _rxORB ) + :FormController_BASE( m_aMutex ) + ,OPropertySetHelper( FormController_BASE::rBHelper ) + ,OSQLParserClient( _rxORB ) + ,m_xComponentContext( _rxORB ) + ,m_aActivateListeners(m_aMutex) + ,m_aModifyListeners(m_aMutex) + ,m_aErrorListeners(m_aMutex) + ,m_aDeleteListeners(m_aMutex) + ,m_aRowSetApproveListeners(m_aMutex) + ,m_aParameterListeners(m_aMutex) + ,m_aFilterListeners(m_aMutex) + ,m_aTabActivationIdle("svx FormController m_aTabActivationIdle") + ,m_aFeatureInvalidationTimer("svx FormController m_aFeatureInvalidationTimer") + ,m_aMode( OUString( "DataMode" ) ) + ,m_aLoadEvent( LINK( this, FormController, OnLoad ) ) + ,m_aToggleEvent( LINK( this, FormController, OnToggleAutoFields ) ) + ,m_aActivationEvent( LINK( this, FormController, OnActivated ) ) + ,m_aDeactivationEvent( LINK( this, FormController, OnDeactivated ) ) + ,m_nCurrentFilterPosition(-1) + ,m_bCurrentRecordModified(false) + ,m_bCurrentRecordNew(false) + ,m_bLocked(false) + ,m_bDBConnection(false) + ,m_bCycle(false) + ,m_bCanInsert(false) + ,m_bCanUpdate(false) + ,m_bCommitLock(false) + ,m_bModified(false) + ,m_bControlsSorted(false) + ,m_bFiltering(false) + ,m_bAttachEvents(true) + ,m_bDetachEvents(true) + ,m_bAttemptedHandlerCreation( false ) + ,m_bSuspendFilterTextListening( false ) +{ + + osl_atomic_increment(&m_refCount); + { + m_xTabController = TabController::create( m_xComponentContext ); + m_xAggregate.set( m_xTabController, UNO_QUERY_THROW ); + m_xAggregate->setDelegator( *this ); + } + osl_atomic_decrement(&m_refCount); + + m_aTabActivationIdle.SetPriority( TaskPriority::LOWEST ); + m_aTabActivationIdle.SetInvokeHandler( LINK( this, FormController, OnActivateTabOrder ) ); + + m_aFeatureInvalidationTimer.SetTimeout( 200 ); + m_aFeatureInvalidationTimer.SetInvokeHandler( LINK( this, FormController, OnInvalidateFeatures ) ); +} + + +FormController::~FormController() +{ + { + ::osl::MutexGuard aGuard( m_aMutex ); + + m_aLoadEvent.CancelPendingCall(); + m_aToggleEvent.CancelPendingCall(); + m_aActivationEvent.CancelPendingCall(); + m_aDeactivationEvent.CancelPendingCall(); + + if ( m_aTabActivationIdle.IsActive() ) + m_aTabActivationIdle.Stop(); + } + + if ( m_aFeatureInvalidationTimer.IsActive() ) + m_aFeatureInvalidationTimer.Stop(); + + disposeAllFeaturesAndDispatchers(); + + if ( m_xFormOperations.is() ) + m_xFormOperations->dispose(); + m_xFormOperations.clear(); + + // release of aggregation + if ( m_xAggregate.is() ) + { + m_xAggregate->setDelegator( nullptr ); + m_xAggregate.clear(); + } +} + + +void SAL_CALL FormController::acquire() noexcept +{ + FormController_BASE::acquire(); +} + + +void SAL_CALL FormController::release() noexcept +{ + FormController_BASE::release(); +} + + +Any SAL_CALL FormController::queryInterface( const Type& _rType ) +{ + Any aRet = FormController_BASE::queryInterface( _rType ); + if ( !aRet.hasValue() ) + aRet = OPropertySetHelper::queryInterface( _rType ); + if ( !aRet.hasValue() ) + aRet = m_xAggregate->queryAggregation( _rType ); + return aRet; +} + + +Sequence< sal_Int8 > SAL_CALL FormController::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +Sequence< Type > SAL_CALL FormController::getTypes( ) +{ + return comphelper::concatSequences( + FormController_BASE::getTypes(), + ::cppu::OPropertySetHelper::getTypes() + ); +} + +// XServiceInfo +sal_Bool SAL_CALL FormController::supportsService(const OUString& ServiceName) +{ + return cppu::supportsService(this, ServiceName); +} + +OUString SAL_CALL FormController::getImplementationName() +{ + return "org.openoffice.comp.svx.FormController"; +} + +Sequence< OUString> SAL_CALL FormController::getSupportedServiceNames() +{ + // service names which are supported only, but cannot be used to created an + // instance at a service factory + Sequence<OUString> aNonCreatableServiceNames { "com.sun.star.form.FormControllerDispatcher" }; + + // services which can be used to created an instance at a service factory + Sequence< OUString > aCreatableServiceNames( getSupportedServiceNames_Static() ); + return ::comphelper::concatSequences( aCreatableServiceNames, aNonCreatableServiceNames ); +} + + +sal_Bool SAL_CALL FormController::approveReset(const EventObject& /*rEvent*/) +{ + return true; +} + + +void SAL_CALL FormController::resetted(const EventObject& rEvent) +{ + ::osl::MutexGuard aGuard(m_aMutex); + if (getCurrentControl().is() && (getCurrentControl()->getModel() == rEvent.Source)) + m_bModified = false; +} + + +Sequence< OUString> const & FormController::getSupportedServiceNames_Static() +{ + static Sequence< OUString> const aServices + { + "com.sun.star.form.runtime.FormController", + "com.sun.star.awt.control.TabController" + }; + return aServices; +} + + +namespace +{ + struct ResetComponentText + { + void operator()( const Reference< XTextComponent >& _rxText ) + { + _rxText->setText( OUString() ); + } + }; + + struct RemoveComponentTextListener + { + explicit RemoveComponentTextListener( const Reference< XTextListener >& _rxListener ) + :m_xListener( _rxListener ) + { + } + + void operator()( const Reference< XTextComponent >& _rxText ) + { + _rxText->removeTextListener( m_xListener ); + } + + private: + Reference< XTextListener > m_xListener; + }; +} + + +void FormController::impl_setTextOnAllFilter_throw() +{ + m_bSuspendFilterTextListening = true; + ::comphelper::FlagGuard aResetFlag( m_bSuspendFilterTextListening ); + + // reset the text for all controls + ::std::for_each( m_aFilterComponents.begin(), m_aFilterComponents.end(), ResetComponentText() ); + + if ( m_aFilterRows.empty() ) + // nothing to do anymore + return; + + if ( m_nCurrentFilterPosition < 0 ) + return; + + // set the text for all filters + OSL_ENSURE( m_aFilterRows.size() > o3tl::make_unsigned(m_nCurrentFilterPosition), + "FormController::impl_setTextOnAllFilter_throw: m_nCurrentFilterPosition too big" ); + + if ( o3tl::make_unsigned(m_nCurrentFilterPosition) < m_aFilterRows.size() ) + { + FmFilterRow& rRow = m_aFilterRows[ m_nCurrentFilterPosition ]; + for (const auto& rEntry : rRow) + { + rEntry.first->setText( rEntry.second ); + } + } +} +// OPropertySetHelper + +sal_Bool FormController::convertFastPropertyValue( Any & /*rConvertedValue*/, Any & /*rOldValue*/, + sal_Int32 /*nHandle*/, const Any& /*rValue*/ ) +{ + return false; +} + + +void FormController::setFastPropertyValue_NoBroadcast( sal_Int32 /*nHandle*/, const Any& /*rValue*/ ) +{ +} + + +void FormController::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const +{ + switch (nHandle) + { + case FM_ATTR_FILTER: + { + OUStringBuffer aFilter; + Reference<XConnection> xConnection(getConnection(Reference< XRowSet>(m_xModelAsIndex, UNO_QUERY))); + if (xConnection.is()) + { + Reference< XNumberFormatsSupplier> xFormatSupplier( getNumberFormats( xConnection, true ) ); + Reference< XNumberFormatter> xFormatter = NumberFormatter::create(m_xComponentContext); + xFormatter->attachNumberFormatsSupplier(xFormatSupplier); + + // now add the filter rows + try + { + for (const FmFilterRow& rRow : m_aFilterRows) + { + if ( rRow.empty() ) + continue; + + OUStringBuffer aRowFilter; + for ( FmFilterRow::const_iterator condition = rRow.begin(); condition != rRow.end(); ++condition ) + { + // get the field of the controls map + Reference< XControl > xControl( condition->first, UNO_QUERY_THROW ); + Reference< XPropertySet > xModelProps( xControl->getModel(), UNO_QUERY_THROW ); + Reference< XPropertySet > xField( xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY_THROW ); + + OUString sFilterValue( condition->second ); + + OUString sErrorMsg; + const std::unique_ptr< OSQLParseNode > pParseNode = + predicateTree( sErrorMsg, sFilterValue, xFormatter, xField ); + OSL_ENSURE( pParseNode != nullptr, "FormController::getFastPropertyValue: could not parse the field value predicate!" ); + if ( pParseNode != nullptr ) + { + OUString sCriteria; + // don't use a parse context here, we need it unlocalized + pParseNode->parseNodeToStr( sCriteria, xConnection ); + if ( condition != rRow.begin() ) + aRowFilter.append( " AND " ); + aRowFilter.append( sCriteria ); + } + } + if ( !aRowFilter.isEmpty() ) + { + if ( !aFilter.isEmpty() ) + aFilter.append( " OR " ); + + aFilter.append( "( " ); + aFilter.append( aRowFilter ); + aFilter.append( " )" ); + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + aFilter.setLength(0); + } + } + rValue <<= aFilter.makeStringAndClear(); + } + break; + + case FM_ATTR_FORM_OPERATIONS: + rValue <<= m_xFormOperations; + break; + } +} + + +Reference< XPropertySetInfo > FormController::getPropertySetInfo() +{ + static Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); + return xInfo; +} + + +void FormController::fillProperties( + Sequence< Property >& /* [out] */ _rProps, + Sequence< Property >& /* [out] */ /*_rAggregateProps*/ + ) const +{ + _rProps.realloc(2); + sal_Int32 nPos = 0; + Property* pDesc = _rProps.getArray(); + + pDesc[nPos++] = Property(FM_PROP_FILTER, FM_ATTR_FILTER, + cppu::UnoType<OUString>::get(), + PropertyAttribute::READONLY); + pDesc[nPos++] = Property(FM_PROP_FORM_OPERATIONS, FM_ATTR_FORM_OPERATIONS, + cppu::UnoType<XFormOperations>::get(), + PropertyAttribute::READONLY); +} + + +::cppu::IPropertyArrayHelper& FormController::getInfoHelper() +{ + return *getArrayHelper(); +} + +// XFilterController + +void SAL_CALL FormController::addFilterControllerListener( const Reference< XFilterControllerListener >& Listener ) +{ + m_aFilterListeners.addInterface( Listener ); +} + + +void SAL_CALL FormController::removeFilterControllerListener( const Reference< XFilterControllerListener >& Listener ) +{ + m_aFilterListeners.removeInterface( Listener ); +} + + +::sal_Int32 SAL_CALL FormController::getFilterComponents() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + return m_aFilterComponents.size(); +} + + +::sal_Int32 SAL_CALL FormController::getDisjunctiveTerms() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + return m_aFilterRows.size(); +} + + +void SAL_CALL FormController::setPredicateExpression( ::sal_Int32 Component, ::sal_Int32 Term, const OUString& PredicateExpression ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + if ( ( Component < 0 ) || ( Component >= getFilterComponents() ) || ( Term < 0 ) || ( Term >= getDisjunctiveTerms() ) ) + throw IndexOutOfBoundsException( OUString(), *this ); + + Reference< XTextComponent > xText( m_aFilterComponents[ Component ] ); + xText->setText( PredicateExpression ); + + FmFilterRow& rFilterRow = m_aFilterRows[ Term ]; + if ( !PredicateExpression.isEmpty() ) + rFilterRow[ xText ] = PredicateExpression; + else + rFilterRow.erase( xText ); +} + + +Reference< XControl > FormController::getFilterComponent( ::sal_Int32 Component ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + if ( ( Component < 0 ) || ( Component >= getFilterComponents() ) ) + throw IndexOutOfBoundsException( OUString(), *this ); + + return Reference< XControl >( m_aFilterComponents[ Component ], UNO_QUERY ); +} + + +Sequence< Sequence< OUString > > FormController::getPredicateExpressions() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + Sequence< Sequence< OUString > > aExpressions( m_aFilterRows.size() ); + auto aExpressionsRange = asNonConstRange(aExpressions); + sal_Int32 termIndex = 0; + for (const FmFilterRow& rRow : m_aFilterRows) + { + Sequence< OUString > aConjunction( m_aFilterComponents.size() ); + auto aConjunctionRange = asNonConstRange(aConjunction); + sal_Int32 componentIndex = 0; + for (const auto& rComp : m_aFilterComponents) + { + FmFilterRow::const_iterator predicate = rRow.find( rComp ); + if ( predicate != rRow.end() ) + aConjunctionRange[ componentIndex ] = predicate->second; + ++componentIndex; + } + + aExpressionsRange[ termIndex ] = aConjunction; + ++termIndex; + } + + return aExpressions; +} + + +void SAL_CALL FormController::removeDisjunctiveTerm( ::sal_Int32 Term ) +{ + // SYNCHRONIZED --> + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + if ( ( Term < 0 ) || ( Term >= getDisjunctiveTerms() ) ) + throw IndexOutOfBoundsException( OUString(), *this ); + + // if the to-be-deleted row is our current row, we need to shift + if ( Term == m_nCurrentFilterPosition ) + { + if ( m_nCurrentFilterPosition < sal_Int32( m_aFilterRows.size() - 1 ) ) + ++m_nCurrentFilterPosition; + else + --m_nCurrentFilterPosition; + } + + FmFilterRows::iterator pos = m_aFilterRows.begin() + Term; + m_aFilterRows.erase( pos ); + + // adjust m_nCurrentFilterPosition if the removed row preceded it + if ( Term < m_nCurrentFilterPosition ) + --m_nCurrentFilterPosition; + + SAL_WARN_IF( !( ( m_nCurrentFilterPosition < 0 ) != ( m_aFilterRows.empty() ) ), + "svx.form", "FormController::removeDisjunctiveTerm: inconsistency!" ); + + // update the texts in the filter controls + impl_setTextOnAllFilter_throw(); + + FilterEvent aEvent; + aEvent.Source = *this; + aEvent.DisjunctiveTerm = Term; + aGuard.clear(); + // <-- SYNCHRONIZED + + m_aFilterListeners.notifyEach( &XFilterControllerListener::disjunctiveTermRemoved, aEvent ); +} + + +void SAL_CALL FormController::appendEmptyDisjunctiveTerm() +{ + // SYNCHRONIZED --> + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + impl_appendEmptyFilterRow( aGuard ); + // <-- SYNCHRONIZED +} + + +::sal_Int32 SAL_CALL FormController::getActiveTerm() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + return m_nCurrentFilterPosition; +} + + +void SAL_CALL FormController::setActiveTerm( ::sal_Int32 ActiveTerm ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + if ( ( ActiveTerm < 0 ) || ( ActiveTerm >= getDisjunctiveTerms() ) ) + throw IndexOutOfBoundsException( OUString(), *this ); + + if ( ActiveTerm == getActiveTerm() ) + return; + + m_nCurrentFilterPosition = ActiveTerm; + impl_setTextOnAllFilter_throw(); +} + +// XElementAccess + +sal_Bool SAL_CALL FormController::hasElements() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return !m_aChildren.empty(); +} + + +Type SAL_CALL FormController::getElementType() +{ + return cppu::UnoType<XFormController>::get(); + +} + +// XEnumerationAccess + +Reference< XEnumeration > SAL_CALL FormController::createEnumeration() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return new ::comphelper::OEnumerationByIndex(this); +} + +// XIndexAccess + +sal_Int32 SAL_CALL FormController::getCount() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return m_aChildren.size(); +} + + +Any SAL_CALL FormController::getByIndex(sal_Int32 Index) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + if (Index < 0 || + o3tl::make_unsigned(Index) >= m_aChildren.size()) + throw IndexOutOfBoundsException(); + + return Any( m_aChildren[ Index ] ); +} + +// EventListener + +void SAL_CALL FormController::disposing(const EventObject& e) +{ + // has the container been disposed + ::osl::MutexGuard aGuard( m_aMutex ); + Reference< XControlContainer > xContainer(e.Source, UNO_QUERY); + if (xContainer.is()) + { + setContainer(Reference< XControlContainer > ()); + } + else + { + // has a control been disposed + Reference< XControl > xControl(e.Source, UNO_QUERY); + if (xControl.is()) + { + if (getContainer().is()) + removeControl(xControl); + } + } +} + +// OComponentHelper + +void FormController::disposeAllFeaturesAndDispatchers() +{ + for (auto& rDispatcher : m_aFeatureDispatchers) + { + try + { + ::comphelper::disposeComponent( rDispatcher.second ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + m_aFeatureDispatchers.clear(); +} + + +void FormController::disposing() +{ + EventObject aEvt( *this ); + + // if we're still active, simulate a "deactivated" event + if ( m_xActiveControl.is() ) + m_aActivateListeners.notifyEach( &XFormControllerListener::formDeactivated, aEvt ); + + // notify all our listeners + m_aActivateListeners.disposeAndClear(aEvt); + m_aModifyListeners.disposeAndClear(aEvt); + m_aErrorListeners.disposeAndClear(aEvt); + m_aDeleteListeners.disposeAndClear(aEvt); + m_aRowSetApproveListeners.disposeAndClear(aEvt); + m_aParameterListeners.disposeAndClear(aEvt); + m_aFilterListeners.disposeAndClear(aEvt); + + removeBoundFieldListener(); + stopFiltering(); + + m_aControlBorderManager.restoreAll(); + + m_aFilterRows.clear(); + + ::osl::MutexGuard aGuard( m_aMutex ); + m_xActiveControl = nullptr; + implSetCurrentControl( nullptr ); + + // clean up our children + for (const auto& rpChild : m_aChildren) + { + // search the position of the model within the form + Reference< XFormComponent > xForm(rpChild->getModel(), UNO_QUERY); + sal_uInt32 nPos = m_xModelAsIndex->getCount(); + Reference< XFormComponent > xTemp; + for( ; nPos; ) + { + + m_xModelAsIndex->getByIndex( --nPos ) >>= xTemp; + if ( xForm.get() == xTemp.get() ) + { + Reference< XInterface > xIfc( rpChild, UNO_QUERY ); + m_xModelAsManager->detach( nPos, xIfc ); + break; + } + } + + Reference< XComponent > (rpChild, UNO_QUERY_THROW)->dispose(); + } + m_aChildren.clear(); + + disposeAllFeaturesAndDispatchers(); + + if ( m_xFormOperations.is() ) + m_xFormOperations->dispose(); + m_xFormOperations.clear(); + + if (m_bDBConnection) + unload(); + + setContainer( nullptr ); + setModel( nullptr ); + setParent( nullptr ); + + ::comphelper::disposeComponent( m_xComposer ); + + m_bDBConnection = false; +} + + +namespace +{ + bool lcl_shouldUseDynamicControlBorder( const Reference< XInterface >& _rxForm, const Any& _rDynamicColorProp ) + { + bool bDoUse = false; + if ( !( _rDynamicColorProp >>= bDoUse ) ) + { + DocumentType eDocType = DocumentClassification::classifyHostDocument( _rxForm ); + return ControlLayouter::useDynamicBorderColor( eDocType ); + } + return bDoUse; + } +} + + +void SAL_CALL FormController::propertyChange(const PropertyChangeEvent& evt) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + if ( evt.PropertyName == FM_PROP_BOUNDFIELD ) + { + Reference<XPropertySet> xOldBound; + evt.OldValue >>= xOldBound; + if ( !xOldBound.is() && evt.NewValue.hasValue() ) + { + Reference< XControlModel > xControlModel(evt.Source,UNO_QUERY); + Reference< XControl > xControl = findControl(m_aControls,xControlModel,false,false); + if ( xControl.is() ) + { + startControlModifyListening( xControl ); + Reference<XPropertySet> xProp(xControlModel,UNO_QUERY); + if ( xProp.is() ) + xProp->removePropertyChangeListener(FM_PROP_BOUNDFIELD, this); + } + } + } + else + { + bool bModifiedChanged = (evt.PropertyName == FM_PROP_ISMODIFIED); + bool bNewChanged = (evt.PropertyName == FM_PROP_ISNEW); + if (bModifiedChanged || bNewChanged) + { + ::osl::MutexGuard aGuard( m_aMutex ); + if (bModifiedChanged) + m_bCurrentRecordModified = ::comphelper::getBOOL(evt.NewValue); + else + m_bCurrentRecordNew = ::comphelper::getBOOL(evt.NewValue); + + // toggle the locking + if (m_bLocked != determineLockState()) + { + m_bLocked = !m_bLocked; + setLocks(); + if (isListeningForChanges()) + startListening(); + else + stopListening(); + } + + if ( bNewChanged ) + m_aToggleEvent.Call(); + + if (!m_bCurrentRecordModified) + m_bModified = false; + } + else if ( evt.PropertyName == FM_PROP_DYNAMIC_CONTROL_BORDER ) + { + bool bEnable = lcl_shouldUseDynamicControlBorder( evt.Source, evt.NewValue ); + if ( bEnable ) + { + m_aControlBorderManager.enableDynamicBorderColor(); + if ( m_xActiveControl.is() ) + m_aControlBorderManager.focusGained( m_xActiveControl ); + } + else + { + m_aControlBorderManager.disableDynamicBorderColor(); + } + } + } +} + + +bool FormController::replaceControl( const Reference< XControl >& _rxExistentControl, const Reference< XControl >& _rxNewControl ) +{ + bool bSuccess = false; + try + { + Reference< XIdentifierReplace > xContainer( getContainer(), UNO_QUERY ); + DBG_ASSERT( xContainer.is(), "FormController::replaceControl: yes, it's not required by the service description, but XIdentifierReplace would be nice!" ); + if ( xContainer.is() ) + { + // look up the ID of _rxExistentControl + const Sequence< sal_Int32 > aIdentifiers( xContainer->getIdentifiers() ); + const sal_Int32* pIdentifiers = std::find_if(aIdentifiers.begin(), aIdentifiers.end(), + [&xContainer, &_rxExistentControl](const sal_Int32 nId) { + Reference< XControl > xCheck( xContainer->getByIdentifier( nId ), UNO_QUERY ); + return xCheck == _rxExistentControl; + }); + DBG_ASSERT( pIdentifiers != aIdentifiers.end(), "FormController::replaceControl: did not find the control in the container!" ); + if ( pIdentifiers != aIdentifiers.end() ) + { + bool bReplacedWasActive = ( m_xActiveControl.get() == _rxExistentControl.get() ); + bool bReplacedWasCurrent = ( m_xCurrentControl.get() == _rxExistentControl.get() ); + + if ( bReplacedWasActive ) + { + m_xActiveControl = nullptr; + implSetCurrentControl( nullptr ); + } + else if ( bReplacedWasCurrent ) + { + implSetCurrentControl( _rxNewControl ); + } + + // carry over the model + _rxNewControl->setModel( _rxExistentControl->getModel() ); + + xContainer->replaceByIdentifer( *pIdentifiers, Any( _rxNewControl ) ); + bSuccess = true; + + if ( bReplacedWasActive ) + { + Reference< XWindow > xControlWindow( _rxNewControl, UNO_QUERY ); + if ( xControlWindow.is() ) + xControlWindow->setFocus(); + } + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + Reference< XControl > xDisposeIt( bSuccess ? _rxExistentControl : _rxNewControl ); + ::comphelper::disposeComponent( xDisposeIt ); + return bSuccess; +} + + +void FormController::toggleAutoFields(bool bAutoFields) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + + Sequence< Reference< XControl > > aControlsCopy( m_aControls ); + const Reference< XControl >* pControls = aControlsCopy.getConstArray(); + sal_Int32 nControls = aControlsCopy.getLength(); + + if (bAutoFields) + { + // as we don't want new controls to be attached to the scripting environment + // we change attach flags + m_bAttachEvents = false; + for (sal_Int32 i = nControls; i > 0;) + { + Reference< XControl > xControl = pControls[--i]; + if (xControl.is()) + { + Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY); + if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet)) + { + // does the model use a bound field ? + Reference< XPropertySet > xField; + xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + + // is it an autofield? + if ( xField.is() + && ::comphelper::hasProperty( FM_PROP_AUTOINCREMENT, xField ) + && ::comphelper::getBOOL( xField->getPropertyValue( FM_PROP_AUTOINCREMENT ) ) + ) + { + replaceControl( xControl, new FmXAutoControl() ); + } + } + } + } + m_bAttachEvents = true; + } + else + { + m_bDetachEvents = false; + for (sal_Int32 i = nControls; i > 0;) + { + Reference< XControl > xControl = pControls[--i]; + if (xControl.is()) + { + Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY); + if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet)) + { + // does the model use a bound field ? + Reference< XPropertySet > xField; + xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + + // is it an autofield? + if ( xField.is() + && ::comphelper::hasProperty( FM_PROP_AUTOINCREMENT, xField ) + && ::comphelper::getBOOL( xField->getPropertyValue(FM_PROP_AUTOINCREMENT ) ) + ) + { + OUString sServiceName; + OSL_VERIFY( xSet->getPropertyValue( FM_PROP_DEFAULTCONTROL ) >>= sServiceName ); + Reference< XControl > xNewControl( m_xComponentContext->getServiceManager()->createInstanceWithContext( sServiceName, m_xComponentContext ), UNO_QUERY ); + replaceControl( xControl, xNewControl ); + } + } + } + } + m_bDetachEvents = true; + } +} + + +IMPL_LINK_NOARG(FormController, OnToggleAutoFields, void*, void) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + toggleAutoFields(m_bCurrentRecordNew); +} + +// XTextListener +void SAL_CALL FormController::textChanged(const TextEvent& e) +{ + // SYNCHRONIZED --> + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + if ( !m_bFiltering ) + { + impl_onModify(); + return; + } + + if ( m_bSuspendFilterTextListening ) + return; + + Reference< XTextComponent > xText(e.Source,UNO_QUERY); + OUString aText = xText->getText(); + + if ( m_aFilterRows.empty() ) + appendEmptyDisjunctiveTerm(); + + // find the current row + if ( ( m_nCurrentFilterPosition < 0 ) || ( o3tl::make_unsigned(m_nCurrentFilterPosition) >= m_aFilterRows.size() ) ) + { + OSL_ENSURE( false, "FormController::textChanged: m_nCurrentFilterPosition is wrong!" ); + return; + } + + FmFilterRow& rRow = m_aFilterRows[ m_nCurrentFilterPosition ]; + + // do we have a new filter + if (!aText.isEmpty()) + rRow[xText] = aText; + else + { + // do we have the control in the row + FmFilterRow::iterator iter = rRow.find(xText); + // erase the entry out of the row + if (iter != rRow.end()) + rRow.erase(iter); + } + + // multiplex the event to our FilterControllerListeners + FilterEvent aEvent; + aEvent.Source = *this; + aEvent.FilterComponent = ::std::find( m_aFilterComponents.begin(), m_aFilterComponents.end(), xText ) - m_aFilterComponents.begin(); + aEvent.DisjunctiveTerm = getActiveTerm(); + aEvent.PredicateExpression = aText; + + aGuard.clear(); + // <-- SYNCHRONIZED + + // notify the changed filter expression + m_aFilterListeners.notifyEach( &XFilterControllerListener::predicateExpressionChanged, aEvent ); +} + +// XItemListener +void SAL_CALL FormController::itemStateChanged(const ItemEvent& /*rEvent*/) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + impl_onModify(); +} + +// XModificationBroadcaster +void SAL_CALL FormController::addModifyListener(const Reference< XModifyListener > & l) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + m_aModifyListeners.addInterface( l ); +} + +void FormController::removeModifyListener(const Reference< XModifyListener > & l) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + m_aModifyListeners.removeInterface( l ); +} + +// XModificationListener +void FormController::modified( const EventObject& _rEvent ) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + try + { + if ( _rEvent.Source != m_xActiveControl ) + { // let this control grab the focus + // (this case may happen if somebody moves the scroll wheel of the mouse over a control + // which does not have the focus) + // 85511 - 29.05.2001 - frank.schoenheit@germany.sun.com + + // also, it happens when an image control gets a new image by double-clicking it + // #i88458# / 2009-01-12 / frank.schoenheit@sun.com + Reference< XWindow > xControlWindow( _rEvent.Source, UNO_QUERY_THROW ); + xControlWindow->setFocus(); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + impl_onModify(); +} + +void FormController::impl_checkDisposed_throw() const +{ + if ( impl_isDisposed_nofail() ) + throw DisposedException( OUString(), *const_cast< FormController* >( this ) ); +} + +void FormController::impl_onModify() +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + { + ::osl::MutexGuard aGuard( m_aMutex ); + if ( !m_bModified ) + m_bModified = true; + } + + EventObject aEvt(static_cast<cppu::OWeakObject*>(this)); + m_aModifyListeners.notifyEach( &XModifyListener::modified, aEvt ); +} + +void FormController::impl_addFilterRow( const FmFilterRow& _row ) +{ + m_aFilterRows.push_back( _row ); + + if ( m_aFilterRows.size() == 1 ) + { // that's the first row ever + OSL_ENSURE( m_nCurrentFilterPosition == -1, "FormController::impl_addFilterRow: inconsistency!" ); + m_nCurrentFilterPosition = 0; + } +} + +void FormController::impl_appendEmptyFilterRow( ::osl::ClearableMutexGuard& _rClearBeforeNotify ) +{ + // SYNCHRONIZED --> + impl_addFilterRow( FmFilterRow() ); + + // notify the listeners + FilterEvent aEvent; + aEvent.Source = *this; + aEvent.DisjunctiveTerm = static_cast<sal_Int32>(m_aFilterRows.size()) - 1; + _rClearBeforeNotify.clear(); + // <-- SYNCHRONIZED + m_aFilterListeners.notifyEach( &XFilterControllerListener::disjunctiveTermAdded, aEvent ); +} + +bool FormController::determineLockState() const +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + // a.) in filter mode we are always locked + // b.) if we have no valid model or our model (a result set) is not alive -> we're locked + // c.) if we are inserting everything is OK and we are not locked + // d.) if are not updatable or on invalid position + Reference< XResultSet > xResultSet(m_xModelAsIndex, UNO_QUERY); + if (m_bFiltering || !xResultSet.is() || !isRowSetAlive(xResultSet)) + return true; + else + return !(m_bCanInsert && m_bCurrentRecordNew) + && (xResultSet->isBeforeFirst() || xResultSet->isAfterLast() || xResultSet->rowDeleted() || !m_bCanUpdate); +} + +// FocusListener +void FormController::focusGained(const FocusEvent& e) +{ + // SYNCHRONIZED --> + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aControlBorderManager.focusGained( e.Source ); + + Reference< XControl > xControl(e.Source, UNO_QUERY); + if (m_bDBConnection) + { + // do we need to keep the locking of the commit + // we hold the lock as long as the control differs from the current + // otherwise we disabled the lock + m_bCommitLock = m_bCommitLock && xControl.get() != m_xCurrentControl.get(); + if (m_bCommitLock) + return; + + // when do we have to commit a value to form or a filter + // a.) if the current value is modified + // b.) there must be a current control + // c.) and it must be different from the new focus owning control or + // d.) the focus is moving around (so we have only one control) + + if ( ( m_bModified || m_bFiltering ) + && m_xCurrentControl.is() + && ( ( xControl.get() != m_xCurrentControl.get() ) + || ( ( e.FocusFlags & FocusChangeReason::AROUND ) + && ( m_bCycle || m_bFiltering ) + ) + ) + ) + { + // check the old control if the content is ok +#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG + Reference< XBoundControl > xLockingTest(m_xCurrentControl, UNO_QUERY); + bool bControlIsLocked = xLockingTest.is() && xLockingTest->getLock(); + assert(!bControlIsLocked && "FormController::Gained: I'm modified and the current control is locked ? How this ?"); + // normally, a locked control should not be modified, so probably my bModified must + // have been set from a different context, which I would not understand ... +#endif + DBG_ASSERT(m_xCurrentControl.is(), "no CurrentControl set"); + // first the control ask if it supports the IFace + Reference< XBoundComponent > xBound(m_xCurrentControl, UNO_QUERY); + if (!xBound.is() && m_xCurrentControl.is()) + xBound.set(m_xCurrentControl->getModel(), UNO_QUERY); + + // lock if we lose the focus during commit + m_bCommitLock = true; + + // commit unsuccessful, reset focus + if (xBound.is() && !xBound->commit()) + { + // the commit failed and we don't commit again until the current control + // which couldn't be commit gains the focus again + Reference< XWindow > xWindow(m_xCurrentControl, UNO_QUERY); + if (xWindow.is()) + xWindow->setFocus(); + return; + } + else + { + m_bModified = false; + m_bCommitLock = false; + } + } + + if (!m_bFiltering && m_bCycle && (e.FocusFlags & FocusChangeReason::AROUND) && m_xCurrentControl.is()) + { + OSL_ENSURE( m_xFormOperations.is(), "FormController::focusGained: hmm?" ); + // should have been created in setModel + try + { + if ( e.FocusFlags & FocusChangeReason::FORWARD ) + { + if ( m_xFormOperations.is() && m_xFormOperations->isEnabled( FormFeature::MoveToNext ) ) + m_xFormOperations->execute( FormFeature::MoveToNext ); + } + else // backward + { + if ( m_xFormOperations.is() && m_xFormOperations->isEnabled( FormFeature::MoveToPrevious ) ) + m_xFormOperations->execute( FormFeature::MoveToPrevious ); + } + } + catch ( const Exception& ) + { + // don't handle this any further. That's an ... admissible error. + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + + // still one and the same control + if ( ( m_xActiveControl == xControl ) + && ( xControl == m_xCurrentControl ) + ) + { + DBG_ASSERT(m_xCurrentControl.is(), "No CurrentControl selected"); + return; + } + + bool bActivated = !m_xActiveControl.is() && xControl.is(); + + m_xActiveControl = xControl; + + implSetCurrentControl( xControl ); + SAL_WARN_IF( !m_xCurrentControl.is(), "svx.form", "implSetCurrentControl did nonsense!" ); + + if ( bActivated ) + { + // (asynchronously) call activation handlers + m_aActivationEvent.Call(); + + // call modify listeners + if ( m_bModified ) + m_aModifyListeners.notifyEach( &XModifyListener::modified, EventObject( *this ) ); + } + + // invalidate all features which depend on the currently focused control + if ( m_bDBConnection && !m_bFiltering ) + implInvalidateCurrentControlDependentFeatures(); + + if ( !m_xCurrentControl.is() ) + return; + + // control gets focus, then possibly in the visible range + Reference< XFormControllerContext > xContext( m_xFormControllerContext ); + Reference< XControl > xCurrentControl( m_xCurrentControl ); + aGuard.clear(); + // <-- SYNCHRONIZED + + if ( xContext.is() ) + xContext->makeVisible( xCurrentControl ); +} + +IMPL_LINK_NOARG( FormController, OnActivated, void*, void ) +{ + EventObject aEvent; + aEvent.Source = *this; + m_aActivateListeners.notifyEach( &XFormControllerListener::formActivated, aEvent ); +} + +IMPL_LINK_NOARG( FormController, OnDeactivated, void*, void ) +{ + EventObject aEvent; + aEvent.Source = *this; + m_aActivateListeners.notifyEach( &XFormControllerListener::formDeactivated, aEvent ); +} + +void FormController::focusLost(const FocusEvent& e) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + m_aControlBorderManager.focusLost( e.Source ); + + Reference< XWindowPeer > xNext(e.NextFocus, UNO_QUERY); + // if focus hasn't passed to some other window, e.g. focus in a welded item, don't deactivate + if (!xNext) + return; + Reference< XControl > xNextControl = isInList(xNext); + if (!xNextControl.is()) + { + m_xActiveControl = nullptr; + m_aDeactivationEvent.Call(); + } +} + +void SAL_CALL FormController::mousePressed( const awt::MouseEvent& /*_rEvent*/ ) +{ + // not interested in +} + +void SAL_CALL FormController::mouseReleased( const awt::MouseEvent& /*_rEvent*/ ) +{ + // not interested in +} + +void SAL_CALL FormController::mouseEntered( const awt::MouseEvent& _rEvent ) +{ + m_aControlBorderManager.mouseEntered( _rEvent.Source ); +} + +void SAL_CALL FormController::mouseExited( const awt::MouseEvent& _rEvent ) +{ + m_aControlBorderManager.mouseExited( _rEvent.Source ); +} + +void SAL_CALL FormController::componentValidityChanged( const EventObject& _rSource ) +{ + Reference< XControl > xControl( findControl( m_aControls, Reference< XControlModel >( _rSource.Source, UNO_QUERY ), false, false ) ); + Reference< XValidatableFormComponent > xValidatable( _rSource.Source, UNO_QUERY ); + + OSL_ENSURE( xControl.is() && xValidatable.is(), "FormController::componentValidityChanged: huh?" ); + + if ( xControl.is() && xValidatable.is() ) + m_aControlBorderManager.validityChanged( xControl, xValidatable ); +} + + +void FormController::setModel(const Reference< XTabControllerModel > & Model) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + DBG_ASSERT(m_xTabController.is(), "FormController::setModel : invalid aggregate !"); + + try + { + // disconnect from the old model + if (m_xModelAsIndex.is()) + { + if (m_bDBConnection) + { + // we are currently working on the model + EventObject aEvt(m_xModelAsIndex); + unloaded(aEvt); + } + + Reference< XLoadable > xForm(m_xModelAsIndex, UNO_QUERY); + if (xForm.is()) + xForm->removeLoadListener(this); + + Reference< XSQLErrorBroadcaster > xBroadcaster(m_xModelAsIndex, UNO_QUERY); + if (xBroadcaster.is()) + xBroadcaster->removeSQLErrorListener(this); + + Reference< XDatabaseParameterBroadcaster > xParamBroadcaster(m_xModelAsIndex, UNO_QUERY); + if (xParamBroadcaster.is()) + xParamBroadcaster->removeParameterListener(this); + + } + + disposeAllFeaturesAndDispatchers(); + + if ( m_xFormOperations.is() ) + m_xFormOperations->dispose(); + m_xFormOperations.clear(); + + // set the new model wait for the load event + if (m_xTabController.is()) + m_xTabController->setModel(Model); + m_xModelAsIndex.set(Model, UNO_QUERY); + m_xModelAsManager.set(Model, UNO_QUERY); + + // only if both ifaces exit, the controller will work successful + if (!m_xModelAsIndex.is() || !m_xModelAsManager.is()) + { + m_xModelAsManager = nullptr; + m_xModelAsIndex = nullptr; + } + + if (m_xModelAsIndex.is()) + { + // re-create m_xFormOperations + m_xFormOperations = FormOperations::createWithFormController( m_xComponentContext, this ); + m_xFormOperations->setFeatureInvalidation( this ); + + // adding load and ui interaction listeners + Reference< XLoadable > xForm(Model, UNO_QUERY); + if (xForm.is()) + xForm->addLoadListener(this); + + Reference< XSQLErrorBroadcaster > xBroadcaster(Model, UNO_QUERY); + if (xBroadcaster.is()) + xBroadcaster->addSQLErrorListener(this); + + Reference< XDatabaseParameterBroadcaster > xParamBroadcaster(Model, UNO_QUERY); + if (xParamBroadcaster.is()) + xParamBroadcaster->addParameterListener(this); + + // well, is the database already loaded? + // then we have to simulate a load event + Reference< XLoadable > xCursor(m_xModelAsIndex, UNO_QUERY); + if (xCursor.is() && xCursor->isLoaded()) + { + EventObject aEvt(xCursor); + loaded(aEvt); + } + + Reference< XPropertySet > xModelProps( m_xModelAsIndex, UNO_QUERY ); + Reference< XPropertySetInfo > xPropInfo( xModelProps->getPropertySetInfo() ); + if ( xPropInfo.is() + && xPropInfo->hasPropertyByName( FM_PROP_DYNAMIC_CONTROL_BORDER ) + && xPropInfo->hasPropertyByName( FM_PROP_CONTROL_BORDER_COLOR_FOCUS ) + && xPropInfo->hasPropertyByName( FM_PROP_CONTROL_BORDER_COLOR_MOUSE ) + && xPropInfo->hasPropertyByName( FM_PROP_CONTROL_BORDER_COLOR_INVALID ) + ) + { + bool bEnableDynamicControlBorder = lcl_shouldUseDynamicControlBorder( + xModelProps, xModelProps->getPropertyValue( FM_PROP_DYNAMIC_CONTROL_BORDER ) ); + if ( bEnableDynamicControlBorder ) + m_aControlBorderManager.enableDynamicBorderColor(); + else + m_aControlBorderManager.disableDynamicBorderColor(); + + Color nColor; + if ( xModelProps->getPropertyValue( FM_PROP_CONTROL_BORDER_COLOR_FOCUS ) >>= nColor ) + m_aControlBorderManager.setStatusColor( ControlStatus::Focused, nColor ); + if ( xModelProps->getPropertyValue( FM_PROP_CONTROL_BORDER_COLOR_MOUSE ) >>= nColor ) + m_aControlBorderManager.setStatusColor( ControlStatus::MouseHover, nColor ); + if ( xModelProps->getPropertyValue( FM_PROP_CONTROL_BORDER_COLOR_INVALID ) >>= nColor ) + m_aControlBorderManager.setStatusColor( ControlStatus::Invalid, nColor ); + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +Reference< XTabControllerModel > FormController::getModel() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + DBG_ASSERT(m_xTabController.is(), "FormController::getModel : invalid aggregate !"); + if (!m_xTabController.is()) + return Reference< XTabControllerModel > (); + return m_xTabController->getModel(); +} + + +void FormController::addToEventAttacher(const Reference< XControl > & xControl) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + OSL_ENSURE( xControl.is(), "FormController::addToEventAttacher: invalid control - how did you reach this?" ); + if ( !xControl.is() ) + return; /* throw IllegalArgumentException(); */ + + // register at the event attacher + Reference< XFormComponent > xComp(xControl->getModel(), UNO_QUERY); + if (!(xComp.is() && m_xModelAsIndex.is())) + return; + + // and look for the position of the ControlModel in it + sal_uInt32 nPos = m_xModelAsIndex->getCount(); + Reference< XFormComponent > xTemp; + for( ; nPos; ) + { + m_xModelAsIndex->getByIndex(--nPos) >>= xTemp; + if (xComp.get() == xTemp.get()) + { + m_xModelAsManager->attach( nPos, Reference<XInterface>( xControl, UNO_QUERY ), Any(xControl) ); + break; + } + } +} + + +void FormController::removeFromEventAttacher(const Reference< XControl > & xControl) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + OSL_ENSURE( xControl.is(), "FormController::removeFromEventAttacher: invalid control - how did you reach this?" ); + if ( !xControl.is() ) + return; /* throw IllegalArgumentException(); */ + + // register at the event attacher + Reference< XFormComponent > xComp(xControl->getModel(), UNO_QUERY); + if ( !(xComp.is() && m_xModelAsIndex.is()) ) + return; + + // and look for the position of the ControlModel in it + sal_uInt32 nPos = m_xModelAsIndex->getCount(); + Reference< XFormComponent > xTemp; + for( ; nPos; ) + { + m_xModelAsIndex->getByIndex(--nPos) >>= xTemp; + if (xComp.get() == xTemp.get()) + { + m_xModelAsManager->detach( nPos, Reference<XInterface>( xControl, UNO_QUERY ) ); + break; + } + } +} + + +void FormController::setContainer(const Reference< XControlContainer > & xContainer) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + Reference< XTabControllerModel > xTabModel(getModel()); + DBG_ASSERT(xTabModel.is() || !xContainer.is(), "No Model defined"); + // if we have a new container we need a model + DBG_ASSERT(m_xTabController.is(), "FormController::setContainer : invalid aggregate !"); + + ::osl::MutexGuard aGuard( m_aMutex ); + Reference< XContainer > xCurrentContainer; + if (m_xTabController.is()) + xCurrentContainer.set(m_xTabController->getContainer(), UNO_QUERY); + if (xCurrentContainer.is()) + { + xCurrentContainer->removeContainerListener(this); + + if ( m_aTabActivationIdle.IsActive() ) + m_aTabActivationIdle.Stop(); + + // clear the filter map + ::std::for_each( m_aFilterComponents.begin(), m_aFilterComponents.end(), RemoveComponentTextListener( this ) ); + m_aFilterComponents.clear(); + + // collecting the controls + for ( const Reference< XControl >& rControl : std::as_const(m_aControls) ) + implControlRemoved( rControl, true ); + + // make database-specific things + if (m_bDBConnection && isListeningForChanges()) + stopListening(); + + m_aControls.realloc( 0 ); + } + + if (m_xTabController.is()) + m_xTabController->setContainer(xContainer); + + // What controls belong to the container? + if (xContainer.is() && xTabModel.is()) + { + const Sequence< Reference< XControlModel > > aModels = xTabModel->getControlModels(); + Sequence< Reference< XControl > > aAllControls = xContainer->getControls(); + + sal_Int32 nCount = aModels.getLength(); + m_aControls = Sequence< Reference< XControl > >( nCount ); + Reference< XControl > * pControls = m_aControls.getArray(); + + // collecting the controls + sal_Int32 j = 0; + for (const Reference< XControlModel >& rModel : aModels ) + { + Reference< XControl > xControl = findControl( aAllControls, rModel, false, true ); + if ( xControl.is() ) + { + pControls[j++] = xControl; + implControlInserted( xControl, true ); + } + } + + // not every model had an associated control + if (j != nCount) + m_aControls.realloc(j); + + // listen at the container + Reference< XContainer > xNewContainer(xContainer, UNO_QUERY); + if (xNewContainer.is()) + xNewContainer->addContainerListener(this); + + // make database-specific things + if (m_bDBConnection) + { + m_bLocked = determineLockState(); + setLocks(); + if (!isLocked()) + startListening(); + } + } + // the controls are in the right order + m_bControlsSorted = true; +} + + +Reference< XControlContainer > FormController::getContainer() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + DBG_ASSERT(m_xTabController.is(), "FormController::getContainer : invalid aggregate !"); + if (!m_xTabController.is()) + return Reference< XControlContainer > (); + return m_xTabController->getContainer(); +} + + +Sequence< Reference< XControl > > FormController::getControls() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + if (!m_bControlsSorted) + { + Reference< XTabControllerModel > xModel = getModel(); + if (!xModel.is()) + return m_aControls; + + const Sequence< Reference< XControlModel > > aControlModels = xModel->getControlModels(); + sal_Int32 nModels = aControlModels.getLength(); + + Sequence< Reference< XControl > > aNewControls(nModels); + + Reference< XControl > * pControls = aNewControls.getArray(); + Reference< XControl > xControl; + + // rearrange the controls according to the tab order sequence + sal_Int32 j = 0; + for ( const Reference< XControlModel >& rModel : aControlModels ) + { + xControl = findControl( m_aControls, rModel, true, true ); + if ( xControl.is() ) + pControls[j++] = xControl; + } + + // not every model had an associated control + if ( j != nModels ) + aNewControls.realloc( j ); + + m_aControls = aNewControls; + m_bControlsSorted = true; + } + return m_aControls; +} + + +void FormController::autoTabOrder() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + DBG_ASSERT(m_xTabController.is(), "FormController::autoTabOrder : invalid aggregate !"); + if (m_xTabController.is()) + m_xTabController->autoTabOrder(); +} + + +void FormController::activateTabOrder() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + DBG_ASSERT(m_xTabController.is(), "FormController::activateTabOrder : invalid aggregate !"); + if (m_xTabController.is()) + m_xTabController->activateTabOrder(); +} + + +void FormController::setControlLock(const Reference< XControl > & xControl) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + bool bLocked = isLocked(); + + // It is locked + // a. if the entire record is locked + // b. if the associated field is locked + Reference< XBoundControl > xBound(xControl, UNO_QUERY); + if (!(xBound.is() && + ( (bLocked && bLocked != bool(xBound->getLock())) || + !bLocked))) // always uncheck individual fields when unlocking + return; + + // there is a data source + Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY); + if (!(xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))) + return; + + // what about the ReadOnly and Enable properties + bool bTouch = true; + if (::comphelper::hasProperty(FM_PROP_ENABLED, xSet)) + bTouch = ::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_ENABLED)); + if (::comphelper::hasProperty(FM_PROP_READONLY, xSet)) + bTouch = !::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_READONLY)); + + if (!bTouch) + return; + + Reference< XPropertySet > xField; + xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + if (!xField.is()) + return; + + if (bLocked) + xBound->setLock(bLocked); + else + { + try + { + Any aVal = xField->getPropertyValue(FM_PROP_ISREADONLY); + if (aVal.hasValue() && ::comphelper::getBOOL(aVal)) + xBound->setLock(true); + else + xBound->setLock(bLocked); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + } +} + + +void FormController::setLocks() +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + // lock/unlock all controls connected to a data source + for ( const Reference< XControl >& rControl : std::as_const(m_aControls) ) + setControlLock( rControl ); +} + + +namespace +{ + bool lcl_shouldListenForModifications( const Reference< XControl >& _rxControl, const Reference< XPropertyChangeListener >& _rxBoundFieldListener ) + { + bool bShould = false; + + Reference< XBoundComponent > xBound( _rxControl, UNO_QUERY ); + if ( xBound.is() ) + { + bShould = true; + } + else if ( _rxControl.is() ) + { + Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY ); + if ( xModelProps.is() && ::comphelper::hasProperty( FM_PROP_BOUNDFIELD, xModelProps ) ) + { + Reference< XPropertySet > xField; + xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ) >>= xField; + bShould = xField.is(); + + if ( !bShould && _rxBoundFieldListener.is() ) + xModelProps->addPropertyChangeListener( FM_PROP_BOUNDFIELD, _rxBoundFieldListener ); + } + } + + return bShould; + } +} + + +void FormController::startControlModifyListening(const Reference< XControl > & xControl) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + bool bModifyListening = lcl_shouldListenForModifications( xControl, this ); + + // artificial while + while ( bModifyListening ) + { + Reference< XModifyBroadcaster > xMod(xControl, UNO_QUERY); + if (xMod.is()) + { + xMod->addModifyListener(this); + break; + } + + // all the text to prematurely recognize a modified + Reference< XTextComponent > xText(xControl, UNO_QUERY); + if (xText.is()) + { + xText->addTextListener(this); + break; + } + + Reference< XCheckBox > xBox(xControl, UNO_QUERY); + if (xBox.is()) + { + xBox->addItemListener(this); + break; + } + + Reference< XComboBox > xCbBox(xControl, UNO_QUERY); + if (xCbBox.is()) + { + xCbBox->addItemListener(this); + break; + } + + Reference< XListBox > xListBox(xControl, UNO_QUERY); + if (xListBox.is()) + { + xListBox->addItemListener(this); + break; + } + break; + } +} + + +void FormController::stopControlModifyListening(const Reference< XControl > & xControl) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + bool bModifyListening = lcl_shouldListenForModifications( xControl, nullptr ); + + // artificial while + while (bModifyListening) + { + Reference< XModifyBroadcaster > xMod(xControl, UNO_QUERY); + if (xMod.is()) + { + xMod->removeModifyListener(this); + break; + } + // all the text to prematurely recognize a modified + Reference< XTextComponent > xText(xControl, UNO_QUERY); + if (xText.is()) + { + xText->removeTextListener(this); + break; + } + + Reference< XCheckBox > xBox(xControl, UNO_QUERY); + if (xBox.is()) + { + xBox->removeItemListener(this); + break; + } + + Reference< XComboBox > xCbBox(xControl, UNO_QUERY); + if (xCbBox.is()) + { + xCbBox->removeItemListener(this); + break; + } + + Reference< XListBox > xListBox(xControl, UNO_QUERY); + if (xListBox.is()) + { + xListBox->removeItemListener(this); + break; + } + break; + } +} + + +void FormController::startListening() +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + m_bModified = false; + + // now register at bound fields + for ( const Reference< XControl >& rControl : std::as_const(m_aControls) ) + startControlModifyListening( rControl ); +} + + +void FormController::stopListening() +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + m_bModified = false; + + // now register at bound fields + for ( const Reference< XControl >& rControl : std::as_const(m_aControls) ) + stopControlModifyListening( rControl ); +} + + +Reference< XControl > FormController::findControl(Sequence< Reference< XControl > >& _rControls, const Reference< XControlModel > & xCtrlModel ,bool _bRemove,bool _bOverWrite) const +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + DBG_ASSERT( xCtrlModel.is(), "findControl - which ?!" ); + + const Reference< XControl >* pControls = std::find_if(std::cbegin(_rControls), std::cend(_rControls), + [&xCtrlModel](const Reference< XControl >& rControl) { + return rControl.is() && rControl->getModel().get() == xCtrlModel.get(); }); + if (pControls != std::cend(_rControls)) + { + Reference< XControl > xControl( *pControls ); + auto i = static_cast<sal_Int32>(std::distance(std::cbegin(_rControls), pControls)); + if ( _bRemove ) + ::comphelper::removeElementAt( _rControls, i ); + else if ( _bOverWrite ) + _rControls.getArray()[i].clear(); + return xControl; + } + return Reference< XControl > (); +} + + +void FormController::implControlInserted( const Reference< XControl>& _rxControl, bool _bAddToEventAttacher ) +{ + Reference< XWindow > xWindow( _rxControl, UNO_QUERY ); + if ( xWindow.is() ) + { + xWindow->addFocusListener( this ); + xWindow->addMouseListener( this ); + + if ( _bAddToEventAttacher ) + addToEventAttacher( _rxControl ); + } + + // add a dispatch interceptor to the control (if supported) + Reference< XDispatchProviderInterception > xInterception( _rxControl, UNO_QUERY ); + if ( xInterception.is() ) + createInterceptor( xInterception ); + + if ( !_rxControl.is() ) + return; + + Reference< XControlModel > xModel( _rxControl->getModel() ); + + // we want to know about the reset of the model of our controls + // (for correctly resetting m_bModified) + Reference< XReset > xReset( xModel, UNO_QUERY ); + if ( xReset.is() ) + xReset->addResetListener( this ); + + // and we want to know about the validity, to visually indicate it + Reference< XValidatableFormComponent > xValidatable( xModel, UNO_QUERY ); + if ( xValidatable.is() ) + { + xValidatable->addFormComponentValidityListener( this ); + m_aControlBorderManager.validityChanged( _rxControl, xValidatable ); + } + +} + + +void FormController::implControlRemoved( const Reference< XControl>& _rxControl, bool _bRemoveFromEventAttacher ) +{ + Reference< XWindow > xWindow( _rxControl, UNO_QUERY ); + if ( xWindow.is() ) + { + xWindow->removeFocusListener( this ); + xWindow->removeMouseListener( this ); + + if ( _bRemoveFromEventAttacher ) + removeFromEventAttacher( _rxControl ); + } + + Reference< XDispatchProviderInterception > xInterception( _rxControl, UNO_QUERY); + if ( xInterception.is() ) + deleteInterceptor( xInterception ); + + if ( _rxControl.is() ) + { + Reference< XControlModel > xModel( _rxControl->getModel() ); + + Reference< XReset > xReset( xModel, UNO_QUERY ); + if ( xReset.is() ) + xReset->removeResetListener( this ); + + Reference< XValidatableFormComponent > xValidatable( xModel, UNO_QUERY ); + if ( xValidatable.is() ) + xValidatable->removeFormComponentValidityListener( this ); + } +} + + +void FormController::implSetCurrentControl( const Reference< XControl >& _rxControl ) +{ + if ( m_xCurrentControl.get() == _rxControl.get() ) + return; + + Reference< XGridControl > xGridControl( m_xCurrentControl, UNO_QUERY ); + if ( xGridControl.is() ) + xGridControl->removeGridControlListener( this ); + + m_xCurrentControl = _rxControl; + + xGridControl.set( m_xCurrentControl, UNO_QUERY ); + if ( xGridControl.is() ) + xGridControl->addGridControlListener( this ); +} + + +void FormController::insertControl(const Reference< XControl > & xControl) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + m_bControlsSorted = false; + m_aControls.realloc(m_aControls.getLength() + 1); + m_aControls.getArray()[m_aControls.getLength() - 1] = xControl; + + if (m_pColumnInfoCache) + m_pColumnInfoCache->deinitializeControls(); + + implControlInserted( xControl, m_bAttachEvents ); + + if (m_bDBConnection && !m_bFiltering) + setControlLock(xControl); + + if (isListeningForChanges() && m_bAttachEvents) + startControlModifyListening( xControl ); +} + + +void FormController::removeControl(const Reference< XControl > & xControl) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + auto pControl = std::find_if(std::cbegin(m_aControls), std::cend(m_aControls), + [&xControl](const Reference< XControl >& rControl) { return xControl.get() == rControl.get(); }); + if (pControl != std::cend(m_aControls)) + { + auto nIndex = static_cast<sal_Int32>(std::distance(std::cbegin(m_aControls), pControl)); + ::comphelper::removeElementAt( m_aControls, nIndex ); + } + + FilterComponents::iterator componentPos = ::std::find( m_aFilterComponents.begin(), m_aFilterComponents.end(), xControl ); + if ( componentPos != m_aFilterComponents.end() ) + m_aFilterComponents.erase( componentPos ); + + implControlRemoved( xControl, m_bDetachEvents ); + + if ( isListeningForChanges() && m_bDetachEvents ) + stopControlModifyListening( xControl ); +} + +// XLoadListener + +void FormController::loaded(const EventObject& rEvent) +{ + OSL_ENSURE( rEvent.Source == m_xModelAsIndex, "FormController::loaded: where did this come from?" ); + + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + ::osl::MutexGuard aGuard( m_aMutex ); + Reference< XRowSet > xForm(rEvent.Source, UNO_QUERY); + // do we have a connected data source + if (xForm.is() && getConnection(xForm).is()) + { + Reference< XPropertySet > xSet(xForm, UNO_QUERY); + if (xSet.is()) + { + Any aVal = xSet->getPropertyValue(FM_PROP_CYCLE); + sal_Int32 aVal2 = 0; + ::cppu::enum2int(aVal2,aVal); + m_bCycle = !aVal.hasValue() || static_cast<form::TabulatorCycle>(aVal2) == TabulatorCycle_RECORDS; + m_bCanUpdate = canUpdate(xSet); + m_bCanInsert = canInsert(xSet); + m_bCurrentRecordModified = ::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_ISMODIFIED)); + m_bCurrentRecordNew = ::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_ISNEW)); + + startFormListening( xSet, false ); + + // set the locks for the current controls + if (getContainer().is()) + { + m_aLoadEvent.Call(); + } + } + else + { + m_bCanInsert = m_bCanUpdate = m_bCycle = false; + m_bCurrentRecordModified = false; + m_bCurrentRecordNew = false; + m_bLocked = false; + } + m_bDBConnection = true; + } + else + { + m_bDBConnection = false; + m_bCanInsert = m_bCanUpdate = m_bCycle = false; + m_bCurrentRecordModified = false; + m_bCurrentRecordNew = false; + m_bLocked = false; + } + + Reference< XColumnsSupplier > xFormColumns( xForm, UNO_QUERY ); + m_pColumnInfoCache.reset( xFormColumns.is() ? new ColumnInfoCache( xFormColumns ) : nullptr ); + + updateAllDispatchers(); +} + + +void FormController::updateAllDispatchers() const +{ + ::std::for_each( + m_aFeatureDispatchers.begin(), + m_aFeatureDispatchers.end(), + [] (const DispatcherContainer::value_type& dispatcher) { + UpdateAllListeners()(dispatcher.second); + }); +} + + +IMPL_LINK_NOARG(FormController, OnLoad, void*, void) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + m_bLocked = determineLockState(); + + setLocks(); + + if (!m_bLocked) + startListening(); + + // just one exception toggle the auto values + if (m_bCurrentRecordNew) + toggleAutoFields(true); +} + + +void FormController::unloaded(const EventObject& /*rEvent*/) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + updateAllDispatchers(); +} + + +void FormController::reloading(const EventObject& /*aEvent*/) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + // do the same like in unloading + // just one exception toggle the auto values + m_aToggleEvent.CancelPendingCall(); + unload(); +} + + +void FormController::reloaded(const EventObject& aEvent) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + loaded(aEvent); +} + + +void FormController::unloading(const EventObject& /*aEvent*/) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + unload(); +} + + +void FormController::unload() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aLoadEvent.CancelPendingCall(); + + // be sure not to have autofields + if (m_bCurrentRecordNew) + toggleAutoFields(false); + + // remove bound field listing again + removeBoundFieldListener(); + + if (m_bDBConnection && isListeningForChanges()) + stopListening(); + + Reference< XPropertySet > xSet( m_xModelAsIndex, UNO_QUERY ); + if ( m_bDBConnection && xSet.is() ) + stopFormListening( xSet, false ); + + m_bDBConnection = false; + m_bCanInsert = m_bCanUpdate = m_bCycle = false; + m_bCurrentRecordModified = m_bCurrentRecordNew = m_bLocked = false; + + m_pColumnInfoCache.reset(); +} + + +void FormController::removeBoundFieldListener() +{ + for ( const Reference< XControl >& rControl : std::as_const(m_aControls) ) + { + Reference< XPropertySet > xProp( rControl, UNO_QUERY ); + if ( xProp.is() ) + xProp->removePropertyChangeListener( FM_PROP_BOUNDFIELD, this ); + } +} + + +void FormController::startFormListening( const Reference< XPropertySet >& _rxForm, bool _bPropertiesOnly ) +{ + try + { + if ( m_bCanInsert || m_bCanUpdate ) // form can be modified + { + _rxForm->addPropertyChangeListener( FM_PROP_ISNEW, this ); + _rxForm->addPropertyChangeListener( FM_PROP_ISMODIFIED, this ); + + if ( !_bPropertiesOnly ) + { + // set the Listener for UI interaction + Reference< XRowSetApproveBroadcaster > xApprove( _rxForm, UNO_QUERY ); + if ( xApprove.is() ) + xApprove->addRowSetApproveListener( this ); + + // listener for row set changes + Reference< XRowSet > xRowSet( _rxForm, UNO_QUERY ); + if ( xRowSet.is() ) + xRowSet->addRowSetListener( this ); + } + } + + Reference< XPropertySetInfo > xInfo = _rxForm->getPropertySetInfo(); + if ( xInfo.is() && xInfo->hasPropertyByName( FM_PROP_DYNAMIC_CONTROL_BORDER ) ) + _rxForm->addPropertyChangeListener( FM_PROP_DYNAMIC_CONTROL_BORDER, this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + + +void FormController::stopFormListening( const Reference< XPropertySet >& _rxForm, bool _bPropertiesOnly ) +{ + try + { + if ( m_bCanInsert || m_bCanUpdate ) + { + _rxForm->removePropertyChangeListener( FM_PROP_ISNEW, this ); + _rxForm->removePropertyChangeListener( FM_PROP_ISMODIFIED, this ); + + if ( !_bPropertiesOnly ) + { + Reference< XRowSetApproveBroadcaster > xApprove( _rxForm, UNO_QUERY ); + if (xApprove.is()) + xApprove->removeRowSetApproveListener(this); + + Reference< XRowSet > xRowSet( _rxForm, UNO_QUERY ); + if ( xRowSet.is() ) + xRowSet->removeRowSetListener( this ); + } + } + + Reference< XPropertySetInfo > xInfo = _rxForm->getPropertySetInfo(); + if ( xInfo.is() && xInfo->hasPropertyByName( FM_PROP_DYNAMIC_CONTROL_BORDER ) ) + _rxForm->removePropertyChangeListener( FM_PROP_DYNAMIC_CONTROL_BORDER, this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + +// css::sdbc::XRowSetListener + +void FormController::cursorMoved(const EventObject& /*event*/) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + // toggle the locking ? + if (m_bLocked != determineLockState()) + { + m_bLocked = !m_bLocked; + setLocks(); + if (isListeningForChanges()) + startListening(); + else + stopListening(); + } + + // neither the current control nor the current record are modified anymore + m_bCurrentRecordModified = m_bModified = false; +} + + +void FormController::rowChanged(const EventObject& /*event*/) +{ + // not interested in ... +} + +void FormController::rowSetChanged(const EventObject& /*event*/) +{ + // not interested in ... +} + + +// XContainerListener + +void SAL_CALL FormController::elementInserted(const ContainerEvent& evt) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + Reference< XControl > xControl( evt.Element, UNO_QUERY ); + if ( !xControl.is() ) + return; + + Reference< XFormComponent > xModel(xControl->getModel(), UNO_QUERY); + if (xModel.is() && m_xModelAsIndex == xModel->getParent()) + { + insertControl(xControl); + + if ( m_aTabActivationIdle.IsActive() ) + m_aTabActivationIdle.Stop(); + + m_aTabActivationIdle.Start(); + } + // are we in filtermode and a XModeSelector has inserted an element + else if (m_bFiltering && Reference< XModeSelector > (evt.Source, UNO_QUERY).is()) + { + xModel.set(evt.Source, UNO_QUERY); + if (xModel.is() && m_xModelAsIndex == xModel->getParent()) + { + Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY); + if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet)) + { + // does the model use a bound field ? + Reference< XPropertySet > xField; + xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + + Reference< XTextComponent > xText(xControl, UNO_QUERY); + // may we filter the field? + if (xText.is() && xField.is() && ::comphelper::hasProperty(FM_PROP_SEARCHABLE, xField) && + ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_SEARCHABLE))) + { + m_aFilterComponents.push_back( xText ); + xText->addTextListener( this ); + } + } + } + } +} + + +void SAL_CALL FormController::elementReplaced(const ContainerEvent& evt) +{ + // simulate an elementRemoved + ContainerEvent aRemoveEvent( evt ); + aRemoveEvent.Element = evt.ReplacedElement; + aRemoveEvent.ReplacedElement = Any(); + elementRemoved( aRemoveEvent ); + + // simulate an elementInserted + ContainerEvent aInsertEvent( evt ); + aInsertEvent.ReplacedElement = Any(); + elementInserted( aInsertEvent ); +} + + +void SAL_CALL FormController::elementRemoved(const ContainerEvent& evt) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + Reference< XControl > xControl; + evt.Element >>= xControl; + if (!xControl.is()) + return; + + Reference< XFormComponent > xModel(xControl->getModel(), UNO_QUERY); + if (xModel.is() && m_xModelAsIndex == xModel->getParent()) + { + removeControl(xControl); + // Do not recalculate TabOrder, because it must already work internally! + } + // are we in filtermode and a XModeSelector has inserted an element + else if (m_bFiltering && Reference< XModeSelector > (evt.Source, UNO_QUERY).is()) + { + FilterComponents::iterator componentPos = ::std::find( + m_aFilterComponents.begin(), m_aFilterComponents.end(), xControl ); + if ( componentPos != m_aFilterComponents.end() ) + m_aFilterComponents.erase( componentPos ); + } +} + + +Reference< XControl > FormController::isInList(const Reference< XWindowPeer > & xPeer) const +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + const Reference< XControl >* pControls = m_aControls.getConstArray(); + + sal_uInt32 nCtrls = m_aControls.getLength(); + for ( sal_uInt32 n = 0; n < nCtrls && xPeer.is(); ++n, ++pControls ) + { + if ( pControls->is() ) + { + Reference< XVclWindowPeer > xCtrlPeer( (*pControls)->getPeer(), UNO_QUERY); + if ( ( xCtrlPeer.get() == xPeer.get() ) || xCtrlPeer->isChild( xPeer ) ) + return *pControls; + } + } + return Reference< XControl > (); +} + + +void FormController::activateFirst() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + DBG_ASSERT(m_xTabController.is(), "FormController::activateFirst : invalid aggregate !"); + if (m_xTabController.is()) + m_xTabController->activateFirst(); +} + + +void FormController::activateLast() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + DBG_ASSERT(m_xTabController.is(), "FormController::activateLast : invalid aggregate !"); + if (m_xTabController.is()) + m_xTabController->activateLast(); +} + +// XFormController + +Reference< XFormOperations > SAL_CALL FormController::getFormOperations() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + return m_xFormOperations; +} + + +Reference< XControl> SAL_CALL FormController::getCurrentControl() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + return m_xCurrentControl; +} + + +void SAL_CALL FormController::addActivateListener(const Reference< XFormControllerListener > & l) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + m_aActivateListeners.addInterface(l); +} + +void SAL_CALL FormController::removeActivateListener(const Reference< XFormControllerListener > & l) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + m_aActivateListeners.removeInterface(l); +} + + +void SAL_CALL FormController::addChildController( const Reference< XFormController >& ChildController ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + if ( !ChildController.is() ) + throw IllegalArgumentException( OUString(), *this, 1 ); + // TODO: (localized) error message + + // the parent of our (to-be-)child must be our own model + Reference< XFormComponent > xFormOfChild( ChildController->getModel(), UNO_QUERY ); + if ( !xFormOfChild.is() ) + throw IllegalArgumentException( OUString(), *this, 1 ); + // TODO: (localized) error message + + if ( xFormOfChild->getParent() != m_xModelAsIndex ) + throw IllegalArgumentException( OUString(), *this, 1 ); + // TODO: (localized) error message + + m_aChildren.push_back( ChildController ); + ChildController->setParent( *this ); + + // search the position of the model within the form + sal_uInt32 nPos = m_xModelAsIndex->getCount(); + Reference< XFormComponent > xTemp; + for( ; nPos; ) + { + m_xModelAsIndex->getByIndex(--nPos) >>= xTemp; + if ( xFormOfChild == xTemp ) + { + m_xModelAsManager->attach( nPos, Reference<XInterface>( ChildController, UNO_QUERY ), Any( ChildController) ); + break; + } + } +} + + +Reference< XFormControllerContext > SAL_CALL FormController::getContext() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + return m_xFormControllerContext; +} + + +void SAL_CALL FormController::setContext( const Reference< XFormControllerContext >& _context ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + m_xFormControllerContext = _context; +} + + +Reference< XInteractionHandler > SAL_CALL FormController::getInteractionHandler() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + return m_xInteractionHandler; +} + + +void SAL_CALL FormController::setInteractionHandler( const Reference< XInteractionHandler >& _interactionHandler ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + m_xInteractionHandler = _interactionHandler; +} + + +void FormController::setFilter(::std::vector<FmFieldInfo>& rFieldInfos) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + // create the composer + Reference< XRowSet > xForm(m_xModelAsIndex, UNO_QUERY); + Reference< XConnection > xConnection(getConnection(xForm)); + if (xForm.is()) + { + try + { + Reference< XMultiServiceFactory > xFactory( xConnection, UNO_QUERY_THROW ); + m_xComposer.set( + xFactory->createInstance("com.sun.star.sdb.SingleSelectQueryComposer"), + UNO_QUERY_THROW ); + + Reference< XPropertySet > xSet( xForm, UNO_QUERY ); + OUString sStatement = ::comphelper::getString( xSet->getPropertyValue( FM_PROP_ACTIVECOMMAND ) ); + OUString sFilter = ::comphelper::getString( xSet->getPropertyValue( FM_PROP_FILTER ) ); + m_xComposer->setElementaryQuery( sStatement ); + m_xComposer->setFilter( sFilter ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + if (m_xComposer.is()) + { + const Sequence< Sequence < PropertyValue > > aFilterRows = m_xComposer->getStructuredFilter(); + + // ok, we receive the list of filters as sequence of fieldnames, value + // now we have to transform the fieldname into UI names, that could be a label of the field or + // an aliasname or the fieldname itself + + // first adjust the field names if necessary + Reference< XNameAccess > xQueryColumns = + Reference< XColumnsSupplier >( m_xComposer, UNO_QUERY_THROW )->getColumns(); + + for (auto& rFieldInfo : rFieldInfos) + { + if ( xQueryColumns->hasByName(rFieldInfo.aFieldName) ) + { + if ( (xQueryColumns->getByName(rFieldInfo.aFieldName) >>= rFieldInfo.xField) && rFieldInfo.xField.is() ) + rFieldInfo.xField->getPropertyValue(FM_PROP_REALNAME) >>= rFieldInfo.aFieldName; + } + } + + Reference< XDatabaseMetaData> xMetaData(xConnection->getMetaData()); + // now transfer the filters into Value/TextComponent pairs + ::comphelper::UStringMixEqual aCompare(xMetaData->storesMixedCaseQuotedIdentifiers()); + + // need to parse criteria localized + Reference< XNumberFormatsSupplier> xFormatSupplier( getNumberFormats(xConnection, true)); + Reference< XNumberFormatter> xFormatter = NumberFormatter::create(m_xComponentContext); + xFormatter->attachNumberFormatsSupplier(xFormatSupplier); + Locale aAppLocale = Application::GetSettings().GetUILanguageTag().getLocale(); + const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetUILocaleDataWrapper() ); + OUString strDecimalSeparator = rLocaleWrapper.getNumDecimalSep(); + + // retrieving the filter + for (const Sequence < PropertyValue >& rRow : aFilterRows) + { + FmFilterRow aRow; + + // search a field for the given name + for (const PropertyValue& rRefValue : rRow) + { + // look for the text component + Reference< XPropertySet > xField; + try + { + Reference< XPropertySet > xSet; + OUString aRealName; + + // first look with the given name + if (xQueryColumns->hasByName(rRefValue.Name)) + { + xQueryColumns->getByName(rRefValue.Name) >>= xSet; + + // get the RealName + xSet->getPropertyValue("RealName") >>= aRealName; + + // compare the condition field name and the RealName + if (aCompare(aRealName, rRefValue.Name)) + xField = xSet; + } + if (!xField.is()) + { + // no we have to check every column to find the realname + Reference< XIndexAccess > xColumnsByIndex(xQueryColumns, UNO_QUERY); + for (sal_Int32 n = 0, nCount = xColumnsByIndex->getCount(); n < nCount; n++) + { + xColumnsByIndex->getByIndex(n) >>= xSet; + xSet->getPropertyValue("RealName") >>= aRealName; + if (aCompare(aRealName, rRefValue.Name)) + { + // get the column by its alias + xField = xSet; + break; + } + } + } + if (!xField.is()) + continue; + } + catch (const Exception&) + { + continue; + } + + // find the text component + for (const auto& rFieldInfo : rFieldInfos) + { + // we found the field so insert a new entry to the filter row + if (rFieldInfo.xField == xField) + { + // do we already have the control ? + if (aRow.find(rFieldInfo.xText) != aRow.end()) + { + OString aVal = m_pParser->getContext().getIntlKeywordAscii(IParseContext::InternationalKeyCode::And); + OUString aCompText = aRow[rFieldInfo.xText] + " " + + OUString(aVal.getStr(),aVal.getLength(),RTL_TEXTENCODING_ASCII_US) + " " + + ::comphelper::getString(rRefValue.Value); + aRow[rFieldInfo.xText] = aCompText; + } + else + { + OUString sPredicate,sErrorMsg; + rRefValue.Value >>= sPredicate; + std::unique_ptr< OSQLParseNode > pParseNode = predicateTree(sErrorMsg, sPredicate, xFormatter, xField); + if ( pParseNode != nullptr ) + { + OUString sCriteria; + switch (rRefValue.Handle) + { + case css::sdb::SQLFilterOperator::EQUAL: + sCriteria += "="; + break; + case css::sdb::SQLFilterOperator::NOT_EQUAL: + sCriteria += "!="; + break; + case css::sdb::SQLFilterOperator::LESS: + sCriteria += "<"; + break; + case css::sdb::SQLFilterOperator::GREATER: + sCriteria += ">"; + break; + case css::sdb::SQLFilterOperator::LESS_EQUAL: + sCriteria += "<="; + break; + case css::sdb::SQLFilterOperator::GREATER_EQUAL: + sCriteria += ">="; + break; + case css::sdb::SQLFilterOperator::LIKE: + sCriteria += "LIKE "; + break; + case css::sdb::SQLFilterOperator::NOT_LIKE: + sCriteria += "NOT LIKE "; + break; + case css::sdb::SQLFilterOperator::SQLNULL: + sCriteria += "IS NULL"; + break; + case css::sdb::SQLFilterOperator::NOT_SQLNULL: + sCriteria += "IS NOT NULL"; + break; + } + pParseNode->parseNodeToPredicateStr( sCriteria + ,xConnection + ,xFormatter + ,xField + ,OUString() + ,aAppLocale + ,strDecimalSeparator + ,getParseContext()); + aRow[rFieldInfo.xText] = sCriteria; + } + } + } + } + } + + if (aRow.empty()) + continue; + + impl_addFilterRow( aRow ); + } + } + + // now set the filter controls + for (const auto& rFieldInfo : rFieldInfos) + { + m_aFilterComponents.push_back( rFieldInfo.xText ); + } +} + + +void FormController::startFiltering() +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + + Reference< XConnection > xConnection( getConnection( Reference< XRowSet >( m_xModelAsIndex, UNO_QUERY ) ) ); + if ( !xConnection.is() ) + // nothing to do - can't filter a form which is not connected + return; + + // stop listening for controls + if (isListeningForChanges()) + stopListening(); + + m_bFiltering = true; + + // as we don't want new controls to be attached to the scripting environment + // we change attach flags + m_bAttachEvents = false; + + // exchanging the controls for the current form + Sequence< Reference< XControl > > aControlsCopy( m_aControls ); + const Reference< XControl >* pControls = aControlsCopy.getConstArray(); + sal_Int32 nControlCount = aControlsCopy.getLength(); + + // the control we have to activate after replacement + Reference< XNumberFormatsSupplier > xFormatSupplier = getNumberFormats(xConnection, true); + Reference< XNumberFormatter > xFormatter = NumberFormatter::create(m_xComponentContext); + xFormatter->attachNumberFormatsSupplier(xFormatSupplier); + + // structure for storing the field info + ::std::vector<FmFieldInfo> aFieldInfos; + + for (sal_Int32 i = nControlCount; i > 0;) + { + Reference< XControl > xControl = pControls[--i]; + if (xControl.is()) + { + // no events for the control anymore + removeFromEventAttacher(xControl); + + // do we have a mode selector + Reference< XModeSelector > xSelector(xControl, UNO_QUERY); + if (xSelector.is()) + { + xSelector->setMode( "FilterMode" ); + + // listening for new controls of the selector + Reference< XContainer > xContainer(xSelector, UNO_QUERY); + if (xContainer.is()) + xContainer->addContainerListener(this); + + Reference< XEnumerationAccess > xElementAccess(xSelector, UNO_QUERY); + if (xElementAccess.is()) + { + Reference< XEnumeration > xEnumeration(xElementAccess->createEnumeration()); + Reference< XControl > xSubControl; + while (xEnumeration->hasMoreElements()) + { + xEnumeration->nextElement() >>= xSubControl; + if (xSubControl.is()) + { + Reference< XPropertySet > xSet(xSubControl->getModel(), UNO_QUERY); + if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet)) + { + // does the model use a bound field ? + Reference< XPropertySet > xField; + xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + + Reference< XTextComponent > xText(xSubControl, UNO_QUERY); + // may we filter the field? + if (xText.is() && xField.is() && ::comphelper::hasProperty(FM_PROP_SEARCHABLE, xField) && + ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_SEARCHABLE))) + { + aFieldInfos.emplace_back(xField, xText); + xText->addTextListener(this); + } + } + } + } + } + continue; + } + + Reference< XPropertySet > xModel( xControl->getModel(), UNO_QUERY ); + if (xModel.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xModel)) + { + // does the model use a bound field ? + Any aVal = xModel->getPropertyValue(FM_PROP_BOUNDFIELD); + Reference< XPropertySet > xField; + aVal >>= xField; + + // may we filter the field? + + if ( xField.is() + && ::comphelper::hasProperty( FM_PROP_SEARCHABLE, xField ) + && ::comphelper::getBOOL( xField->getPropertyValue( FM_PROP_SEARCHABLE ) ) + ) + { + // create a filter control + Reference< XControl > xFilterControl = form::control::FilterControl::createWithFormat( + m_xComponentContext, + getDialogParentWindow(this), + xFormatter, + xModel); + + if ( replaceControl( xControl, xFilterControl ) ) + { + Reference< XTextComponent > xFilterText( xFilterControl, UNO_QUERY ); + aFieldInfos.emplace_back( xField, xFilterText ); + xFilterText->addTextListener(this); + } + } + } + else + { + // unsubscribe from EventManager + } + } + } + + // we have all filter controls now, so the next step is to read the filters from the form + // resolve all aliases and set the current filter to the according structure + setFilter(aFieldInfos); + + Reference< XPropertySet > xSet( m_xModelAsIndex, UNO_QUERY ); + if ( xSet.is() ) + stopFormListening( xSet, true ); + + impl_setTextOnAllFilter_throw(); + + // lock all controls which are not used for filtering + m_bLocked = determineLockState(); + setLocks(); + m_bAttachEvents = true; +} + + +void FormController::stopFiltering() +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + if ( !m_bFiltering ) // #104693# OJ + { // nothing to do + return; + } + + m_bFiltering = false; + m_bDetachEvents = false; + + ::comphelper::disposeComponent(m_xComposer); + + // exchanging the controls for the current form + Sequence< Reference< XControl > > aControlsCopy( m_aControls ); + const Reference< XControl > * pControls = aControlsCopy.getConstArray(); + sal_Int32 nControlCount = aControlsCopy.getLength(); + + // clear the filter control map + ::std::for_each( m_aFilterComponents.begin(), m_aFilterComponents.end(), RemoveComponentTextListener( this ) ); + m_aFilterComponents.clear(); + + for ( sal_Int32 i = nControlCount; i > 0; ) + { + Reference< XControl > xControl = pControls[--i]; + if (xControl.is()) + { + // now enable event handling again + addToEventAttacher(xControl); + + Reference< XModeSelector > xSelector(xControl, UNO_QUERY); + if (xSelector.is()) + { + xSelector->setMode( "DataMode" ); + + // listening for new controls of the selector + Reference< XContainer > xContainer(xSelector, UNO_QUERY); + if (xContainer.is()) + xContainer->removeContainerListener(this); + continue; + } + + Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY); + if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet)) + { + // does the model use a bound field ? + Reference< XPropertySet > xField; + xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField; + + // may we filter the field? + if ( xField.is() + && ::comphelper::hasProperty( FM_PROP_SEARCHABLE, xField ) + && ::comphelper::getBOOL( xField->getPropertyValue( FM_PROP_SEARCHABLE ) ) + ) + { + OUString sServiceName; + OSL_VERIFY( xSet->getPropertyValue( FM_PROP_DEFAULTCONTROL ) >>= sServiceName ); + Reference< XControl > xNewControl( m_xComponentContext->getServiceManager()->createInstanceWithContext( sServiceName, m_xComponentContext ), UNO_QUERY ); + replaceControl( xControl, xNewControl ); + } + } + } + } + + Reference< XPropertySet > xSet( m_xModelAsIndex, UNO_QUERY ); + if ( xSet.is() ) + startFormListening( xSet, true ); + + m_bDetachEvents = true; + + m_aFilterRows.clear(); + m_nCurrentFilterPosition = -1; + + // release the locks if possible + // lock all controls which are not used for filtering + m_bLocked = determineLockState(); + setLocks(); + + // restart listening for control modifications + if (isListeningForChanges()) + startListening(); +} + +// XModeSelector + +void FormController::setMode(const OUString& Mode) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + if (!supportsMode(Mode)) + throw NoSupportException(); + + if (Mode == m_aMode) + return; + + m_aMode = Mode; + + if ( Mode == "FilterMode" ) + startFiltering(); + else + stopFiltering(); + + for (const auto& rChild : m_aChildren) + { + Reference< XModeSelector > xMode(rChild, UNO_QUERY); + if ( xMode.is() ) + xMode->setMode(Mode); + } +} + + +OUString SAL_CALL FormController::getMode() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + return m_aMode; +} + + +Sequence< OUString > SAL_CALL FormController::getSupportedModes() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + static Sequence< OUString > const aModes + { + "DataMode", + "FilterMode" + }; + return aModes; +} + +sal_Bool SAL_CALL FormController::supportsMode(const OUString& Mode) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + Sequence< OUString > aModes(getSupportedModes()); + return comphelper::findValue(aModes, Mode) != -1; +} + +css::uno::Reference<css::awt::XWindow> FormController::getDialogParentWindow(css::uno::Reference<css::form::runtime::XFormController> xFormController) +{ + try + { + Reference< XControl > xContainerControl( xFormController->getContainer(), UNO_QUERY_THROW ); + Reference<XWindow> xContainerWindow(xContainerControl->getPeer(), UNO_QUERY_THROW); + return xContainerWindow; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return nullptr; +} + +bool FormController::checkFormComponentValidity( OUString& /* [out] */ _rFirstInvalidityExplanation, Reference< XControlModel >& /* [out] */ _rxFirstInvalidModel ) +{ + try + { + Reference< XEnumerationAccess > xControlEnumAcc( getModel(), UNO_QUERY ); + Reference< XEnumeration > xControlEnumeration; + if ( xControlEnumAcc.is() ) + xControlEnumeration = xControlEnumAcc->createEnumeration(); + OSL_ENSURE( xControlEnumeration.is(), "FormController::checkFormComponentValidity: cannot enumerate the controls!" ); + if ( !xControlEnumeration.is() ) + // assume all valid + return true; + + Reference< XValidatableFormComponent > xValidatable; + while ( xControlEnumeration->hasMoreElements() ) + { + if ( !( xControlEnumeration->nextElement() >>= xValidatable ) ) + // control does not support validation + continue; + + if ( xValidatable->isValid() ) + continue; + + Reference< XValidator > xValidator( xValidatable->getValidator() ); + OSL_ENSURE( xValidator.is(), "FormController::checkFormComponentValidity: invalid, but no validator?" ); + if ( !xValidator.is() ) + // this violates the interface definition of css.form.validation.XValidatableFormComponent ... + continue; + + _rFirstInvalidityExplanation = xValidator->explainInvalid( xValidatable->getCurrentValue() ); + _rxFirstInvalidModel.set(xValidatable, css::uno::UNO_QUERY); + return false; + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return true; +} + + +Reference< XControl > FormController::locateControl( const Reference< XControlModel >& _rxModel ) +{ + try + { + const Sequence< Reference< XControl > > aControls( getControls() ); + + for ( auto const & control : aControls ) + { + OSL_ENSURE( control.is(), "FormController::locateControl: NULL-control?" ); + if ( control.is() ) + { + if ( control->getModel() == _rxModel ) + return control; + } + } + OSL_FAIL( "FormController::locateControl: did not find a control for this model!" ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return nullptr; +} + + +namespace +{ + void displayErrorSetFocus(const OUString& _rMessage, const Reference<XControl>& _rxFocusControl, + const css::uno::Reference<css::awt::XWindow>& rDialogParent) + { + SQLContext aError; + aError.Message = SvxResId(RID_STR_WRITEERROR); + aError.Details = _rMessage; + displayException(aError, rDialogParent); + + if ( _rxFocusControl.is() ) + { + Reference< XWindow > xControlWindow( _rxFocusControl, UNO_QUERY ); + OSL_ENSURE( xControlWindow.is(), "displayErrorSetFocus: invalid control!" ); + if ( xControlWindow.is() ) + xControlWindow->setFocus(); + } + } + + bool lcl_shouldValidateRequiredFields_nothrow( const Reference< XInterface >& _rxForm ) + { + try + { + static constexpr OUStringLiteral s_sFormsCheckRequiredFields = u"FormsCheckRequiredFields"; + + // first, check whether the form has a property telling us the answer + // this allows people to use the XPropertyContainer interface of a form to control + // the behaviour on a per-form basis. + Reference< XPropertySet > xFormProps( _rxForm, UNO_QUERY_THROW ); + Reference< XPropertySetInfo > xPSI( xFormProps->getPropertySetInfo() ); + if ( xPSI->hasPropertyByName( s_sFormsCheckRequiredFields ) ) + { + bool bShouldValidate = true; + OSL_VERIFY( xFormProps->getPropertyValue( s_sFormsCheckRequiredFields ) >>= bShouldValidate ); + return bShouldValidate; + } + + // next, check the data source which created the connection + Reference< XChild > xConnectionAsChild( xFormProps->getPropertyValue( FM_PROP_ACTIVE_CONNECTION ), UNO_QUERY_THROW ); + Reference< XPropertySet > xDataSource( xConnectionAsChild->getParent(), UNO_QUERY ); + if ( !xDataSource.is() ) + // seldom (but possible): this is not a connection created by a data source + return true; + + Reference< XPropertySet > xDataSourceSettings( + xDataSource->getPropertyValue("Settings"), + UNO_QUERY_THROW ); + + bool bShouldValidate = true; + OSL_VERIFY( xDataSourceSettings->getPropertyValue( s_sFormsCheckRequiredFields ) >>= bShouldValidate ); + return bShouldValidate; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + return true; + } +} + +// XRowSetApproveListener + +sal_Bool SAL_CALL FormController::approveRowChange(const RowChangeEvent& _rEvent) +{ + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + ::comphelper::OInterfaceIteratorHelper3 aIter(m_aRowSetApproveListeners); + bool bValid = true; + if (aIter.hasMoreElements()) + { + RowChangeEvent aEvt( _rEvent ); + aEvt.Source = *this; + bValid = aIter.next()->approveRowChange(aEvt); + } + + if ( !bValid ) + return bValid; + + if ( ( _rEvent.Action != RowChangeAction::INSERT ) + && ( _rEvent.Action != RowChangeAction::UPDATE ) + ) + return bValid; + + // if some of the control models are bound to validators, check them + OUString sInvalidityExplanation; + Reference< XControlModel > xInvalidModel; + if ( !checkFormComponentValidity( sInvalidityExplanation, xInvalidModel ) ) + { + Reference< XControl > xControl( locateControl( xInvalidModel ) ); + aGuard.clear(); + displayErrorSetFocus( sInvalidityExplanation, xControl, getDialogParentWindow(this) ); + return false; + } + + // check values on NULL and required flag + if ( !lcl_shouldValidateRequiredFields_nothrow( _rEvent.Source ) ) + return true; + + OSL_ENSURE(m_pColumnInfoCache, "FormController::approveRowChange: no column infos!"); + if (!m_pColumnInfoCache) + return true; + + try + { + if ( !m_pColumnInfoCache->controlsInitialized() ) + m_pColumnInfoCache->initializeControls( getControls() ); + + size_t colCount = m_pColumnInfoCache->getColumnCount(); + for ( size_t col = 0; col < colCount; ++col ) + { + const ColumnInfo& rColInfo = m_pColumnInfoCache->getColumnInfo( col ); + + if ( rColInfo.bAutoIncrement ) + continue; + + if ( rColInfo.bReadOnly ) + continue; + + if ( !rColInfo.xFirstControlWithInputRequired.is() && !rColInfo.xFirstGridWithInputRequiredColumn.is() ) + { + continue; + } + + // TODO: in case of binary fields, this "getString" below is extremely expensive + if ( !rColInfo.xColumn->getString().isEmpty() || !rColInfo.xColumn->wasNull() ) + continue; + + OUString sMessage( SvxResId( RID_ERR_FIELDREQUIRED ) ); + sMessage = sMessage.replaceFirst( "#", rColInfo.sName ); + + // the control to focus + Reference< XControl > xControl( rColInfo.xFirstControlWithInputRequired ); + if ( !xControl.is() ) + xControl.set( rColInfo.xFirstGridWithInputRequiredColumn, UNO_QUERY ); + + aGuard.clear(); + displayErrorSetFocus( sMessage, rColInfo.xFirstControlWithInputRequired, getDialogParentWindow(this) ); + return false; + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + return true; +} + + +sal_Bool SAL_CALL FormController::approveCursorMove(const EventObject& event) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + ::comphelper::OInterfaceIteratorHelper3 aIter(m_aRowSetApproveListeners); + if (aIter.hasMoreElements()) + { + EventObject aEvt(event); + aEvt.Source = *this; + return aIter.next()->approveCursorMove(aEvt); + } + + return true; +} + + +sal_Bool SAL_CALL FormController::approveRowSetChange(const EventObject& event) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + ::comphelper::OInterfaceIteratorHelper3 aIter(m_aRowSetApproveListeners); + if (aIter.hasMoreElements()) + { + EventObject aEvt(event); + aEvt.Source = *this; + return aIter.next()->approveRowSetChange(aEvt); + } + + return true; +} + +// XRowSetApproveBroadcaster + +void SAL_CALL FormController::addRowSetApproveListener(const Reference< XRowSetApproveListener > & _rxListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aRowSetApproveListeners.addInterface(_rxListener); +} + + +void SAL_CALL FormController::removeRowSetApproveListener(const Reference< XRowSetApproveListener > & _rxListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aRowSetApproveListeners.removeInterface(_rxListener); +} + +// XErrorListener + +void SAL_CALL FormController::errorOccured(const SQLErrorEvent& aEvent) +{ + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + ::comphelper::OInterfaceIteratorHelper3 aIter(m_aErrorListeners); + if (aIter.hasMoreElements()) + { + SQLErrorEvent aEvt(aEvent); + aEvt.Source = *this; + aIter.next()->errorOccured(aEvt); + } + else + { + aGuard.clear(); + displayException(aEvent, getDialogParentWindow(this)); + } +} + +// XErrorBroadcaster + +void SAL_CALL FormController::addSQLErrorListener(const Reference< XSQLErrorListener > & aListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aErrorListeners.addInterface(aListener); +} + + +void SAL_CALL FormController::removeSQLErrorListener(const Reference< XSQLErrorListener > & aListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aErrorListeners.removeInterface(aListener); +} + +// XDatabaseParameterBroadcaster2 + +void SAL_CALL FormController::addDatabaseParameterListener(const Reference< XDatabaseParameterListener > & aListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aParameterListeners.addInterface(aListener); +} + + +void SAL_CALL FormController::removeDatabaseParameterListener(const Reference< XDatabaseParameterListener > & aListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aParameterListeners.removeInterface(aListener); +} + +// XDatabaseParameterBroadcaster + +void SAL_CALL FormController::addParameterListener(const Reference< XDatabaseParameterListener > & aListener) +{ + FormController::addDatabaseParameterListener( aListener ); +} + + +void SAL_CALL FormController::removeParameterListener(const Reference< XDatabaseParameterListener > & aListener) +{ + FormController::removeDatabaseParameterListener( aListener ); +} + +// XDatabaseParameterListener + +sal_Bool SAL_CALL FormController::approveParameter(const DatabaseParameterEvent& aEvent) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + ::comphelper::OInterfaceIteratorHelper3 aIter(m_aParameterListeners); + if (aIter.hasMoreElements()) + { + DatabaseParameterEvent aEvt(aEvent); + aEvt.Source = *this; + return aIter.next()->approveParameter(aEvt); + } + else + { + // default handling: instantiate an interaction handler and let it handle the parameter request + try + { + if ( !ensureInteractionHandler() ) + return false; + + // two continuations allowed: OK and Cancel + rtl::Reference<OParameterContinuation> pParamValues = new OParameterContinuation; + rtl::Reference<OInteractionAbort> pAbort = new OInteractionAbort; + // the request + ParametersRequest aRequest; + aRequest.Parameters = aEvent.Parameters; + aRequest.Connection = getConnection(Reference< XRowSet >(aEvent.Source, UNO_QUERY)); + rtl::Reference<OInteractionRequest> pParamRequest = new OInteractionRequest(Any(aRequest)); + // some knittings + pParamRequest->addContinuation(pParamValues); + pParamRequest->addContinuation(pAbort); + + // handle the request + m_xInteractionHandler->handle(pParamRequest); + + if (!pParamValues->wasSelected()) + // canceled + return false; + + // transfer the values into the parameter supplier + Sequence< PropertyValue > aFinalValues = pParamValues->getValues(); + if (aFinalValues.getLength() != aRequest.Parameters->getCount()) + { + OSL_FAIL("FormController::approveParameter: the InteractionHandler returned nonsense!"); + return false; + } + const PropertyValue* pFinalValues = aFinalValues.getConstArray(); + for (sal_Int32 i=0; i<aFinalValues.getLength(); ++i, ++pFinalValues) + { + Reference< XPropertySet > xParam( + aRequest.Parameters->getByIndex(i), css::uno::UNO_QUERY); + if (xParam.is()) + { +#ifdef DBG_UTIL + OUString sName; + xParam->getPropertyValue(FM_PROP_NAME) >>= sName; + DBG_ASSERT(sName == pFinalValues->Name, "FormController::approveParameter: suspicious value names!"); +#endif + try { xParam->setPropertyValue(FM_PROP_VALUE, pFinalValues->Value); } + catch(Exception&) + { + OSL_FAIL("FormController::approveParameter: setting one of the properties failed!"); + } + } + } + } + catch(Exception&) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + return true; +} + +// XConfirmDeleteBroadcaster + +void SAL_CALL FormController::addConfirmDeleteListener(const Reference< XConfirmDeleteListener > & aListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aDeleteListeners.addInterface(aListener); +} + + +void SAL_CALL FormController::removeConfirmDeleteListener(const Reference< XConfirmDeleteListener > & aListener) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + m_aDeleteListeners.removeInterface(aListener); +} + +// XConfirmDeleteListener + +sal_Bool SAL_CALL FormController::confirmDelete(const RowChangeEvent& aEvent) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + impl_checkDisposed_throw(); + + ::comphelper::OInterfaceIteratorHelper3 aIter(m_aDeleteListeners); + if (aIter.hasMoreElements()) + { + RowChangeEvent aEvt(aEvent); + aEvt.Source = *this; + return aIter.next()->confirmDelete(aEvt); + } + // default handling: instantiate an interaction handler and let it handle the request + + OUString sTitle; + sal_Int32 nLength = aEvent.Rows; + if ( nLength > 1 ) + { + sTitle = SvxResId( RID_STR_DELETECONFIRM_RECORDS ); + sTitle = sTitle.replaceFirst( "#", OUString::number(nLength) ); + } + else + sTitle = SvxResId( RID_STR_DELETECONFIRM_RECORD ); + + try + { + if ( !ensureInteractionHandler() ) + return false; + + // two continuations allowed: Yes and No + rtl::Reference<OInteractionApprove> pApprove = new OInteractionApprove; + rtl::Reference<OInteractionDisapprove> pDisapprove = new OInteractionDisapprove; + + // the request + SQLWarning aWarning; + aWarning.Message = sTitle; + SQLWarning aDetails; + aDetails.Message = SvxResId(RID_STR_DELETECONFIRM); + aWarning.NextException <<= aDetails; + + rtl::Reference<OInteractionRequest> pRequest = new OInteractionRequest( Any( aWarning ) ); + + // some knittings + pRequest->addContinuation( pApprove ); + pRequest->addContinuation( pDisapprove ); + + // handle the request + m_xInteractionHandler->handle( pRequest ); + + if ( pApprove->wasSelected() ) + return true; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + return false; +} + + +void SAL_CALL FormController::invalidateFeatures( const Sequence< ::sal_Int16 >& Features ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + // for now, just copy the ids of the features, because... + m_aInvalidFeatures.insert( Features.begin(), Features.end() ); + + // ... we will do the real invalidation asynchronously + if ( !m_aFeatureInvalidationTimer.IsActive() ) + m_aFeatureInvalidationTimer.Start(); +} + + +void SAL_CALL FormController::invalidateAllFeatures( ) +{ + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + + Sequence< sal_Int16 > aInterceptedFeatures( comphelper::mapKeysToSequence(m_aFeatureDispatchers) ); + + aGuard.clear(); + if ( aInterceptedFeatures.hasElements() ) + invalidateFeatures( aInterceptedFeatures ); +} + + +Reference< XDispatch > +FormController::interceptedQueryDispatch( const URL& aURL, + const OUString& /*aTargetFrameName*/, sal_Int32 /*nSearchFlags*/) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + Reference< XDispatch > xReturn; + // dispatches handled by ourself + if ( ( aURL.Complete == FMURL_CONFIRM_DELETION ) + || ( ( aURL.Complete == "private:/InteractionHandler" ) + && ensureInteractionHandler() + ) + ) + xReturn = static_cast< XDispatch* >( this ); + + // dispatches of FormSlot-URLs we have to translate + if ( !xReturn.is() && m_xFormOperations.is() ) + { + // find the slot id which corresponds to the URL + sal_Int32 nFeatureSlotId = svx::FeatureSlotTranslation::getControllerFeatureSlotIdForURL( aURL.Main ); + sal_Int16 nFormFeature = ( nFeatureSlotId != -1 ) ? svx::FeatureSlotTranslation::getFormFeatureForSlotId( nFeatureSlotId ) : -1; + if ( nFormFeature > 0 ) + { + // get the dispatcher for this feature, create if necessary + DispatcherContainer::const_iterator aDispatcherPos = m_aFeatureDispatchers.find( nFormFeature ); + if ( aDispatcherPos == m_aFeatureDispatchers.end() ) + { + aDispatcherPos = m_aFeatureDispatchers.emplace( + nFormFeature, new svx::OSingleFeatureDispatcher( aURL, nFormFeature, m_xFormOperations, m_aMutex ) + ).first; + } + + OSL_ENSURE( aDispatcherPos->second.is(), "FormController::interceptedQueryDispatch: should have a dispatcher by now!" ); + return aDispatcherPos->second; + } + } + + // no more to offer + return xReturn; +} + + +void SAL_CALL FormController::dispatch( const URL& _rURL, const Sequence< PropertyValue >& _rArgs ) +{ + if ( _rArgs.getLength() != 1 ) + { + OSL_FAIL( "FormController::dispatch: no arguments -> no dispatch!" ); + return; + } + + if ( _rURL.Complete == "private:/InteractionHandler" ) + { + Reference< XInteractionRequest > xRequest; + OSL_VERIFY( _rArgs[0].Value >>= xRequest ); + if ( xRequest.is() ) + handle( xRequest ); + return; + } + + if ( _rURL.Complete == FMURL_CONFIRM_DELETION ) + { + OSL_FAIL( "FormController::dispatch: How do you expect me to return something via this call?" ); + // confirmDelete has a return value - dispatch hasn't + return; + } + + OSL_FAIL( "FormController::dispatch: unknown URL!" ); +} + + +void SAL_CALL FormController::addStatusListener( const Reference< XStatusListener >& _rxListener, const URL& _rURL ) +{ + if (_rURL.Complete == FMURL_CONFIRM_DELETION) + { + if (_rxListener.is()) + { // send an initial statusChanged event + FeatureStateEvent aEvent; + aEvent.FeatureURL = _rURL; + aEvent.IsEnabled = true; + _rxListener->statusChanged(aEvent); + // and don't add the listener at all (the status will never change) + } + } + else + OSL_FAIL("FormController::addStatusListener: invalid (unsupported) URL!"); +} + + +Reference< XInterface > SAL_CALL FormController::getParent() +{ + return m_xParent; +} + + +void SAL_CALL FormController::setParent( const Reference< XInterface >& Parent) +{ + m_xParent = Parent; +} + + +void SAL_CALL FormController::removeStatusListener( const Reference< XStatusListener >& /*_rxListener*/, const URL& _rURL ) +{ + OSL_ENSURE(_rURL.Complete == FMURL_CONFIRM_DELETION, "FormController::removeStatusListener: invalid (unsupported) URL!"); + // we never really added the listener, so we don't need to remove it +} + + +Reference< XDispatchProviderInterceptor > FormController::createInterceptor(const Reference< XDispatchProviderInterception > & _xInterception) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); +#ifdef DBG_UTIL + // check if we already have an interceptor for the given object + for ( const auto & it : m_aControlDispatchInterceptors ) + { + if (it->getIntercepted() == _xInterception) + OSL_FAIL("FormController::createInterceptor : we already do intercept this objects dispatches !"); + } +#endif + + rtl::Reference<DispatchInterceptionMultiplexer> pInterceptor(new DispatchInterceptionMultiplexer( _xInterception, this )); + m_aControlDispatchInterceptors.push_back( pInterceptor ); + + return pInterceptor; +} + + +bool FormController::ensureInteractionHandler() +{ + if ( m_xInteractionHandler.is() ) + return true; + if ( m_bAttemptedHandlerCreation ) + return false; + m_bAttemptedHandlerCreation = true; + + m_xInteractionHandler = InteractionHandler::createWithParent(m_xComponentContext, + getDialogParentWindow(this)); + return m_xInteractionHandler.is(); +} + + +void SAL_CALL FormController::handle( const Reference< XInteractionRequest >& _rRequest ) +{ + if ( !ensureInteractionHandler() ) + return; + m_xInteractionHandler->handle( _rRequest ); +} + + +void FormController::deleteInterceptor(const Reference< XDispatchProviderInterception > & _xInterception) +{ + OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" ); + // search the interceptor responsible for the given object + auto aIter = std::find_if(m_aControlDispatchInterceptors.begin(), m_aControlDispatchInterceptors.end(), + [&_xInterception](const rtl::Reference<DispatchInterceptionMultiplexer>& rpInterceptor) { + return rpInterceptor->getIntercepted() == _xInterception; + }); + if (aIter != m_aControlDispatchInterceptors.end()) + { + // log off the interception from its interception object + (*aIter)->dispose(); + // remove the interceptor from our array + m_aControlDispatchInterceptors.erase(aIter); + } +} + + +void FormController::implInvalidateCurrentControlDependentFeatures() +{ + Sequence< sal_Int16 > aCurrentControlDependentFeatures + { + FormFeature::SortAscending, + FormFeature::SortDescending, + FormFeature::AutoFilter, + FormFeature::RefreshCurrentControl + }; + + invalidateFeatures( aCurrentControlDependentFeatures ); +} + + +void SAL_CALL FormController::columnChanged( const EventObject& /*_event*/ ) +{ + implInvalidateCurrentControlDependentFeatures(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/formcontrolling.cxx b/svx/source/form/formcontrolling.cxx new file mode 100644 index 000000000..221ae3584 --- /dev/null +++ b/svx/source/form/formcontrolling.cxx @@ -0,0 +1,497 @@ +/* -*- 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/macros.h> +#include <formcontrolling.hxx> +#include <fmurl.hxx> +#include <svx/svxids.hrc> +#include <fmprop.hxx> +#include <formcontroller.hxx> +#include <svx/fmtools.hxx> + +#include <com/sun/star/form/runtime/FormOperations.hpp> +#include <com/sun/star/form/runtime/FormFeature.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/sdbc/SQLException.hpp> + +#include <tools/diagnose_ex.h> +#include <comphelper/anytostring.hxx> +#include <comphelper/processfactory.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <osl/diagnose.h> + +#include <algorithm> + + +namespace svx +{ + + + using ::com::sun::star::uno::Reference; + using ::com::sun::star::form::runtime::XFormController; + using ::com::sun::star::form::runtime::FormOperations; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::sdbc::XRowSet; + using ::com::sun::star::form::runtime::FeatureState; + using ::com::sun::star::uno::Any; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::beans::NamedValue; + using ::com::sun::star::beans::XPropertySet; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::sdbc::SQLException; + using ::com::sun::star::sdb::SQLErrorEvent; + using ::com::sun::star::lang::EventObject; + + namespace FormFeature = ::com::sun::star::form::runtime::FormFeature; + + + //= FeatureSlotTranslation + + namespace + { + struct FeatureDescription + { + OUString sURL; // the URL + sal_Int32 nSlotId; // the SFX-compatible slot ID + sal_Int16 nFormFeature; // the css.form.runtime.FormFeature ID + }; + typedef ::std::vector< FeatureDescription > FeatureDescriptions; + + + const FeatureDescriptions& getFeatureDescriptions() + { + static const FeatureDescriptions s_aFeatureDescriptions({ + { OUString(FMURL_FORM_POSITION), SID_FM_RECORD_ABSOLUTE, FormFeature::MoveAbsolute }, + { OUString(FMURL_FORM_RECORDCOUNT), SID_FM_RECORD_TOTAL, FormFeature::TotalRecords }, + { OUString(FMURL_RECORD_MOVEFIRST), SID_FM_RECORD_FIRST, FormFeature::MoveToFirst }, + { OUString(FMURL_RECORD_MOVEPREV), SID_FM_RECORD_PREV, FormFeature::MoveToPrevious }, + { OUString(FMURL_RECORD_MOVENEXT), SID_FM_RECORD_NEXT, FormFeature::MoveToNext }, + { OUString(FMURL_RECORD_MOVELAST), SID_FM_RECORD_LAST, FormFeature::MoveToLast }, + { OUString(FMURL_RECORD_MOVETONEW), SID_FM_RECORD_NEW, FormFeature::MoveToInsertRow }, + { OUString(FMURL_RECORD_SAVE), SID_FM_RECORD_SAVE, FormFeature::SaveRecordChanges }, + { OUString(FMURL_RECORD_DELETE), SID_FM_RECORD_DELETE, FormFeature::DeleteRecord }, + { OUString(FMURL_FORM_REFRESH), SID_FM_REFRESH, FormFeature::ReloadForm }, + { OUString(FMURL_FORM_REFRESH_CURRENT_CONTROL), + SID_FM_REFRESH_FORM_CONTROL,FormFeature::RefreshCurrentControl }, + { OUString(FMURL_RECORD_UNDO), SID_FM_RECORD_UNDO, FormFeature::UndoRecordChanges }, + { OUString(FMURL_FORM_SORT_UP), SID_FM_SORTUP, FormFeature::SortAscending }, + { OUString(FMURL_FORM_SORT_DOWN), SID_FM_SORTDOWN, FormFeature::SortDescending }, + { OUString(FMURL_FORM_SORT), SID_FM_ORDERCRIT, FormFeature::InteractiveSort }, + { OUString(FMURL_FORM_AUTO_FILTER), SID_FM_AUTOFILTER, FormFeature::AutoFilter }, + { OUString(FMURL_FORM_FILTER), SID_FM_FILTERCRIT, FormFeature::InteractiveFilter }, + { OUString(FMURL_FORM_APPLY_FILTER), SID_FM_FORM_FILTERED, FormFeature::ToggleApplyFilter }, + { OUString(FMURL_FORM_REMOVE_FILTER), SID_FM_REMOVE_FILTER_SORT, FormFeature::RemoveFilterAndSort } + }); + return s_aFeatureDescriptions; + } + } + + + namespace + { + + struct MatchFeatureDescriptionByURL + { + const OUString& m_rURL; + explicit MatchFeatureDescriptionByURL( const OUString& _rURL ) :m_rURL( _rURL ) { } + + bool operator()( const FeatureDescription& _compare ) + { + return m_rURL == _compare.sURL; + } + }; + + + struct MatchFeatureDescriptionBySlotId + { + sal_Int32 m_nSlotId; + explicit MatchFeatureDescriptionBySlotId( sal_Int32 _nSlotId ) :m_nSlotId( _nSlotId ) { } + + bool operator()( const FeatureDescription& _compare ) + { + return m_nSlotId == _compare.nSlotId; + } + }; + + + struct MatchFeatureDescriptionByFormFeature + { + sal_Int32 m_nFormFeature; + explicit MatchFeatureDescriptionByFormFeature( sal_Int32 _nFormFeature ) :m_nFormFeature( _nFormFeature ) { } + + bool operator()( const FeatureDescription& _compare ) + { + return m_nFormFeature == _compare.nFormFeature; + } + }; + + + struct FormFeatureToSlotId + { + sal_Int32 operator()( sal_Int16 FormFeature ) + { + return FeatureSlotTranslation::getSlotIdForFormFeature( FormFeature ); + } + }; + } + + + sal_Int32 FeatureSlotTranslation::getControllerFeatureSlotIdForURL( const OUString& _rMainURL ) + { + const FeatureDescriptions& rDescriptions( getFeatureDescriptions() ); + FeatureDescriptions::const_iterator pos = ::std::find_if( rDescriptions.begin(), rDescriptions.end(), MatchFeatureDescriptionByURL( _rMainURL ) ); + return ( pos != rDescriptions.end() ) ? pos->nSlotId : -1; + } + + + sal_Int16 FeatureSlotTranslation::getFormFeatureForSlotId( sal_Int32 _nSlotId ) + { + const FeatureDescriptions& rDescriptions( getFeatureDescriptions() ); + FeatureDescriptions::const_iterator pos = ::std::find_if( rDescriptions.begin(), rDescriptions.end(), MatchFeatureDescriptionBySlotId( _nSlotId ) ); + OSL_ENSURE( pos != rDescriptions.end(), "FeatureSlotTranslation::getFormFeatureForSlotId: not found!" ); + return ( pos != rDescriptions.end() ) ? pos->nFormFeature : -1; + } + + + sal_Int32 FeatureSlotTranslation::getSlotIdForFormFeature( sal_Int16 _nFormFeature ) + { + const FeatureDescriptions& rDescriptions( getFeatureDescriptions() ); + FeatureDescriptions::const_iterator pos = ::std::find_if( rDescriptions.begin(), rDescriptions.end(), MatchFeatureDescriptionByFormFeature( _nFormFeature ) ); + OSL_ENSURE( pos != rDescriptions.end(), "FeatureSlotTranslation::getSlotIdForFormFeature: not found!" ); + return ( pos != rDescriptions.end() ) ? pos->nSlotId : -1; + } + + ControllerFeatures::ControllerFeatures( IControllerFeatureInvalidation* _pInvalidationCallback ) + :m_pInvalidationCallback( _pInvalidationCallback ) + { + } + + + ControllerFeatures::ControllerFeatures( const Reference< XFormController >& _rxController ) + :m_pInvalidationCallback( nullptr ) + { + assign( _rxController ); + } + + + void ControllerFeatures::assign( const Reference< XFormController >& _rxController ) + { + dispose(); + m_pImpl = new FormControllerHelper( _rxController, m_pInvalidationCallback ); + } + + + ControllerFeatures::~ControllerFeatures() + { + dispose(); + } + + + void ControllerFeatures::dispose() + { + if ( m_pImpl.is() ) + { + m_pImpl->dispose(); + m_pImpl.clear(); + } + } + + FormControllerHelper::FormControllerHelper( const Reference< XFormController >& _rxController, IControllerFeatureInvalidation* _pInvalidationCallback ) + :m_pInvalidationCallback( _pInvalidationCallback ) + { + osl_atomic_increment( &m_refCount ); + try + { + m_xFormOperations = FormOperations::createWithFormController( comphelper::getProcessComponentContext(), _rxController ); + if ( m_xFormOperations.is() ) + m_xFormOperations->setFeatureInvalidation( this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + osl_atomic_decrement( &m_refCount ); + } + + + FormControllerHelper::~FormControllerHelper( ) + { + try + { + acquire(); + dispose(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void FormControllerHelper::dispose() + { + if ( m_xFormOperations.is() ) + m_xFormOperations->dispose(); + m_xFormOperations.clear(); + } + + + bool FormControllerHelper::isEnabled( sal_Int32 _nSlotId ) const + { + if ( !m_xFormOperations.is() ) + return false; + return m_xFormOperations->isEnabled( FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ) ); + } + + + Reference< XRowSet > FormControllerHelper::getCursor() const + { + Reference< XRowSet > xCursor; + if ( m_xFormOperations.is() ) + xCursor = m_xFormOperations->getCursor(); + return xCursor; + } + + + void FormControllerHelper::getState( sal_Int32 _nSlotId, FeatureState& _rState ) const + { + if ( m_xFormOperations.is() ) + _rState = m_xFormOperations->getState( FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ) ); + } + + + bool FormControllerHelper::commitCurrentControl( ) const + { + return impl_operateForm_nothrow( COMMIT_CONTROL ); + } + + + bool FormControllerHelper::commitCurrentRecord() const + { + return impl_operateForm_nothrow( COMMIT_RECORD ); + } + + + void FormControllerHelper::execute( sal_Int32 _nSlotId, const OUString& _rParamName, const Any& _rParamValue ) const + { + Sequence< NamedValue > aArguments { { _rParamName, _rParamValue } }; + impl_operateForm_nothrow( EXECUTE_ARGS, FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ), aArguments ); + } + + + bool FormControllerHelper::impl_operateForm_nothrow( const FormOperation _eWhat, const sal_Int16 _nFeature, + const Sequence< NamedValue >& _rArguments ) const + { + if ( !m_xFormOperations.is() ) + return false; + + Any aError; + bool bSuccess = false; + const_cast< FormControllerHelper* >( this )->m_aOperationError.clear(); + try + { + // to prevent the controller from displaying any error messages which happen while we operate on it, + // we add ourself as XSQLErrorListener. By contract, a FormController displays errors if and only if + // no SQLErrorListeners are registered. + m_xFormOperations->getController()->addSQLErrorListener( const_cast< FormControllerHelper* >(this) ); + + switch ( _eWhat ) + { + case COMMIT_CONTROL: + bSuccess = m_xFormOperations->commitCurrentControl(); + break; + + case COMMIT_RECORD: + { + sal_Bool bDummy( false ); + bSuccess = m_xFormOperations->commitCurrentRecord( bDummy ); + } + break; + + case EXECUTE: + m_xFormOperations->execute( _nFeature ); + bSuccess = true; + break; + + case EXECUTE_ARGS: + m_xFormOperations->executeWithArguments( _nFeature, _rArguments ); + bSuccess = true; + break; + } + } + catch ( const SQLException& ) + { + m_xFormOperations->getController()->removeSQLErrorListener( const_cast< FormControllerHelper* >(this) ); + aError = ::cppu::getCaughtException(); + } + catch( const Exception& ) + { + m_xFormOperations->getController()->removeSQLErrorListener( const_cast< FormControllerHelper* >(this) ); + SQLException aFallbackError; + aFallbackError.Message = ::comphelper::anyToString( ::cppu::getCaughtException() ); + aError <<= aFallbackError; + } + + if ( bSuccess ) + return true; + + // display the error. Prefer the one reported in errorOccurred over the one caught. + if ( m_aOperationError.hasValue() ) + displayException(m_aOperationError, svxform::FormController::getDialogParentWindow(m_xFormOperations->getController())); + else if ( aError.hasValue() ) + displayException(aError, svxform::FormController::getDialogParentWindow(m_xFormOperations->getController())); + else + OSL_FAIL( "FormControllerHelper::impl_operateForm_nothrow: no success, but no error?" ); + + return false; + } + + + void FormControllerHelper::execute( sal_Int32 _nSlotId ) const + { + impl_operateForm_nothrow( EXECUTE, FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ), + Sequence< NamedValue >() ); + } + + + void SAL_CALL FormControllerHelper::invalidateFeatures( const Sequence< ::sal_Int16 >& Features ) + { + if ( !m_pInvalidationCallback ) + // nobody's interested in ... + return; + + ::std::vector< sal_Int32 > aFeatures( Features.getLength() ); + ::std::transform( + Features.begin(), + Features.end(), + aFeatures.begin(), + FormFeatureToSlotId() + ); + + m_pInvalidationCallback->invalidateFeatures( aFeatures ); + } + + + void SAL_CALL FormControllerHelper::invalidateAllFeatures() + { + if ( !m_pInvalidationCallback ) + // nobody's interested in ... + return; + + // actually, it's a little bit more than the supported features, + // but on the medium term, we are to support everything listed + // here + ::std::vector< sal_Int32 > aSupportedFeatures; + const sal_Int32 pSupportedFeatures[] = + { + SID_FM_RECORD_FIRST, + SID_FM_RECORD_NEXT, + SID_FM_RECORD_PREV, + SID_FM_RECORD_LAST, + SID_FM_RECORD_NEW, + SID_FM_RECORD_DELETE, + SID_FM_RECORD_ABSOLUTE, + SID_FM_RECORD_TOTAL, + SID_FM_RECORD_SAVE, + SID_FM_RECORD_UNDO, + SID_FM_REMOVE_FILTER_SORT, + SID_FM_SORTUP, + SID_FM_SORTDOWN, + SID_FM_ORDERCRIT, + SID_FM_AUTOFILTER, + SID_FM_FILTERCRIT, + SID_FM_FORM_FILTERED, + SID_FM_REFRESH, + SID_FM_REFRESH_FORM_CONTROL, + SID_FM_SEARCH, + SID_FM_FILTER_START, + SID_FM_VIEW_AS_GRID + }; + sal_Int32 nFeatureCount = SAL_N_ELEMENTS( pSupportedFeatures ); + aSupportedFeatures.reserve(nFeatureCount); // work around GCC12 spurious -Werror=stringop-overflow= + aSupportedFeatures.insert( aSupportedFeatures.begin(), pSupportedFeatures, pSupportedFeatures + nFeatureCount ); + + m_pInvalidationCallback->invalidateFeatures( aSupportedFeatures ); + } + + + void SAL_CALL FormControllerHelper::errorOccured( const SQLErrorEvent& Event ) + { + OSL_ENSURE( !m_aOperationError.hasValue(), "FormControllerHelper::errorOccurred: two errors during one operation?" ); + m_aOperationError = Event.Reason; + } + + + void SAL_CALL FormControllerHelper::disposing( const EventObject& /*_Source*/ ) + { + // not interested in + } + + + bool FormControllerHelper::isInsertionRow() const + { + bool bIs = false; + if ( m_xFormOperations.is() ) + bIs = m_xFormOperations->isInsertionRow(); + return bIs; + } + + + bool FormControllerHelper::isModifiedRow() const + { + bool bIs = false; + if ( m_xFormOperations.is() ) + bIs = m_xFormOperations->isModifiedRow(); + return bIs; + } + + bool FormControllerHelper::canDoFormFilter() const + { + if ( !m_xFormOperations.is() ) + return false; + + bool bCanDo = false; + try + { + Reference< XPropertySet > xCursorProperties( m_xFormOperations->getCursor(), UNO_QUERY_THROW ); + + bool bEscapeProcessing( false ); + OSL_VERIFY( xCursorProperties->getPropertyValue( FM_PROP_ESCAPE_PROCESSING ) >>= bEscapeProcessing ); + + OUString sActiveCommand; + OSL_VERIFY( xCursorProperties->getPropertyValue( FM_PROP_ACTIVECOMMAND ) >>= sActiveCommand ); + + bool bInsertOnlyForm( false ); + OSL_VERIFY( xCursorProperties->getPropertyValue( FM_PROP_INSERTONLY ) >>= bInsertOnlyForm ); + + bCanDo = bEscapeProcessing && !sActiveCommand.isEmpty() && !bInsertOnlyForm; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return bCanDo; + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/formdispatchinterceptor.cxx b/svx/source/form/formdispatchinterceptor.cxx new file mode 100644 index 000000000..cc75b0b01 --- /dev/null +++ b/svx/source/form/formdispatchinterceptor.cxx @@ -0,0 +1,176 @@ +/* -*- 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 <formdispatchinterceptor.hxx> + +namespace svxform +{ + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::frame::XDispatchProviderInterception; + using ::com::sun::star::frame::XDispatchProviderInterceptor; + using ::com::sun::star::lang::XComponent; + using ::com::sun::star::util::URL; + using ::com::sun::star::frame::XDispatch; + using ::com::sun::star::frame::DispatchDescriptor; + using ::com::sun::star::frame::XDispatchProvider; + using ::com::sun::star::lang::EventObject; + + DispatchInterceptionMultiplexer::DispatchInterceptionMultiplexer( + const Reference< XDispatchProviderInterception >& _rxToIntercept, DispatchInterceptor* _pMaster ) + :DispatchInterceptionMultiplexer_BASE(_pMaster && _pMaster->getInterceptorMutex() ? *_pMaster->getInterceptorMutex() : m_aFallback) + ,m_pMutex( _pMaster && _pMaster->getInterceptorMutex() ? _pMaster->getInterceptorMutex() : &m_aFallback ) + ,m_xIntercepted(_rxToIntercept) + ,m_bListening(false) + ,m_pMaster(_pMaster) + { + + ::osl::MutexGuard aGuard( *m_pMutex ); + osl_atomic_increment(&m_refCount); + if (_rxToIntercept.is()) + { + _rxToIntercept->registerDispatchProviderInterceptor(static_cast<XDispatchProviderInterceptor*>(this)); + // this should make us the top-level dispatch-provider for the component, via a call to our + // setDispatchProvider we should have got a fallback for requests we (i.e. our master) cannot fulfill + Reference< XComponent> xInterceptedComponent(_rxToIntercept, UNO_QUERY); + if (xInterceptedComponent.is()) + { + xInterceptedComponent->addEventListener(this); + m_bListening = true; + } + } + osl_atomic_decrement(&m_refCount); + } + + + DispatchInterceptionMultiplexer::~DispatchInterceptionMultiplexer() + { + if (!rBHelper.bDisposed) + dispose(); + + } + + + Reference< XDispatch > SAL_CALL DispatchInterceptionMultiplexer::queryDispatch( const URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags ) + { + ::osl::MutexGuard aGuard( *m_pMutex ); + Reference< XDispatch> xResult; + // ask our 'real' interceptor + if (m_pMaster) + xResult = m_pMaster->interceptedQueryDispatch( aURL, aTargetFrameName, nSearchFlags); + + // ask our slave provider + if (!xResult.is() && m_xSlaveDispatcher.is()) + xResult = m_xSlaveDispatcher->queryDispatch(aURL, aTargetFrameName, nSearchFlags); + + return xResult; + } + + + Sequence< Reference< XDispatch > > SAL_CALL + DispatchInterceptionMultiplexer::queryDispatches( const Sequence< DispatchDescriptor >& aDescripts ) + { + ::osl::MutexGuard aGuard( *m_pMutex ); + Sequence< Reference< XDispatch> > aReturn(aDescripts.getLength()); + std::transform(aDescripts.begin(), aDescripts.end(), aReturn.getArray(), + [this](const DispatchDescriptor& rDescript) -> Reference< XDispatch> { + return queryDispatch(rDescript.FeatureURL, rDescript.FrameName, rDescript.SearchFlags); }); + return aReturn; + } + + + Reference< XDispatchProvider > SAL_CALL DispatchInterceptionMultiplexer::getSlaveDispatchProvider( ) + { + ::osl::MutexGuard aGuard( *m_pMutex ); + return m_xSlaveDispatcher; + } + + + void SAL_CALL DispatchInterceptionMultiplexer::setSlaveDispatchProvider(const Reference< XDispatchProvider>& xNewDispatchProvider) + { + ::osl::MutexGuard aGuard( *m_pMutex ); + m_xSlaveDispatcher = xNewDispatchProvider; + } + + + Reference< XDispatchProvider> SAL_CALL DispatchInterceptionMultiplexer::getMasterDispatchProvider() + { + ::osl::MutexGuard aGuard( *m_pMutex ); + return m_xMasterDispatcher; + } + + + void SAL_CALL DispatchInterceptionMultiplexer::setMasterDispatchProvider(const Reference< XDispatchProvider>& xNewSupplier) + { + ::osl::MutexGuard aGuard( *m_pMutex ); + m_xMasterDispatcher = xNewSupplier; + } + + + void SAL_CALL DispatchInterceptionMultiplexer::disposing(const EventObject& Source) + { + if (m_bListening) + { + Reference< XDispatchProviderInterception > xIntercepted(m_xIntercepted.get(), UNO_QUERY); + if (Source.Source == xIntercepted) + ImplDetach(); + } + } + + + void DispatchInterceptionMultiplexer::ImplDetach() + { + ::osl::MutexGuard aGuard( *m_pMutex ); + OSL_ENSURE(m_bListening, "DispatchInterceptionMultiplexer::ImplDetach: invalid call!"); + + // deregister ourself from the interception component + Reference< XDispatchProviderInterception > xIntercepted(m_xIntercepted.get(), UNO_QUERY); + if (xIntercepted.is()) + xIntercepted->releaseDispatchProviderInterceptor(static_cast<XDispatchProviderInterceptor*>(this)); + + // m_xIntercepted.clear(); + // Don't reset m_xIntercepted: It may be needed by our owner to check for which object we were + // responsible. As we hold the object with a weak reference only, this should be no problem. + // 88936 - 23.07.2001 - frank.schoenheit@sun.com + m_pMaster = nullptr; + m_pMutex = &m_aFallback; + m_bListening = false; + } + + + void DispatchInterceptionMultiplexer::disposing() + { + // remove ourself as event listener from the interception component + if (m_bListening) + { + Reference< XComponent> xInterceptedComponent(m_xIntercepted.get(), UNO_QUERY); + if (xInterceptedComponent.is()) + xInterceptedComponent->removeEventListener(static_cast<XEventListener*>(this)); + + // detach from the interception component + ImplDetach(); + } + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/formfeaturedispatcher.cxx b/svx/source/form/formfeaturedispatcher.cxx new file mode 100644 index 000000000..b90cd4c92 --- /dev/null +++ b/svx/source/form/formfeaturedispatcher.cxx @@ -0,0 +1,194 @@ +/* -*- 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 <formfeaturedispatcher.hxx> + +#include <comphelper/namedvaluecollection.hxx> +#include <tools/diagnose_ex.h> + + +namespace svx +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::util; + using namespace ::com::sun::star::form::runtime; + + OSingleFeatureDispatcher::OSingleFeatureDispatcher( const URL& _rFeatureURL, const sal_Int16 _nFormFeature, + const Reference< XFormOperations >& _rxFormOperations, ::osl::Mutex& _rMutex ) + :m_rMutex( _rMutex ) + ,m_aStatusListeners( _rMutex ) + ,m_xFormOperations( _rxFormOperations ) + ,m_aFeatureURL( _rFeatureURL ) + ,m_nFormFeature( _nFormFeature ) + ,m_bLastKnownEnabled( false ) + { + } + + + void OSingleFeatureDispatcher::getUnoState( FeatureStateEvent& /* [out] */ _rState ) const + { + _rState.Source = *const_cast< OSingleFeatureDispatcher* >( this ); + + FeatureState aState( m_xFormOperations->getState( m_nFormFeature ) ); + + _rState.FeatureURL = m_aFeatureURL; + _rState.IsEnabled = aState.Enabled; + _rState.Requery = false; + _rState.State = aState.State; + } + + + void OSingleFeatureDispatcher::updateAllListeners() + { + ::osl::ClearableMutexGuard aGuard( m_rMutex ); + + FeatureStateEvent aUnoState; + getUnoState( aUnoState ); + + if ( ( m_aLastKnownState == aUnoState.State ) && ( m_bLastKnownEnabled == bool(aUnoState.IsEnabled) ) ) + return; + + m_aLastKnownState = aUnoState.State; + m_bLastKnownEnabled = aUnoState.IsEnabled; + + notifyStatus( nullptr, aGuard ); + } + + + void OSingleFeatureDispatcher::notifyStatus( const Reference< XStatusListener >& _rxListener, ::osl::ClearableMutexGuard& _rFreeForNotification ) + { + FeatureStateEvent aUnoState; + getUnoState( aUnoState ); + + if ( _rxListener.is() ) + { + try + { + _rFreeForNotification.clear(); + _rxListener->statusChanged( aUnoState ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "OSingleFeatureDispatcher::notifyStatus" ); + } + } + else + { + ::comphelper::OInterfaceIteratorHelper3 aIter( m_aStatusListeners ); + _rFreeForNotification.clear(); + + while ( aIter.hasMoreElements() ) + { + try + { + aIter.next()->statusChanged( aUnoState ); + } + catch( const DisposedException& ) + { + TOOLS_WARN_EXCEPTION("svx.form", + "caught a DisposedException - removing the listener!"); + aIter.remove( ); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( + "svx.form", + "caught a generic exception while notifying a single listener!"); + } + } + } + } + + + void SAL_CALL OSingleFeatureDispatcher::dispatch( const URL& _rURL, const Sequence< PropertyValue >& _rArguments ) + { + ::osl::ClearableMutexGuard aGuard( m_rMutex ); + + OSL_ENSURE( _rURL.Complete == m_aFeatureURL.Complete, "OSingleFeatureDispatcher::dispatch: not responsible for this URL!" ); + + if ( !m_xFormOperations->isEnabled( m_nFormFeature ) ) + return; + + // release our mutex before executing the command + sal_Int16 nFormFeature( m_nFormFeature ); + Reference< XFormOperations > xFormOperations( m_xFormOperations ); + aGuard.clear(); + + try + { + if ( !_rArguments.hasElements() ) + { + xFormOperations->execute( nFormFeature ); + } + else + { // at the moment we only support one parameter + ::comphelper::NamedValueCollection aArgs( _rArguments ); + xFormOperations->executeWithArguments( nFormFeature, aArgs.getNamedValues() ); + } + } + catch( const RuntimeException& ) + { + throw; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void SAL_CALL OSingleFeatureDispatcher::addStatusListener( const Reference< XStatusListener >& _rxControl, const URL& _rURL ) + { + OSL_ENSURE( _rURL.Complete == m_aFeatureURL.Complete, "OSingleFeatureDispatcher::addStatusListener: unexpected URL!" ); + OSL_ENSURE( _rxControl.is(), "OSingleFeatureDispatcher::addStatusListener: senseless call!" ); + if ( !_rxControl.is() ) + return; + + ::osl::ClearableMutexGuard aGuard( m_rMutex ); + + m_aStatusListeners.addInterface( _rxControl ); + + // initially update the status + notifyStatus( _rxControl, aGuard ); + } + + + void SAL_CALL OSingleFeatureDispatcher::removeStatusListener( const Reference< XStatusListener >& _rxControl, const URL& _rURL ) + { + OSL_ENSURE( _rURL.Complete == m_aFeatureURL.Complete, "OSingleFeatureDispatcher::removeStatusListener: unexpected URL!" ); + OSL_ENSURE( _rxControl.is(), "OSingleFeatureDispatcher::removeStatusListener: senseless call!" ); + if ( !_rxControl.is() ) + return; + + ::osl::MutexGuard aGuard( m_rMutex ); + + m_aStatusListeners.removeInterface( _rxControl ); + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/formtoolbars.cxx b/svx/source/form/formtoolbars.cxx new file mode 100644 index 000000000..d46e7cc1b --- /dev/null +++ b/svx/source/form/formtoolbars.cxx @@ -0,0 +1,93 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <formtoolbars.hxx> + +#include <com/sun/star/beans/XPropertySet.hpp> +#include <osl/diagnose.h> +#include <tools/diagnose_ex.h> + +#include <svx/svxids.hrc> + + +namespace svxform +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::frame; + using namespace ::com::sun::star::beans; + + FormToolboxes::FormToolboxes( const Reference< XFrame >& _rxFrame ) + { + // the layout manager + Reference< XPropertySet > xFrameProps( _rxFrame, UNO_QUERY ); + if ( xFrameProps.is() ) + xFrameProps->getPropertyValue("LayoutManager") >>= m_xLayouter; + } + + + void FormToolboxes::toggleToolbox( sal_uInt16 _nSlotId ) const + { + try + { + Reference< XLayoutManager > xManager( m_xLayouter ); + OSL_ENSURE( xManager. is(), "FormToolboxes::toggleToolbox: couldn't obtain the layout manager!" ); + if ( xManager. is() ) + { + OUString sToolboxResource( getToolboxResourceName( _nSlotId ) ); + if ( xManager->isElementVisible( sToolboxResource ) ) + { + xManager->hideElement( sToolboxResource ); + xManager->destroyElement( sToolboxResource ); + } + else + { + xManager->createElement( sToolboxResource ); + xManager->showElement( sToolboxResource ); + } + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FormToolboxes::toggleToolbox" ); + } + } + + + bool FormToolboxes::isToolboxVisible( sal_uInt16 _nSlotId ) const + { + return m_xLayouter.is() && m_xLayouter->isElementVisible( + getToolboxResourceName( _nSlotId ) ); + } + + + OUString FormToolboxes::getToolboxResourceName( sal_uInt16 _nSlotId ) + { + OSL_ENSURE( _nSlotId == SID_FM_FORM_DESIGN_TOOLS , + "FormToolboxes::getToolboxResourceName: unsupported slot!" ); + + return "private:resource/toolbar/formdesign"; + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/labelitemwindow.cxx b/svx/source/form/labelitemwindow.cxx new file mode 100644 index 000000000..77965cbd4 --- /dev/null +++ b/svx/source/form/labelitemwindow.cxx @@ -0,0 +1,45 @@ +/* -*- 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 <svx/labelitemwindow.hxx> + +LabelItemWindow::LabelItemWindow(vcl::Window* pParent, const OUString& rLabel) + : InterimItemWindow(pParent, "svx/ui/labelbox.ui", "LabelBox") + , m_xLabel(m_xBuilder->weld_label("label")) +{ + InitControlBase(m_xLabel.get()); + + m_xLabel->set_label(rLabel); + + SetOptimalSize(); + + m_xLabel->set_toolbar_background(); +} + +void LabelItemWindow::SetOptimalSize() +{ + Size aSize(m_xLabel->get_preferred_size()); + aSize.AdjustWidth(12); + + SetSizePixel(aSize); +} + +void LabelItemWindow::set_label(const OUString& rLabel) { m_xLabel->set_label(rLabel); } + +OUString LabelItemWindow::get_label() const { return m_xLabel->get_label(); } + +void LabelItemWindow::dispose() +{ + m_xLabel.reset(); + InterimItemWindow::dispose(); +} + +LabelItemWindow::~LabelItemWindow() { disposeOnce(); } + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/svx/source/form/legacyformcontroller.cxx b/svx/source/form/legacyformcontroller.cxx new file mode 100644 index 000000000..94b2ae983 --- /dev/null +++ b/svx/source/form/legacyformcontroller.cxx @@ -0,0 +1,201 @@ +/* -*- 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 <fmservs.hxx> + +#include <com/sun/star/form/XFormController.hpp> +#include <com/sun/star/form/runtime/FormController.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> + +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <comphelper/processfactory.hxx> + + +namespace svxform +{ + + + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::uno::XComponentContext; + using ::com::sun::star::lang::XMultiServiceFactory; + using ::com::sun::star::awt::XControl; + using ::com::sun::star::awt::XTabControllerModel; + using ::com::sun::star::awt::XControlContainer; + using ::com::sun::star::lang::XServiceInfo; + using ::com::sun::star::form::runtime::FormController; + + using namespace ::com::sun::star; + + + //= LegacyFormController + + typedef ::cppu::WeakImplHelper < form::XFormController + , XServiceInfo + > LegacyFormController_Base; + + namespace { + + /** is an implementation of the legacy form controller service, namely css.form.FormController, supporting the + css.form.XFormController interface. + + This legacy API is superseded by css.form.runtime.(X)FormController, and though we migrated all OOo-internal + usage of this old API, their might be clients external to OOo still using it (though this is rather unlikely). + */ + class LegacyFormController : public LegacyFormController_Base + { + public: + static Reference< XInterface > Create( const Reference< XMultiServiceFactory >& _rxFactory ) + { + return *( new LegacyFormController( comphelper::getComponentContext(_rxFactory) ) ); + } + + protected: + explicit LegacyFormController( const Reference< XComponentContext >& _rxContext ) + :m_xDelegator( FormController::create(_rxContext) ) + { + } + + // form::XFormController + virtual Reference< XControl > SAL_CALL getCurrentControl( ) override; + virtual void SAL_CALL addActivateListener( const Reference< form::XFormControllerListener >& l ) override; + virtual void SAL_CALL removeActivateListener( const Reference< form::XFormControllerListener >& l ) override; + + // awt::XTabController + virtual void SAL_CALL setModel( const Reference< XTabControllerModel >& Model ) override; + virtual Reference< XTabControllerModel > SAL_CALL getModel( ) override; + virtual void SAL_CALL setContainer( const Reference< XControlContainer >& Container ) override; + virtual Reference< XControlContainer > SAL_CALL getContainer( ) override; + virtual Sequence< Reference< XControl > > SAL_CALL getControls( ) override; + virtual void SAL_CALL autoTabOrder( ) override; + virtual void SAL_CALL activateTabOrder( ) override; + virtual void SAL_CALL activateFirst( ) override; + virtual void SAL_CALL activateLast( ) override; + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override; + + private: + const Reference< form::runtime::XFormController > m_xDelegator; + }; + + } + + Reference< XControl > SAL_CALL LegacyFormController::getCurrentControl( ) + { + return m_xDelegator->getCurrentControl(); + } + + + void SAL_CALL LegacyFormController::addActivateListener( const Reference< form::XFormControllerListener >& _listener ) + { + m_xDelegator->addActivateListener( _listener ); + } + + + void SAL_CALL LegacyFormController::removeActivateListener( const Reference< form::XFormControllerListener >& _listener ) + { + m_xDelegator->removeActivateListener( _listener ); + } + + + void SAL_CALL LegacyFormController::setModel( const Reference< XTabControllerModel >& _model ) + { + m_xDelegator->setModel( _model ); + } + + + Reference< XTabControllerModel > SAL_CALL LegacyFormController::getModel( ) + { + return m_xDelegator->getModel(); + } + + + void SAL_CALL LegacyFormController::setContainer( const Reference< XControlContainer >& _container ) + { + m_xDelegator->setContainer( _container ); + } + + + Reference< XControlContainer > SAL_CALL LegacyFormController::getContainer( ) + { + return m_xDelegator->getContainer(); + } + + + Sequence< Reference< XControl > > SAL_CALL LegacyFormController::getControls( ) + { + return m_xDelegator->getControls(); + } + + + void SAL_CALL LegacyFormController::autoTabOrder( ) + { + m_xDelegator->autoTabOrder(); + } + + + void SAL_CALL LegacyFormController::activateTabOrder( ) + { + m_xDelegator->activateTabOrder(); + } + + + void SAL_CALL LegacyFormController::activateFirst( ) + { + m_xDelegator->activateFirst(); + } + + + void SAL_CALL LegacyFormController::activateLast( ) + { + m_xDelegator->activateLast(); + } + + + OUString SAL_CALL LegacyFormController::getImplementationName( ) + { + return "org.openoffice.comp.svx.LegacyFormController"; + } + + sal_Bool SAL_CALL LegacyFormController::supportsService( const OUString& _serviceName ) + { + return cppu::supportsService(this, _serviceName); + } + + Sequence< OUString > SAL_CALL LegacyFormController::getSupportedServiceNames( ) + { + return { "com.sun.star.form.FormController", "com.sun.star.awt.control.TabController" }; + } + +} + +css::uno::Reference< css::uno::XInterface > + LegacyFormController_NewInstance_Impl( const css::uno::Reference< css::lang::XMultiServiceFactory > & _rxORB ) +{ + return ::svxform::LegacyFormController::Create( _rxORB ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/navigatortree.cxx b/svx/source/form/navigatortree.cxx new file mode 100644 index 000000000..9ac6e6a87 --- /dev/null +++ b/svx/source/form/navigatortree.cxx @@ -0,0 +1,2044 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/fmshell.hxx> +#include <svx/fmmodel.hxx> +#include <svx/fmpage.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svditer.hxx> + +#include <helpids.h> +#include <fmexpl.hxx> +#include <fmshimp.hxx> +#include <fmservs.hxx> +#include <fmundo.hxx> +#include <fmpgeimp.hxx> +#include <fmobj.hxx> +#include <fmprop.hxx> +#include <sal/log.hxx> +#include <vcl/svapp.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/property.hxx> +#include <comphelper/types.hxx> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/sdb/CommandType.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/script/XEventAttacherManager.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/XTransferable.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <svx/sdrpaintwindow.hxx> + +#include <svx/strings.hrc> +#include <tools/diagnose_ex.h> +#include <svx/svxids.hrc> +#include <bitmaps.hlst> +#include <vcl/commandevent.hxx> + +namespace svxform +{ + #define EXPLORER_SYNC_DELAY 200 + // Time (in ms) until explorer synchronizes the view after select or deselect + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::form; + using namespace ::com::sun::star::awt; + using namespace ::com::sun::star::container; + using namespace ::com::sun::star::script; + using namespace ::com::sun::star::datatransfer; + using namespace ::com::sun::star::datatransfer::clipboard; + using namespace ::com::sun::star::sdb; + + + // helper + + + typedef ::std::map< Reference< XInterface >, SdrObject* > MapModelToShape; + + + static void collectShapeModelMapping( SdrPage const * _pPage, MapModelToShape& _rMapping ) + { + OSL_ENSURE( _pPage, "collectShapeModelMapping: invalid arg!" ); + + _rMapping.clear(); + + SdrObjListIter aIter( _pPage ); + while ( aIter.IsMore() ) + { + SdrObject* pSdrObject = aIter.Next(); + FmFormObj* pFormObject = FmFormObj::GetFormObject( pSdrObject ); + if ( !pFormObject ) + continue; + + Reference< XInterface > xNormalizedModel( pFormObject->GetUnoControlModel(), UNO_QUERY ); + // note that this is normalized (i.e. queried for XInterface explicitly) + + ::std::pair< MapModelToShape::iterator, bool > aPos = + _rMapping.emplace( xNormalizedModel, pSdrObject ); + DBG_ASSERT( aPos.second, "collectShapeModelMapping: model was already existent!" ); + // if this asserts, this would mean we have 2 shapes pointing to the same model + } + } + + NavigatorTreeDropTarget::NavigatorTreeDropTarget(NavigatorTree& rTreeView) + : DropTargetHelper(rTreeView.get_widget().get_drop_target()) + , m_rTreeView(rTreeView) + { + } + + sal_Int8 NavigatorTreeDropTarget::AcceptDrop(const AcceptDropEvent& rEvt) + { + sal_Int8 nAccept = m_rTreeView.AcceptDrop(rEvt); + + if (nAccept != DND_ACTION_NONE) + { + // to enable the autoscroll when we're close to the edges + weld::TreeView& rWidget = m_rTreeView.get_widget(); + rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr, true); + } + + return nAccept; + } + + sal_Int8 NavigatorTreeDropTarget::ExecuteDrop(const ExecuteDropEvent& rEvt) + { + return m_rTreeView.ExecuteDrop(rEvt); + } + + NavigatorTree::NavigatorTree(std::unique_ptr<weld::TreeView> xTreeView) + :m_xTreeView(std::move(xTreeView)) + ,m_aDropTargetHelper(*this) + ,m_aSynchronizeTimer("svx NavigatorTree m_aSynchronizeTimer") + ,nEditEvent(nullptr) + ,m_sdiState(SDI_DIRTY) + ,m_nSelectLock(0) + ,m_nFormsSelected(0) + ,m_nControlsSelected(0) + ,m_nHiddenControls(0) + ,m_bDragDataDirty(false) + ,m_bPrevSelectionMixed(false) + ,m_bRootSelected(false) + ,m_bInitialUpdate(true) + ,m_bKeyboardCut( false ) + ,m_bEditing( false ) + { + m_xTreeView->set_help_id(HID_FORM_NAVIGATOR); + m_xTreeView->set_size_request(200, 200); + + m_xTreeView->set_selection_mode(SelectionMode::Multiple); + + m_pNavModel.reset(new NavigatorTreeModel()); + Clear(); + + StartListening( *m_pNavModel ); + + m_aSynchronizeTimer.SetInvokeHandler(LINK(this, NavigatorTree, OnSynchronizeTimer)); + m_xTreeView->connect_changed(LINK(this, NavigatorTree, OnEntrySelDesel)); + m_xTreeView->connect_key_press(LINK(this, NavigatorTree, KeyInputHdl)); + m_xTreeView->connect_popup_menu(LINK(this, NavigatorTree, PopupMenuHdl)); + m_xTreeView->connect_editing(LINK(this, NavigatorTree, EditingEntryHdl), + LINK(this, NavigatorTree, EditedEntryHdl)); + m_xTreeView->connect_drag_begin(LINK(this, NavigatorTree, DragBeginHdl)); + } + + NavigatorTree::~NavigatorTree() + { + if( nEditEvent ) + Application::RemoveUserEvent( nEditEvent ); + + if (m_aSynchronizeTimer.IsActive()) + m_aSynchronizeTimer.Stop(); + + DBG_ASSERT(GetNavModel() != nullptr, "NavigatorTree::~NavigatorTree : unexpected : no ExplorerModel"); + EndListening( *m_pNavModel ); + Clear(); + m_pNavModel.reset(); + } + + void NavigatorTree::Clear() + { + m_pNavModel->Clear(); + } + + void NavigatorTree::UpdateContent( FmFormShell* pFormShell ) + { + if (m_bInitialUpdate) + { + GrabFocus(); + m_bInitialUpdate = false; + } + + FmFormShell* pOldShell = GetNavModel()->GetFormShell(); + FmFormPage* pOldPage = GetNavModel()->GetFormPage(); + FmFormPage* pNewPage = pFormShell ? pFormShell->GetCurPage() : nullptr; + + if ((pOldShell != pFormShell) || (pOldPage != pNewPage)) + { + // new shell during editing + if (IsEditingActive()) + { + m_xTreeView->end_editing(); + m_bEditing = false; + } + + m_bDragDataDirty = true; // as a precaution, although I don't drag + } + GetNavModel()->UpdateContent( pFormShell ); + + // if there is a form, expand root + if (m_xRootEntry && !m_xTreeView->get_row_expanded(*m_xRootEntry)) + m_xTreeView->expand_row(*m_xRootEntry); + // if there is EXACTLY ONE form, expand it too + if (m_xRootEntry) + { + std::unique_ptr<weld::TreeIter> xFirst(m_xTreeView->make_iterator(m_xRootEntry.get())); + bool bFirst = m_xTreeView->iter_children(*xFirst); + if (bFirst) + { + std::unique_ptr<weld::TreeIter> xSibling(m_xTreeView->make_iterator(xFirst.get())); + if (!m_xTreeView->iter_next_sibling(*xSibling)) + m_xTreeView->expand_row(*xFirst); + } + } + } + + bool NavigatorTree::implAllowExchange( sal_Int8 _nAction, bool* _pHasNonHidden ) + { + bool bCurEntry = m_xTreeView->get_cursor(nullptr); + if (!bCurEntry) + return false; + + // Information for AcceptDrop and Execute Drop + CollectSelectionData(SDI_ALL); + if (m_arrCurrentSelection.empty()) + // nothing to do + return false; + + // check whether there are only hidden controls + // I may add a format to pCtrlExch + bool bHasNonHidden = std::any_of(m_arrCurrentSelection.begin(), m_arrCurrentSelection.end(), + [this](const auto& rEntry) { + FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rEntry)); + return !IsHiddenControl( pCurrent ); + }); + + if ( bHasNonHidden && ( 0 == ( _nAction & DND_ACTION_MOVE ) ) ) + // non-hidden controls need to be moved + return false; + + if ( _pHasNonHidden ) + *_pHasNonHidden = bHasNonHidden; + + return true; + } + + bool NavigatorTree::implPrepareExchange( sal_Int8 _nAction ) + { + bool bHasNonHidden = false; + if ( !implAllowExchange( _nAction, &bHasNonHidden ) ) + return false; + + m_aControlExchange.prepareDrag(); + m_aControlExchange->setFocusEntry(m_xTreeView->get_cursor(nullptr)); + + for (const auto& rpEntry : m_arrCurrentSelection) + m_aControlExchange->addSelectedEntry(m_xTreeView->make_iterator(rpEntry.get())); + + m_aControlExchange->setFormsRoot( GetNavModel()->GetFormPage()->GetForms() ); + m_aControlExchange->buildPathFormat(m_xTreeView.get(), m_xRootEntry.get()); + + if (!bHasNonHidden) + { + // create a sequence + Sequence< Reference< XInterface > > seqIFaces(m_arrCurrentSelection.size()); + Reference< XInterface >* pArray = seqIFaces.getArray(); + for (const auto& rpEntry : m_arrCurrentSelection) + { + *pArray = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rpEntry))->GetElement(); + ++pArray; + } + // and the new format + m_aControlExchange->addHiddenControlsFormat(seqIFaces); + } + + m_bDragDataDirty = false; + return true; + } + + IMPL_LINK(NavigatorTree, DragBeginHdl, bool&, rUnsetDragIcon, bool) + { + rUnsetDragIcon = false; + + bool bSuccess = implPrepareExchange(DND_ACTION_COPYMOVE); + if (bSuccess) + { + OControlExchange& rExchange = *m_aControlExchange; + rtl::Reference<TransferDataContainer> xHelper(&rExchange); + m_xTreeView->enable_drag_source(xHelper, DND_ACTION_COPYMOVE); + rExchange.setDragging(true); + } + return !bSuccess; + } + + IMPL_LINK(NavigatorTree, PopupMenuHdl, const CommandEvent&, rEvt, bool) + { + bool bHandled = false; + switch( rEvt.GetCommand() ) + { + case CommandEventId::ContextMenu: + { + // Position of click + ::Point ptWhere; + if (rEvt.IsMouseEvent()) + { + ptWhere = rEvt.GetMousePosPixel(); + std::unique_ptr<weld::TreeIter> xClickedOn(m_xTreeView->make_iterator()); + if (!m_xTreeView->get_dest_row_at_pos(ptWhere, xClickedOn.get(), false)) + break; + if (!m_xTreeView->is_selected(*xClickedOn)) + { + m_xTreeView->unselect_all(); + m_xTreeView->select(*xClickedOn); + m_xTreeView->set_cursor(*xClickedOn); + } + } + else + { + if (m_arrCurrentSelection.empty()) // only happens with context menu via keyboard + break; + + std::unique_ptr<weld::TreeIter> xCurrent(m_xTreeView->make_iterator()); + if (!m_xTreeView->get_cursor(xCurrent.get())) + break; + ptWhere = m_xTreeView->get_row_area(*xCurrent).Center(); + } + + // update my selection data + CollectSelectionData(SDI_ALL); + + // if there is at least one no-root-entry and the root selected, I deselect root + if ( (m_arrCurrentSelection.size() > 1) && m_bRootSelected ) + { + const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin(); + m_xTreeView->set_cursor(*rIter); + m_xTreeView->unselect(*m_xRootEntry); + } + bool bSingleSelection = (m_arrCurrentSelection.size() == 1); + + + DBG_ASSERT( (!m_arrCurrentSelection.empty()) || m_bRootSelected, "no entries selected" ); + // shouldn't happen, because I would have selected one during call to IsSelected, + // if there was none before + + + // create menu + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + FmFormModel* pFormModel = pFormShell ? pFormShell->GetFormModel() : nullptr; + if( pFormShell && pFormModel ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "svx/ui/formnavimenu.ui")); + std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu("menu")); + std::unique_ptr<weld::Menu> xSubMenuNew(xBuilder->weld_menu("submenu")); + + // menu 'New' only exists, if only the root or only one form is selected + bool bShowNew = bSingleSelection && (m_nFormsSelected || m_bRootSelected); + if (!bShowNew) + xContextMenu->remove("new"); + + // 'New'\'Form' under the same terms + bool bShowForm = bSingleSelection && (m_nFormsSelected || m_bRootSelected); + if (bShowForm) + xSubMenuNew->append("form", SvxResId(RID_STR_FORM), RID_SVXBMP_FORM); + + // 'New'\'hidden...', if exactly one form is selected + bool bShowHidden = bSingleSelection && m_nFormsSelected; + if (bShowHidden) + xSubMenuNew->append("hidden", SvxResId(RID_STR_HIDDEN), RID_SVXBMP_HIDDEN); + + // 'Delete': everything which is not root can be removed + if (m_bRootSelected) + xContextMenu->remove("delete"); + + // 'Cut', 'Copy' and 'Paste' + bool bShowCut = !m_bRootSelected && implAllowExchange(DND_ACTION_MOVE); + if (!bShowCut) + xContextMenu->remove("cut"); + bool bShowCopy = !m_bRootSelected && implAllowExchange(DND_ACTION_COPY); + if (!bShowCopy) + xContextMenu->remove("copy"); + if (!implAcceptPaste()) + xContextMenu->remove("paste"); + + // TabDialog, if exactly one form + bool bShowTabOrder = bSingleSelection && m_nFormsSelected; + if (!bShowTabOrder) + xContextMenu->remove("taborder"); + + bool bShowProps = true; + // in XML forms, we don't allow for the properties of a form + // #i36484# + if (pFormShell->GetImpl()->isEnhancedForm_Lock() && !m_nControlsSelected) + bShowProps = false; + // if the property browser is already open, we don't allow for the properties, too + if (pFormShell->GetImpl()->IsPropBrwOpen_Lock()) + bShowProps = false; + + // and finally, if there's a mixed selection of forms and controls, disable the entry, too + if (bShowProps && !pFormShell->GetImpl()->IsPropBrwOpen_Lock()) + bShowProps = + (m_nControlsSelected && !m_nFormsSelected) || (!m_nControlsSelected && m_nFormsSelected); + + if (!bShowProps) + xContextMenu->remove("props"); + + // rename, if one element and no root + bool bShowRename = bSingleSelection && !m_bRootSelected; + if (!bShowRename) + xContextMenu->remove("rename"); + + if (!m_bRootSelected) + { + // Readonly-entry is only for root + xContextMenu->remove("designmode"); + // the same for automatic control focus + xContextMenu->remove("controlfocus"); + } + + std::unique_ptr<weld::Menu> xConversionMenu(xBuilder->weld_menu("changemenu")); + // ConvertTo-Slots are enabled, if one control is selected + // the corresponding slot is disabled + if (!m_bRootSelected && !m_nFormsSelected && (m_nControlsSelected == 1)) + { + FmXFormShell::GetConversionMenu_Lock(*xConversionMenu); +#if OSL_DEBUG_LEVEL > 0 + const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin(); + FmControlData* pCurrent = weld::fromId<FmControlData*>(m_xTreeView->get_id(*rIter)); + OSL_ENSURE( pFormShell->GetImpl()->isSolelySelected_Lock( pCurrent->GetFormComponent() ), + "NavigatorTree::Command: inconsistency between the navigator selection, and the selection as the shell knows it!" ); +#endif + + pFormShell->GetImpl()->checkControlConversionSlotsForCurrentSelection_Lock(*xConversionMenu); + } + else + xContextMenu->remove("change"); + + if (m_bRootSelected) + { + // set OpenReadOnly + xContextMenu->set_active("designmode", pFormModel->GetOpenInDesignMode()); + xContextMenu->set_active("controlfocus", pFormModel->GetAutoControlFocus()); + } + + OString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(ptWhere, ::Size(1, 1))); + if (sIdent == "form") + { + OUString aStr(SvxResId(RID_STR_FORM)); + OUString aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_INSERT).replaceAll("#", aStr); + + pFormModel->BegUndo(aUndoStr); + // slot was only available, if there is only one selected entry, + // which is a root or a form + const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin(); + NewForm(*rIter); + pFormModel->EndUndo(); + } + else if (sIdent == "hidden") + { + OUString aStr(SvxResId(RID_STR_CONTROL)); + OUString aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_INSERT).replaceAll("#", aStr); + + pFormModel->BegUndo(aUndoStr); + // slot was valid for (exactly) one selected form + const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin(); + NewControl(FM_COMPONENT_HIDDEN, *rIter, true); + pFormModel->EndUndo(); + } + else if (sIdent == "cut") + doCut(); + else if (sIdent == "copy") + doCopy(); + else if (sIdent == "paste") + doPaste(); + else if (sIdent == "delete") + DeleteSelection(); + else if (sIdent == "taborder") + { + // this slot was effective for exactly one selected form + const std::unique_ptr<weld::TreeIter>& rSelectedForm = *m_arrCurrentSelection.begin(); + DBG_ASSERT( IsFormEntry(*rSelectedForm), "NavigatorTree::Command: This entry must be a FormEntry." ); + + FmFormData* pFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(*rSelectedForm)); + const Reference< XForm >& xForm( pFormData->GetFormIface()); + + Reference< XTabControllerModel > xTabController(xForm, UNO_QUERY); + if( !xTabController.is() ) + break; + GetNavModel()->GetFormShell()->GetImpl()->ExecuteTabOrderDialog_Lock(xTabController); + } + else if (sIdent == "props") + ShowSelectionProperties(true); + else if (sIdent == "rename") + { + // only allowed for one no-root-entry + const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin(); + m_xTreeView->start_editing(*rIter); + m_bEditing = true; + } + else if (sIdent == "designmode") + { + pFormModel->SetOpenInDesignMode( !pFormModel->GetOpenInDesignMode() ); + pFormShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_OPEN_READONLY); + } + else if (sIdent == "controlfocus") + { + pFormModel->SetAutoControlFocus( !pFormModel->GetAutoControlFocus() ); + pFormShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_AUTOCONTROLFOCUS); + } + else if (FmXFormShell::isControlConversionSlot(sIdent)) + { + const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin(); + FmControlData* pCurrent = weld::fromId<FmControlData*>(m_xTreeView->get_id(*rIter)); + if (pFormShell->GetImpl()->executeControlConversionSlot_Lock(pCurrent->GetFormComponent(), sIdent)) + ShowSelectionProperties(); + } + } + bHandled = true; + } + break; + default: break; + } + + return bHandled; + } + + std::unique_ptr<weld::TreeIter> NavigatorTree::FindEntry(FmEntryData* pEntryData) + { + std::unique_ptr<weld::TreeIter> xRet; + if(!pEntryData) + return xRet; + + m_xTreeView->all_foreach([this, pEntryData, &xRet](weld::TreeIter& rEntry){ + FmEntryData* pCurEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rEntry)); + if (pCurEntryData && pCurEntryData->IsEqualWithoutChildren(pEntryData)) + { + xRet = m_xTreeView->make_iterator(&rEntry); + return true; + } + return false; + }); + + return xRet; + } + + void NavigatorTree::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) + { + if( auto pRemovedHint = dynamic_cast<const FmNavRemovedHint*>(&rHint) ) + { + FmEntryData* pEntryData = pRemovedHint->GetEntryData(); + Remove( pEntryData ); + } + else if( auto pInsertedHint = dynamic_cast<const FmNavInsertedHint*>(&rHint) ) + { + FmEntryData* pEntryData = pInsertedHint->GetEntryData(); + sal_uInt32 nRelPos = pInsertedHint->GetRelPos(); + Insert( pEntryData, nRelPos ); + } + else if( auto pReplacedHint = dynamic_cast<const FmNavModelReplacedHint*>(&rHint) ) + { + FmEntryData* pData = pReplacedHint->GetEntryData(); + std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pData); + if (xEntry) + { + // reset image + m_xTreeView->set_image(*xEntry, pData->GetNormalImage()); + } + } + else if( auto pNameChangedHint = dynamic_cast<const FmNavNameChangedHint*>(&rHint) ) + { + std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pNameChangedHint->GetEntryData()); + m_xTreeView->set_text(*xEntry, pNameChangedHint->GetNewName()); + } + else if( dynamic_cast<const FmNavClearedHint*>(&rHint) ) + { + m_aCutEntries.clear(); + if (m_aControlExchange.isDataExchangeActive()) + m_aControlExchange.clear(); + m_xTreeView->clear(); + + // default-entry "Forms" + OUString sText(SvxResId(RID_STR_FORMS)); + m_xRootEntry = m_xTreeView->make_iterator(); + m_xTreeView->insert(nullptr, -1, &sText, nullptr, nullptr, nullptr, + false, m_xRootEntry.get()); + m_xTreeView->set_image(*m_xRootEntry, RID_SVXBMP_FORMS); + m_xTreeView->set_sensitive(*m_xRootEntry, true); + } + else if (auto pSelectHint = dynamic_cast<FmNavRequestSelectHint*>(const_cast<SfxHint*>(&rHint))) + { + FmEntryDataArray& arredToSelect = pSelectHint->GetItems(); + SynchronizeSelection(arredToSelect); + + if (pSelectHint->IsMixedSelection()) + // in this case I deselect all, although the view had a mixed selection + // during next selection, I must adapt the navigator to the view + m_bPrevSelectionMixed = true; + } + } + + std::unique_ptr<weld::TreeIter> NavigatorTree::Insert(const FmEntryData* pEntryData, int nRelPos) + { + // insert current entry + std::unique_ptr<weld::TreeIter> xParentEntry = FindEntry( pEntryData->GetParent() ); + std::unique_ptr<weld::TreeIter> xNewEntry(m_xTreeView->make_iterator()); + OUString sId(weld::toId(pEntryData)); + + if(!xParentEntry) + { + m_xTreeView->insert(m_xRootEntry.get(), nRelPos, &pEntryData->GetText(), &sId, + nullptr, nullptr, false, xNewEntry.get()); + } + else + { + m_xTreeView->insert(xParentEntry.get(), nRelPos, &pEntryData->GetText(), &sId, + nullptr, nullptr, false, xNewEntry.get()); + } + + m_xTreeView->set_image(*xNewEntry, pEntryData->GetNormalImage()); + m_xTreeView->set_sensitive(*xNewEntry, true); + + // If root-entry, expand root + if (!xParentEntry) + m_xTreeView->expand_row(*m_xRootEntry); + + // insert children + FmEntryDataList* pChildList = pEntryData->GetChildList(); + size_t nChildCount = pChildList->size(); + for( size_t i = 0; i < nChildCount; i++ ) + { + FmEntryData* pChildData = pChildList->at( i ); + Insert(pChildData, -1); + } + + return xNewEntry; + } + + void NavigatorTree::Remove( FmEntryData* pEntryData ) + { + if( !pEntryData ) + return; + + // entry for the data + std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pEntryData); + if (!xEntry) + return; + + // delete entry from TreeListBox + // I'm not allowed, to treat the selection, which I trigger: + // select changes the MarkList of the view, if somebody else does this at the same time + // and removes a selection, we get a problem + // e.g. Group controls with open navigator + LockSelectionHandling(); + + // little problem: I remember the selected data, but if somebody deletes one of these entries, + // I get inconsistent... this would be bad + m_xTreeView->unselect(*xEntry); + + // selection can be modified during deletion, + // but because I disabled SelectionHandling, I have to do it later + auto nExpectedSelectionCount = m_xTreeView->count_selected_rows(); + + ModelHasRemoved(xEntry.get()); + m_xTreeView->remove(*xEntry); + + if (nExpectedSelectionCount != m_xTreeView->count_selected_rows()) + SynchronizeSelection(); + + // by default I treat the selection of course + UnlockSelectionHandling(); + } + + bool NavigatorTree::IsFormEntry(const weld::TreeIter& rEntry) + { + FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rEntry)); + return !pEntryData || dynamic_cast<const FmFormData*>( pEntryData) != nullptr; + } + + bool NavigatorTree::IsFormComponentEntry(const weld::TreeIter& rEntry) + { + FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rEntry)); + return dynamic_cast<const FmControlData*>( pEntryData) != nullptr; + } + + bool NavigatorTree::implAcceptPaste( ) + { + auto nSelectedEntries = m_xTreeView->count_selected_rows(); + if (nSelectedEntries != 1) + // no selected entry, or at least two selected entries + return false; + + // get the clipboard + TransferableDataHelper aClipboardContent(TransferableDataHelper::CreateFromClipboard(m_xTreeView->get_clipboard())); + + sal_Int8 nAction = m_aControlExchange.isClipboardOwner() && doingKeyboardCut( ) ? DND_ACTION_MOVE : DND_ACTION_COPY; + std::unique_ptr<weld::TreeIter> xSelected(m_xTreeView->make_iterator()); + if (!m_xTreeView->get_selected(xSelected.get())) + xSelected.reset(); + return nAction == implAcceptDataTransfer(aClipboardContent.GetDataFlavorExVector(), nAction, xSelected.get(), false); + } + + sal_Int8 NavigatorTree::implAcceptDataTransfer( const DataFlavorExVector& _rFlavors, sal_Int8 _nAction, const weld::TreeIter* _pTargetEntry, bool _bDnD ) + { + // no target -> no drop + if (!_pTargetEntry) + return DND_ACTION_NONE; + + // format check + bool bHasDefControlFormat = OControlExchange::hasFieldExchangeFormat( _rFlavors ); + bool bHasControlPathFormat = OControlExchange::hasControlPathFormat( _rFlavors ); + bool bHasHiddenControlsFormat = OControlExchange::hasHiddenControlModelsFormat( _rFlavors ); + if (!bHasDefControlFormat && !bHasControlPathFormat && !bHasHiddenControlsFormat) + return DND_ACTION_NONE; + + bool bSelfSource = _bDnD ? m_aControlExchange.isDragSource() : m_aControlExchange.isClipboardOwner(); + + if ( bHasHiddenControlsFormat ) + { // bHasHiddenControlsFormat means that only hidden controls are part of the data + + // hidden controls can be copied to a form only + if (m_xTreeView->iter_compare(*_pTargetEntry, *m_xRootEntry) == 0 || !IsFormEntry(*_pTargetEntry)) + return DND_ACTION_NONE; + + return bSelfSource ? ( DND_ACTION_COPYMOVE & _nAction ) : DND_ACTION_COPY; + } + + if ( !bSelfSource ) + { + // DnD or CnP crossing navigator boundaries + // The main problem here is that the current API does not allow us to sneak into the content which + // is to be inserted. So we have to allow it for the moment, but maybe reject later on (in the real drop). + + // TODO: this smart behaviour later on ... at the moment, we disallow data transfer crossing navigator + // boundaries. + + return DND_ACTION_NONE; + } + + DBG_ASSERT( _bDnD ? m_aControlExchange.isDragSource() : m_aControlExchange.isClipboardOwner(), + "NavigatorTree::implAcceptDataTransfer: here only with source=dest!" ); + // somebody changed the logic of this method ... + + // from here on, I can work with m_aControlExchange instead of _rData! + + bool bForeignCollection = m_aControlExchange->getFormsRoot().get() != GetNavModel()->GetFormPage()->GetForms().get(); + if ( bForeignCollection ) + { + // crossing shell/page boundaries, we can exchange hidden controls only + // But if we survived the checks above, we do not have hidden controls. + // -> no data transfer + DBG_ASSERT( !bHasHiddenControlsFormat, "NavigatorTree::implAcceptDataTransfer: still hidden controls format!" ); + // somebody changed the logic of this method ... + + return DND_ACTION_COPY; + } + + if (DND_ACTION_MOVE != _nAction) // 'normal' controls within a shell are moved only (never copied) + return DND_ACTION_NONE; + + if ( m_bDragDataDirty || !bHasDefControlFormat ) + { + if (!bHasControlPathFormat) + // I am in the shell/page, which has the controls, but I have no format, + // which survived the shell change (SVX_FM_CONTROLS_AS_PATH) + return DND_ACTION_NONE; + + // I must recreate the list of the ExchangeObjects, because the shell was changed during dragging + // (there are SvLBoxEntries in it, and we lost them during change) + m_aControlExchange->buildListFromPath(m_xTreeView.get(), m_xRootEntry.get()); + m_bDragDataDirty = false; + } + + // List of dropped entries from DragServer + const ListBoxEntrySet& rDropped = m_aControlExchange->selected(); + DBG_ASSERT(!rDropped.empty(), "NavigatorTree::implAcceptDataTransfer: no entries !"); + + bool bDropTargetIsComponent = IsFormComponentEntry( *_pTargetEntry ); + + // conditions to disallow the drop + // 0) the root entry is part of the list (can't DnD the root!) + // 1) one of the dragged entries is to be dropped onto its own parent + // 2) - " - is to be dropped onto itself + // 3) - " - is a Form and to be dropped onto one of its descendants + // 4) one of the entries is a control and to be dropped onto the root + // 5) a control or form will be dropped onto a control which is _not_ a sibling (dropping onto a sibling + // means moving the control) + + // collect the ancestors of the drop target (speeds up 3) + SvLBoxEntrySortedArray arrDropAncestors; + std::unique_ptr<weld::TreeIter> xLoop(m_xTreeView->make_iterator(_pTargetEntry)); + do + { + arrDropAncestors.emplace(m_xTreeView->make_iterator(xLoop.get())); + } + while (m_xTreeView->iter_parent(*xLoop)); + + for (const auto& rCurrent : rDropped) + { + // test for 0) + if (m_xTreeView->iter_compare(*rCurrent, *m_xRootEntry) == 0) + return DND_ACTION_NONE; + + std::unique_ptr<weld::TreeIter> xCurrentParent(m_xTreeView->make_iterator(rCurrent.get())); + m_xTreeView->iter_parent(*xCurrentParent); + + // test for 1) + if (m_xTreeView->iter_compare(*_pTargetEntry, *xCurrentParent) == 0) + return DND_ACTION_NONE; + + // test for 2) + if (m_xTreeView->iter_compare(*rCurrent, *_pTargetEntry) == 0) + return DND_ACTION_NONE; + + // test for 5) + if (bDropTargetIsComponent) + return DND_ACTION_NONE; + + // test for 3) + if (IsFormEntry(*rCurrent)) + { + auto aIter = std::find_if(arrDropAncestors.begin(), arrDropAncestors.end(), + [this, &rCurrent](const auto& rElem) { + return m_xTreeView->iter_compare(*rElem, *rCurrent) == 0; + }); + + if ( aIter != arrDropAncestors.end() ) + return DND_ACTION_NONE; + } + else if (IsFormComponentEntry(*rCurrent)) + { + // test for 4) + if (m_xTreeView->iter_compare(*_pTargetEntry, *m_xRootEntry) == 0) + return DND_ACTION_NONE; + } + } + return DND_ACTION_MOVE; + } + + sal_Int8 NavigatorTree::AcceptDrop( const AcceptDropEvent& rEvt ) + { + ::Point aDropPos = rEvt.maPosPixel; + std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator()); + // get_dest_row_at_pos with false cause we must drop exactly "on" a form to paste a control into it + if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false)) + xDropTarget.reset(); + return implAcceptDataTransfer(m_aDropTargetHelper.GetDataFlavorExVector(), rEvt.mnAction, xDropTarget.get(), true); + } + + sal_Int8 NavigatorTree::implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, const ::Point& _rDropPos, bool _bDnD ) + { + std::unique_ptr<weld::TreeIter> xDrop(m_xTreeView->make_iterator()); + // get_dest_row_at_pos with false cause we must drop exactly "on" a form to paste a control into it + if (!m_xTreeView->get_dest_row_at_pos(_rDropPos, xDrop.get(), false)) + xDrop.reset(); + return implExecuteDataTransfer( _rData, _nAction, xDrop.get(), _bDnD ); + } + + sal_Int8 NavigatorTree::implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, const weld::TreeIter* _pTargetEntry, bool _bDnD ) + { + const DataFlavorExVector& rDataFlavors = _rData.GetDataFlavorExVector(); + + if ( DND_ACTION_NONE == implAcceptDataTransfer( rDataFlavors, _nAction, _pTargetEntry, _bDnD ) ) + // under some platforms, it may happen that ExecuteDrop is called though AcceptDrop returned DND_ACTION_NONE + return DND_ACTION_NONE; + + if (!_pTargetEntry) + // no target -> no drop + return DND_ACTION_NONE; + + // format checks +#ifdef DBG_UTIL + bool bHasHiddenControlsFormat = OControlExchange::hasHiddenControlModelsFormat( rDataFlavors ); + bool bForeignCollection = _rData.getFormsRoot().get() != GetNavModel()->GetFormPage()->GetForms().get(); + DBG_ASSERT(!bForeignCollection || bHasHiddenControlsFormat, "NavigatorTree::implExecuteDataTransfer: invalid format (AcceptDrop shouldn't have let this pass) !"); + DBG_ASSERT(bForeignCollection || !m_bDragDataDirty, "NavigatorTree::implExecuteDataTransfer: invalid state (shell changed since last exchange resync) !"); + // this should be done in AcceptDrop: the list of controls is created in _rData + // and m_bDragDataDirty is reset +#endif + + if ( DND_ACTION_COPY == _nAction ) + { // bHasHiddenControlsFormat means that only hidden controls are part of the data +#ifdef DBG_UTIL + DBG_ASSERT( bHasHiddenControlsFormat, "NavigatorTree::implExecuteDataTransfer: copy allowed for hidden controls only!" ); +#endif + DBG_ASSERT( _pTargetEntry && m_xTreeView->iter_compare(*_pTargetEntry, *m_xRootEntry) != 0 && IsFormEntry( *_pTargetEntry ), + "NavigatorTree::implExecuteDataTransfer: should not be here!" ); + // implAcceptDataTransfer should have caught both cases + +#ifdef DBG_UTIL + DBG_ASSERT(bHasHiddenControlsFormat, "NavigatorTree::implExecuteDataTransfer: only copying of hidden controls is supported !"); + // should be caught by AcceptDrop +#endif + + // because i want to select all targets (and only them) + m_xTreeView->unselect_all(); + + const Sequence< Reference< XInterface > >& aControls = _rData.hiddenControls(); + sal_Int32 nCount = aControls.getLength(); + const Reference< XInterface >* pControls = aControls.getConstArray(); + + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + FmFormModel* pFormModel = pFormShell ? pFormShell->GetFormModel() : nullptr; + + // within undo + if (pFormModel) + { + OUString aStr(SvxResId(RID_STR_CONTROL)); + OUString aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_INSERT).replaceAll("#", aStr); + pFormModel->BegUndo(aUndoStr); + } + + // copy controls + for (sal_Int32 i=0; i<nCount; ++i) + { + // create new control + FmControlData* pNewControlData = NewControl( FM_COMPONENT_HIDDEN, *_pTargetEntry, false); + Reference< XPropertySet > xNewPropSet( pNewControlData->GetPropertySet() ); + + // copy properties form old control to new one + Reference< XPropertySet > xCurrent(pControls[i], UNO_QUERY); +#if (OSL_DEBUG_LEVEL > 0) + // check whether it is a hidden control + sal_Int16 nClassId = ::comphelper::getINT16(xCurrent->getPropertyValue(FM_PROP_CLASSID)); + OSL_ENSURE(nClassId == FormComponentType::HIDDENCONTROL, "NavigatorTree::implExecuteDataTransfer: invalid control in drop list !"); + // if SVX_FM_HIDDEN_CONTROLS-format exists, the sequence + // should only contain hidden controls +#endif // (OSL_DEBUG_LEVEL > 0) + Reference< XPropertySetInfo > xPropInfo( xCurrent->getPropertySetInfo()); + const Sequence< Property> seqAllCurrentProps = xPropInfo->getProperties(); + for (Property const & currentProp : seqAllCurrentProps) + { + if (((currentProp.Attributes & PropertyAttribute::READONLY) == 0) && (currentProp.Name != FM_PROP_NAME)) + { // (read-only attribs aren't set, ditto name, + // NewControl defined it uniquely + xNewPropSet->setPropertyValue(currentProp.Name, xCurrent->getPropertyValue(currentProp.Name)); + } + } + + std::unique_ptr<weld::TreeIter> xToSelect = FindEntry(pNewControlData); + m_xTreeView->select(*xToSelect); + if (i == 0) + m_xTreeView->set_cursor(*xToSelect); + } + + if (pFormModel) + pFormModel->EndUndo(); + + return _nAction; + } + + if ( !OControlExchange::hasFieldExchangeFormat( _rData.GetDataFlavorExVector() ) ) + { + // can't do anything without the internal format here ... usually happens when doing DnD or CnP + // over navigator boundaries + return DND_ACTION_NONE; + } + + // some data for the target + bool bDropTargetIsForm = IsFormEntry(*_pTargetEntry); + FmFormData* pTargetData = bDropTargetIsForm ? weld::fromId<FmFormData*>(m_xTreeView->get_id(*_pTargetEntry)) : nullptr; + + DBG_ASSERT( DND_ACTION_COPY != _nAction, "NavigatorTree::implExecuteDataTransfer: somebody changed the logics!" ); + + // list of dragged entries + const ListBoxEntrySet& rDropped = _rData.selected(); + DBG_ASSERT(!rDropped.empty(), "NavigatorTree::implExecuteDataTransfer: no entries!"); + + // make a copy because rDropped is updated on deleting an entry which we do in the processing loop + ListBoxEntrySet aDropped; + for (const auto& rEntry : rDropped) + aDropped.emplace(m_xTreeView->make_iterator(rEntry.get())); + + // shell and model + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + FmFormModel* pFormModel = pFormShell ? pFormShell->GetFormModel() : nullptr; + if (!pFormModel) + return DND_ACTION_NONE; + + // for Undo + const bool bUndo = pFormModel->IsUndoEnabled(); + + if( bUndo ) + { + OUString strUndoDescription(SvxResId(RID_STR_UNDO_CONTAINER_REPLACE)); + pFormModel->BegUndo(strUndoDescription); + } + + // remove selection before adding an entry, so the mark doesn't flicker + // -> lock action of selection + LockSelectionHandling(); + + // go through all dropped entries + for ( ListBoxEntrySet::const_iterator dropped = aDropped.begin(); + dropped != aDropped.end(); + ++dropped + ) + { + bool bFirstEntry = aDropped.begin() == dropped; + + // some data of the current element + const auto& rCurrent = *dropped; + DBG_ASSERT(rCurrent, "NavigatorTree::implExecuteDataTransfer: invalid entry"); + DBG_ASSERT(m_xTreeView->get_iter_depth(*rCurrent) != 0, "NavigatorTree::implExecuteDataTransfer: invalid entry"); + // don't drag root + + FmEntryData* pCurrentUserData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rCurrent)); + + Reference< XChild > xCurrentChild = pCurrentUserData->GetChildIFace(); + Reference< XIndexContainer > xContainer(xCurrentChild->getParent(), UNO_QUERY); + + FmFormData* pCurrentParentUserData = static_cast<FmFormData*>(pCurrentUserData->GetParent()); + DBG_ASSERT(pCurrentParentUserData == nullptr || dynamic_cast<const FmFormData*>(pCurrentUserData->GetParent()) != nullptr, "NavigatorTree::implExecuteDataTransfer: invalid parent"); + + // remove from parent + if (pCurrentParentUserData) + pCurrentParentUserData->GetChildList()->removeNoDelete( pCurrentUserData ); + else + GetNavModel()->GetRootList()->removeNoDelete( pCurrentUserData ); + + // remove from container + sal_Int32 nIndex = getElementPos(xContainer, xCurrentChild); + GetNavModel()->m_pPropChangeList->Lock(); + // UndoAction for removal + if ( bUndo && GetNavModel()->m_pPropChangeList->CanUndo()) + { + pFormModel->AddUndo(std::make_unique<FmUndoContainerAction>(*pFormModel, FmUndoContainerAction::Removed, + xContainer, xCurrentChild, nIndex)); + } + else if( !GetNavModel()->m_pPropChangeList->CanUndo() ) + { + FmUndoContainerAction::DisposeElement( xCurrentChild ); + } + + // copy events + Reference< XEventAttacherManager > xManager(xContainer, UNO_QUERY); + Sequence< ScriptEventDescriptor > aEvts; + + if (xManager.is() && nIndex >= 0) + aEvts = xManager->getScriptEvents(nIndex); + xContainer->removeByIndex(nIndex); + + // remove selection + m_xTreeView->unselect(*rCurrent); + // and delete it + Remove(pCurrentUserData); + + // position in DropParents, where to insert dropped entries + if (pTargetData) + xContainer.set(pTargetData->GetElement(), UNO_QUERY); + else + xContainer = GetNavModel()->GetForms(); + + // always insert at the end + nIndex = xContainer->getCount(); + + // UndoAction for insertion + if ( bUndo && GetNavModel()->m_pPropChangeList->CanUndo()) + pFormModel->AddUndo(std::make_unique<FmUndoContainerAction>(*pFormModel, FmUndoContainerAction::Inserted, + xContainer, xCurrentChild, nIndex)); + + // insert in new container + if (pTargetData) + { + // insert in a form needs a FormComponent + xContainer->insertByIndex( nIndex, + Any( Reference< XFormComponent >( xCurrentChild, UNO_QUERY ) ) ); + } + else + { + xContainer->insertByIndex( nIndex, + Any( Reference< XForm >( xCurrentChild, UNO_QUERY ) ) ); + } + + if (aEvts.hasElements()) + { + xManager.set(xContainer, UNO_QUERY); + if (xManager.is()) + xManager->registerScriptEvents(nIndex, aEvts); + } + + GetNavModel()->m_pPropChangeList->UnLock(); + + // give an entry the new parent + pCurrentUserData->SetParent(pTargetData); + + // give parent the new child + if (pTargetData) + pTargetData->GetChildList()->insert( std::unique_ptr<FmEntryData>(pCurrentUserData), nIndex ); + else + GetNavModel()->GetRootList()->insert( std::unique_ptr<FmEntryData>(pCurrentUserData), nIndex ); + + // announce to myself and reselect + std::unique_ptr<weld::TreeIter> xNew = Insert( pCurrentUserData, nIndex ); + if (bFirstEntry && xNew) + { + if (m_xTreeView->iter_parent(*xNew)) + m_xTreeView->expand_row(*xNew); + } + } + + UnlockSelectionHandling(); + + if( bUndo ) + pFormModel->EndUndo(); + + // During the move, the markings of the underlying view did not change (because the view is not affected by the logical + // hierarchy of the form/control models. But my selection changed - which means I have to adjust it according to the + // view marks, again. + SynchronizeSelection(); + + // in addition, with the move of controls such things as "the current form" may have changed - force the shell + // to update itself accordingly + if( pFormShell && pFormShell->GetImpl() && pFormShell->GetFormView() ) + pFormShell->GetImpl()->DetermineSelection_Lock( pFormShell->GetFormView()->GetMarkedObjectList() ); + + if ( m_aControlExchange.isClipboardOwner() && ( DND_ACTION_MOVE == _nAction ) ) + m_aControlExchange->clear(); + + return _nAction; + } + + sal_Int8 NavigatorTree::ExecuteDrop( const ExecuteDropEvent& rEvt ) + { + sal_Int8 nResult( DND_ACTION_NONE ); + if ( m_aControlExchange.isDragSource() ) + nResult = implExecuteDataTransfer( *m_aControlExchange, rEvt.mnAction, rEvt.maPosPixel, true ); + else + { + OControlTransferData aDroppedData( rEvt.maDropEvent.Transferable ); + nResult = implExecuteDataTransfer( aDroppedData, rEvt.mnAction, rEvt.maPosPixel, true ); + } + return nResult; + } + + void NavigatorTree::doPaste() + { + std::unique_ptr<weld::TreeIter> xSelected(m_xTreeView->make_iterator()); + if (!m_xTreeView->get_selected(xSelected.get())) + xSelected.reset(); + + try + { + if ( m_aControlExchange.isClipboardOwner() ) + { + implExecuteDataTransfer( *m_aControlExchange, doingKeyboardCut( ) ? DND_ACTION_MOVE : DND_ACTION_COPY, xSelected.get(), false ); + } + else + { + // the clipboard content + Reference< XClipboard > xClipboard(m_xTreeView->get_clipboard()); + Reference< XTransferable > xTransferable; + if ( xClipboard.is() ) + xTransferable = xClipboard->getContents(); + + OControlTransferData aClipboardContent( xTransferable ); + implExecuteDataTransfer( aClipboardContent, DND_ACTION_COPY, xSelected.get(), false ); + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "NavigatorTree::doPaste" ); + } + } + + void NavigatorTree::doCopy() + { + if ( implPrepareExchange( DND_ACTION_COPY ) ) + { + m_aControlExchange.setClipboardListener( LINK( this, NavigatorTree, OnClipboardAction ) ); + m_aControlExchange.copyToClipboard(*m_xTreeView); + } + } + + void NavigatorTree::ModelHasRemoved(const weld::TreeIter* pTypedEntry) + { + if (doingKeyboardCut()) + { + auto aIter = std::find_if(m_aCutEntries.begin(), m_aCutEntries.end(), + [this, pTypedEntry](const auto& rElem) { + return m_xTreeView->iter_compare(*rElem, *pTypedEntry) == 0; + }); + if (aIter != m_aCutEntries.end()) + m_aCutEntries.erase(aIter); + } + + if (m_aControlExchange.isDataExchangeActive()) + { + if (0 == m_aControlExchange->onEntryRemoved(m_xTreeView.get(), pTypedEntry)) + { + // last of the entries which we put into the clipboard has been deleted from the tree. + // Give up the clipboard ownership. + m_aControlExchange.clear(); + } + } + } + + void NavigatorTree::doCut() + { + if ( !implPrepareExchange( DND_ACTION_MOVE ) ) + return; + + m_aControlExchange.setClipboardListener( LINK( this, NavigatorTree, OnClipboardAction ) ); + m_aControlExchange.copyToClipboard(*m_xTreeView); + m_bKeyboardCut = true; + + // mark all the entries we just "cut" into the clipboard as "nearly moved" + for (const auto& rEntry : m_arrCurrentSelection ) + { + if (!rEntry) + continue; + m_aCutEntries.emplace(m_xTreeView->make_iterator(rEntry.get())); + m_xTreeView->set_sensitive(*rEntry, false); + } + } + + IMPL_LINK(NavigatorTree, KeyInputHdl, const ::KeyEvent&, rKEvt, bool) + { + const vcl::KeyCode& rCode = rKEvt.GetKeyCode(); + + // delete? + if (rCode.GetCode() == KEY_DELETE && !rCode.GetModifier()) + { + DeleteSelection(); + return true; + } + + // copy'n'paste? + switch ( rCode.GetFunction() ) + { + case KeyFuncType::CUT: + doCut(); + break; + + case KeyFuncType::PASTE: + if ( implAcceptPaste() ) + doPaste(); + break; + + case KeyFuncType::COPY: + doCopy(); + break; + + default: + break; + } + + return false; + } + + IMPL_LINK(NavigatorTree, EditingEntryHdl, const weld::TreeIter&, rIter, bool) + { + // root, which isn't allowed to be renamed, has UserData=NULL + m_bEditing = !m_xTreeView->get_id(rIter).isEmpty(); + return m_bEditing; + } + + void NavigatorTree::NewForm(const weld::TreeIter& rParentEntry) + { + // get ParentFormData + if (!IsFormEntry(rParentEntry)) + return; + + FmFormData* pParentFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(rParentEntry)); + + + // create new form + Reference<XComponentContext> xContext = comphelper::getProcessComponentContext(); + Reference< XForm > xNewForm(xContext->getServiceManager()->createInstanceWithContext(FM_SUN_COMPONENT_FORM, xContext), UNO_QUERY); + if (!xNewForm.is()) + return; + + Reference< XPropertySet > xPropertySet(xNewForm, UNO_QUERY); + if (!xPropertySet.is()) + return; + + FmFormData* pNewFormData = new FmFormData(xNewForm, pParentFormData); + + + // set name + OUString aName = GenerateName(pNewFormData); + pNewFormData->SetText(aName); + + try + { + xPropertySet->setPropertyValue( FM_PROP_NAME, Any(aName) ); + // a form should always have the command type table as default + xPropertySet->setPropertyValue( FM_PROP_COMMANDTYPE, Any(sal_Int32(CommandType::TABLE))); + } + catch ( const Exception& ) + { + OSL_FAIL("NavigatorTree::NewForm : could not set essential properties!"); + } + + + // insert form + GetNavModel()->Insert(pNewFormData, SAL_MAX_UINT32, true); + + + // set new form as active + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if( pFormShell ) + { + InterfaceBag aSelection; + aSelection.insert( Reference<XInterface>( xNewForm, UNO_QUERY ) ); + pFormShell->GetImpl()->setCurrentSelection_Lock(std::move(aSelection)); + + pFormShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_PROPERTIES, true, true); + } + GetNavModel()->SetModified(); + + // switch to EditMode + std::unique_ptr<weld::TreeIter> xNewEntry = FindEntry(pNewFormData); + m_xTreeView->start_editing(*xNewEntry); + m_bEditing = true; + } + + FmControlData* NavigatorTree::NewControl(const OUString& rServiceName, const weld::TreeIter& rParentEntry, bool bEditName) + { + // get ParentForm + if (!GetNavModel()->GetFormShell()) + return nullptr; + if (!IsFormEntry(rParentEntry)) + return nullptr; + + FmFormData* pParentFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(rParentEntry)); + Reference<XForm> xParentForm(pParentFormData->GetFormIface()); + + // create new component + Reference<XComponentContext> xContext = comphelper::getProcessComponentContext(); + Reference<XFormComponent> xNewComponent( xContext->getServiceManager()->createInstanceWithContext(rServiceName, xContext), UNO_QUERY); + if (!xNewComponent.is()) + return nullptr; + + FmControlData* pNewFormControlData = new FmControlData(xNewComponent, pParentFormData); + + // set name + OUString sName = FmFormPageImpl::setUniqueName( xNewComponent, xParentForm ); + + pNewFormControlData->SetText( sName ); + + // insert FormComponent + GetNavModel()->Insert(pNewFormControlData, SAL_MAX_UINT32, true); + GetNavModel()->SetModified(); + + if (bEditName) + { + // switch to EditMode + std::unique_ptr<weld::TreeIter> xNewEntry = FindEntry( pNewFormControlData ); + m_xTreeView->select(*xNewEntry); + + m_xTreeView->start_editing(*xNewEntry); + m_bEditing = true; + } + + return pNewFormControlData; + } + + OUString NavigatorTree::GenerateName( FmEntryData const * pEntryData ) + { + const sal_uInt16 nMaxCount = 99; + OUString aNewName; + + // create base name + OUString aBaseName; + if( dynamic_cast<const FmFormData*>( pEntryData) != nullptr ) + aBaseName = SvxResId( RID_STR_STDFORMNAME ); + else if( dynamic_cast<const FmControlData*>( pEntryData) != nullptr ) + aBaseName = SvxResId( RID_STR_CONTROL ); + + + // create new name + FmFormData* pFormParentData = static_cast<FmFormData*>(pEntryData->GetParent()); + + for( sal_Int32 i=0; i<nMaxCount; i++ ) + { + aNewName = aBaseName; + if( i>0 ) + { + aNewName += " " + OUString::number(i); + } + + if( GetNavModel()->FindData(aNewName, pFormParentData,false) == nullptr ) + break; + } + + return aNewName; + } + + IMPL_LINK(NavigatorTree, EditedEntryHdl, const IterString&, rIterString, bool) + { + m_bEditing = false; + + const weld::TreeIter& rIter = rIterString.first; + + FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rIter)); + bool bRes = NavigatorTreeModel::Rename(pEntryData, rIterString.second); + if (!bRes) + { + m_xEditEntry = m_xTreeView->make_iterator(&rIter); + nEditEvent = Application::PostUserEvent(LINK(this, NavigatorTree, OnEdit)); + } + + return bRes; + } + + IMPL_LINK_NOARG(NavigatorTree, OnEdit, void*, void) + { + nEditEvent = nullptr; + m_xTreeView->start_editing(*m_xEditEntry); + m_bEditing = true; + m_xEditEntry.reset(); + } + + IMPL_LINK_NOARG(NavigatorTree, OnEntrySelDesel, weld::TreeView&, void) + { + m_sdiState = SDI_DIRTY; + + if (IsSelectionHandlingLocked()) + return; + + if (m_aSynchronizeTimer.IsActive()) + m_aSynchronizeTimer.Stop(); + + m_aSynchronizeTimer.SetTimeout(EXPLORER_SYNC_DELAY); + m_aSynchronizeTimer.Start(); + } + + IMPL_LINK_NOARG(NavigatorTree, OnSynchronizeTimer, Timer *, void) + { + SynchronizeMarkList(); + } + + IMPL_LINK_NOARG(NavigatorTree, OnClipboardAction, OLocalExchange&, void) + { + if ( m_aControlExchange.isClipboardOwner() ) + return; + + if ( !doingKeyboardCut() ) + return; + + for (const auto& rEntry : m_aCutEntries) + { + if (!rEntry) + continue; + m_xTreeView->set_sensitive(*rEntry, true); + } + ListBoxEntrySet().swap(m_aCutEntries); + + m_bKeyboardCut = false; + } + + void NavigatorTree::ShowSelectionProperties(bool bForce) + { + // at first i need the FormShell + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if (!pFormShell) + // no shell -> impossible to set curObject -> leave + return; + + CollectSelectionData(SDI_ALL); + SAL_WARN_IF(static_cast<size_t>(m_nFormsSelected + m_nControlsSelected + + (m_bRootSelected ? 1 : 0)) != m_arrCurrentSelection.size(), + "svx.form", + "NavigatorTree::ShowSelectionProperties : selection meta data invalid !"); + + + InterfaceBag aSelection; + bool bSetSelectionAsMarkList = false; + + if (m_bRootSelected) + ; // no properties for the root, neither for single nor for multi selection + else if ( m_nFormsSelected + m_nControlsSelected == 0 ) // none of the two should be less 0 + ; // no selection -> no properties + else if ( m_nFormsSelected * m_nControlsSelected != 0 ) + ; // mixed selection -> no properties + else + { // either only forms, or only controls are selected + if (m_arrCurrentSelection.size() == 1) + { + const std::unique_ptr<weld::TreeIter>& rIter = *m_arrCurrentSelection.begin(); + if (m_nFormsSelected > 0) + { // exactly one form is selected + FmFormData* pFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(*rIter)); + aSelection.insert( Reference< XInterface >( pFormData->GetFormIface(), UNO_QUERY ) ); + } + else + { // exactly one control is selected (whatever hidden or normal) + FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rIter)); + + aSelection.insert( Reference< XInterface >( pEntryData->GetElement(), UNO_QUERY ) ); + } + } + else + { // it's a MultiSelection, so we must build a MultiSet + if (m_nFormsSelected > 0) + { // ... only forms + // first of all collect PropertySet-Interfaces of the forms + SvLBoxEntrySortedArray::const_iterator it = m_arrCurrentSelection.begin(); + for ( sal_Int32 i = 0; i < m_nFormsSelected; ++i ) + { + const std::unique_ptr<weld::TreeIter>& rIter = *it; + FmFormData* pFormData = weld::fromId<FmFormData*>(m_xTreeView->get_id(*rIter)); + aSelection.insert( pFormData->GetPropertySet() ); + ++it; + } + } + else + { // ... only controls + if (m_nHiddenControls == m_nControlsSelected) + { // a MultiSet for properties of hidden controls + SvLBoxEntrySortedArray::const_iterator it = m_arrCurrentSelection.begin(); + for ( sal_Int32 i = 0; i < m_nHiddenControls; ++i ) + { + const std::unique_ptr<weld::TreeIter>& rIter = *it; + FmEntryData* pEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rIter)); + aSelection.insert( pEntryData->GetPropertySet() ); + ++it; + } + } + else if (m_nHiddenControls == 0) + { // only normal controls + bSetSelectionAsMarkList = true; + } + } + } + + } + + // and now my form and my SelObject + if ( bSetSelectionAsMarkList ) + pFormShell->GetImpl()->setCurrentSelectionFromMark_Lock(pFormShell->GetFormView()->GetMarkedObjectList()); + else + pFormShell->GetImpl()->setCurrentSelection_Lock(std::move(aSelection)); + + if (pFormShell->GetImpl()->IsPropBrwOpen_Lock() || bForce) + { + // and now deliver all to the PropertyBrowser + pFormShell->GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_SHOW_PROPERTY_BROWSER, SfxCallMode::ASYNCHRON ); + } + } + + + void NavigatorTree::DeleteSelection() + { + // of course, i can't delete root + bool bRootSelected = m_xTreeView->is_selected(*m_xRootEntry); + auto nSelectedEntries = m_xTreeView->count_selected_rows(); + if (bRootSelected && (nSelectedEntries > 1)) // root and other elements ? + m_xTreeView->unselect(*m_xRootEntry); // yes -> remove root from selection + + if ((nSelectedEntries == 0) || bRootSelected) // still root ? + return; // -> only selected element -> leave + + DBG_ASSERT(!m_bPrevSelectionMixed, "NavigatorTree::DeleteSelection() : delete permitted if mark and selection are inconsistent"); + + // i need the FormModel later + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if (!pFormShell) + return; + FmFormModel* pFormModel = pFormShell->GetFormModel(); + if (!pFormModel) + return; + + // now I have to safeguard the DeleteList: if you delete a form and a dependent element + // - in this order - than the SvLBoxEntryPtr of the dependent element is already invalid, + // when it should be deleted... you have to prohibit this GPF, that of course would happen, + // so I take the 'normalized' list + CollectSelectionData( SDI_NORMALIZED ); + + // see below for why we need this mapping from models to shapes + FmFormView* pFormView = pFormShell->GetFormView(); + SdrPageView* pPageView = pFormView ? pFormView->GetSdrPageView() : nullptr; + SdrPage* pPage = pPageView ? pPageView->GetPage() : nullptr; + DBG_ASSERT( pPage, "NavigatorTree::DeleteSelection: invalid form page!" ); + + MapModelToShape aModelShapes; + if ( pPage ) + collectShapeModelMapping( pPage, aModelShapes ); + + // problem: we have to use ExplorerModel::Remove, since only this one properly deletes Form objects. + // But, the controls themself must be deleted via DeleteMarked (else, the Writer has some problems + // somewhere). In case I'd first delete the structure, then the controls, the UNDO would not work + // (since UNDO then would mean to first restore the controls, then the structure, means their parent + // form). The other way round, the EntryDatas would be invalid, if I'd first delete the controls and + // then go on to the structure. This means I have to delete the forms *after* the normal controls, so + // that during UNDO, they're restored in the proper order. + pFormShell->GetImpl()->EnableTrackProperties_Lock(false); + for (SvLBoxEntrySortedArray::reverse_iterator it = m_arrCurrentSelection.rbegin(); + it != m_arrCurrentSelection.rend(); ) + { + const std::unique_ptr<weld::TreeIter>& rIter = *it; + FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rIter)); + + // a form ? + auto pFormData = dynamic_cast<FmFormData*>(pCurrent); + + // because deletion is done by the view, and i build on its MarkList, + // but normally only direct controls, no indirect ones, are marked in a marked form, + // I have to do it later + if (pFormData) + MarkViewObj(pFormData, true/*deep*/); + + // a hidden control ? + bool bIsHidden = IsHiddenControl(pCurrent); + + // keep forms and hidden controls, the rest not + if (!pFormData && !bIsHidden) + { + // well, no form and no hidden control -> we can remove it from m_arrCurrentSelection, as it will + // be deleted automatically. This is because for every model (except forms and hidden control models) + // there exist a shape, which is marked _if_and_only_if_ the model is selected in our tree. + if ( aModelShapes.find( pCurrent->GetElement() ) != aModelShapes.end() ) + { + // if there's a shape for the current entry, then either it is marked or it is in a + // hidden layer (#i28502#), or something like this. + // In the first case, it will be deleted below, in the second case, we currently don't + // delete it, as there's no real (working!) API for this, neither in UNO nor in non-UNO. + m_arrCurrentSelection.erase( --(it.base()) ); + } + else + ++it; + // In case there is no shape for the current entry, we keep the entry in m_arrCurrentSelection, + // since then we can definitely remove it. + } + else + ++it; + } + pFormShell->GetImpl()->EnableTrackProperties_Lock(true); + + // let the view delete the marked controls + pFormShell->GetFormView()->DeleteMarked(); + + // start UNDO at this point. Unfortunately, this results in 2 UNDO actions, since DeleteMarked is + // creating an own one. However, if we'd move it before DeleteMarked, Writer does not really like + // this ... :( + // #i31038# + { + + // initialize UNDO + OUString aUndoStr; + if ( m_arrCurrentSelection.size() == 1 ) + { + aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_REMOVE); + if (m_nFormsSelected) + aUndoStr = aUndoStr.replaceFirst( "#", SvxResId( RID_STR_FORM ) ); + else + // it must be a control (else the root would be selected, but it cannot be deleted) + aUndoStr = aUndoStr.replaceFirst( "#", SvxResId( RID_STR_CONTROL ) ); + } + else + { + aUndoStr = SvxResId(RID_STR_UNDO_CONTAINER_REMOVE_MULTIPLE); + aUndoStr = aUndoStr.replaceFirst( "#", OUString::number( m_arrCurrentSelection.size() ) ); + } + pFormModel->BegUndo(aUndoStr); + } + + // remove remaining structure + for (const auto& rpSelection : m_arrCurrentSelection) + { + FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(*rpSelection)); + + // if the entry still has children, we skipped deletion of one of those children. + // This may for instance be because the shape is in a hidden layer, where we're unable + // to remove it + if ( pCurrent->GetChildList()->size() ) + continue; + + // one remaining subtile problem, before deleting it : if it's a form and the shell + // knows it as CurrentObject, I have to tell it something else + if (auto pFormData = dynamic_cast<FmFormData*>( pCurrent)) + { + Reference< XForm > xCurrentForm( pFormData->GetFormIface() ); + if (pFormShell->GetImpl()->getCurrentForm_Lock() == xCurrentForm) // shell knows form to be deleted ? + pFormShell->GetImpl()->forgetCurrentForm_Lock(); // -> take away ... + } + GetNavModel()->Remove(pCurrent, true); + } + pFormModel->EndUndo(); + } + + + void NavigatorTree::CollectSelectionData(SELDATA_ITEMS sdiHow) + { + DBG_ASSERT(sdiHow != SDI_DIRTY, "NavigatorTree::CollectSelectionData : ever thought about your parameter ? DIRTY ?"); + if (sdiHow == m_sdiState) + return; + + m_arrCurrentSelection.clear(); + m_nFormsSelected = m_nControlsSelected = m_nHiddenControls = 0; + m_bRootSelected = false; + + m_xTreeView->selected_foreach([this, sdiHow](weld::TreeIter& rSelectionLoop){ + // count different elements + if (m_xTreeView->iter_compare(rSelectionLoop, *m_xRootEntry) == 0) + m_bRootSelected = true; + else + { + if (IsFormEntry(rSelectionLoop)) + ++m_nFormsSelected; + else + { + ++m_nControlsSelected; + if (IsHiddenControl(weld::fromId<FmEntryData*>(m_xTreeView->get_id(rSelectionLoop)))) + ++m_nHiddenControls; + } + } + + if (sdiHow == SDI_NORMALIZED) + { + // don't take something with a selected ancestor + if (m_xTreeView->iter_compare(rSelectionLoop, *m_xRootEntry) == 0) + m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop)); + else + { + std::unique_ptr<weld::TreeIter> xParentLoop(m_xTreeView->make_iterator(&rSelectionLoop)); + bool bParentLoop = m_xTreeView->iter_parent(*xParentLoop); + while (bParentLoop) + { + // actually i would have to test, if parent is part of m_arr_CurrentSelection ... + // but if it's selected, then it's in m_arrCurrentSelection + // or one of its ancestors, which was selected earlier. + // In both cases IsSelected is enough + if (m_xTreeView->is_selected(*xParentLoop)) + break; + else + { + if (m_xTreeView->iter_compare(*xParentLoop, *m_xRootEntry) == 0) + { + // until root (exclusive), there was no selected parent -> entry belongs to normalized list + m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop)); + break; + } + else + bParentLoop = m_xTreeView->iter_parent(*xParentLoop); + } + } + } + } + else if (sdiHow == SDI_NORMALIZED_FORMARK) + { + std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rSelectionLoop)); + bool bParent = m_xTreeView->iter_parent(*xParent); + if (!bParent || !m_xTreeView->is_selected(*xParent) || IsFormEntry(rSelectionLoop)) + m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop)); + } + else + m_arrCurrentSelection.emplace(m_xTreeView->make_iterator(&rSelectionLoop)); + + return false; + }); + + m_sdiState = sdiHow; + } + + void NavigatorTree::SynchronizeSelection(FmEntryDataArray& arredToSelect) + { + LockSelectionHandling(); + if (arredToSelect.empty()) + { + m_xTreeView->unselect_all(); + } + else + { + // compare current selection with requested SelectList + m_xTreeView->selected_foreach([this, &arredToSelect](weld::TreeIter& rSelection) { + FmEntryData* pCurrent = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rSelection)); + if (pCurrent != nullptr) + { + FmEntryDataArray::iterator it = arredToSelect.find(pCurrent); + if ( it != arredToSelect.end() ) + { // entry already selected, but also in SelectList + // remove it from there + arredToSelect.erase(it); + } else + { // entry selected, but not in SelectList -> remove selection + m_xTreeView->unselect(rSelection); + // make it visible (maybe it's the only modification i do in this handler + // so you should see it + m_xTreeView->scroll_to_row(rSelection); + } + } + else + m_xTreeView->unselect(rSelection); + + return false; + }); + + // now SelectList contains only entries, which have to be selected + // two possibilities : 1) run through SelectList, get SvTreeListEntry for every entry and select it (is more intuitive) + // 2) run through my SvLBoxEntries and select those, i can find in the SelectList + // 1) needs =(k*n) (k=length of SelectList, n=number of entries), + // plus the fact, that FindEntry uses extensive IsEqualWithoutChilden instead of comparing pointer to UserData + // 2) needs =(n*log k), duplicates some code from FindEntry + // This may be a frequently used code ( at every change in mark of the view!), + // so i use latter one + m_xTreeView->all_foreach([this, &arredToSelect](weld::TreeIter& rLoop){ + FmEntryData* pCurEntryData = weld::fromId<FmEntryData*>(m_xTreeView->get_id(rLoop)); + FmEntryDataArray::iterator it = arredToSelect.find(pCurEntryData); + if (it != arredToSelect.end()) + { + m_xTreeView->select(rLoop); + m_xTreeView->scroll_to_row(rLoop); + } + + return false; + }); + } + UnlockSelectionHandling(); + } + + + void NavigatorTree::SynchronizeSelection() + { + // shell and view + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if(!pFormShell) return; + + FmFormView* pFormView = pFormShell->GetFormView(); + if (!pFormView) return; + + GetNavModel()->BroadcastMarkedObjects(pFormView->GetMarkedObjectList()); + } + + + void NavigatorTree::SynchronizeMarkList() + { + // i'll need this shell + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if (!pFormShell) return; + + CollectSelectionData(SDI_NORMALIZED_FORMARK); + + // the view shouldn't notify now if MarkList changed + pFormShell->GetImpl()->EnableTrackProperties_Lock(false); + + UnmarkAllViewObj(); + + for (auto& rSelectionLoop : m_arrCurrentSelection) + { + // When form selection, mark all controls of form + if (IsFormEntry(*rSelectionLoop) && m_xTreeView->iter_compare(*rSelectionLoop, *m_xRootEntry) != 0) + MarkViewObj(weld::fromId<FmFormData*>(m_xTreeView->get_id(*rSelectionLoop)), false/*deep*/); + + // When control selection, mark Control-SdrObjects + else if (IsFormComponentEntry(*rSelectionLoop)) + { + FmControlData* pControlData = weld::fromId<FmControlData*>(m_xTreeView->get_id(*rSelectionLoop)); + if (pControlData) + { + + // When HiddenControl no object can be selected + Reference< XFormComponent > xFormComponent( pControlData->GetFormComponent()); + if (!xFormComponent.is()) + continue; + Reference< XPropertySet > xSet(xFormComponent, UNO_QUERY); + if (!xSet.is()) + continue; + + sal_uInt16 nClassId = ::comphelper::getINT16(xSet->getPropertyValue(FM_PROP_CLASSID)); + if (nClassId != FormComponentType::HIDDENCONTROL) + MarkViewObj(pControlData); + } + } + } + + // if PropertyBrowser is open, I have to adopt it according to my selection + // (Not as MarkList of view : if a form is selected, all belonging controls are selected in the view + // but of course i want to see the form-properties + ShowSelectionProperties(); + + // reset flag at view + pFormShell->GetImpl()->EnableTrackProperties_Lock(true); + + // if exactly one form is selected now, shell should notice it as CurrentForm + // (if selection handling isn't locked, view cares about it in MarkListHasChanged + // but mechanism doesn't work, if form is empty for example + if ((m_arrCurrentSelection.size() != 1) || (m_nFormsSelected != 1)) + return; + + std::unique_ptr<weld::TreeIter> xSelected(m_xTreeView->make_iterator()); + if (!m_xTreeView->get_selected(xSelected.get())) + xSelected.reset(); + FmFormData* pSingleSelectionData = xSelected ? dynamic_cast<FmFormData*>(weld::fromId<FmEntryData*>(m_xTreeView->get_id(*xSelected))) + : nullptr; + DBG_ASSERT( pSingleSelectionData, "NavigatorTree::SynchronizeMarkList: invalid selected form!" ); + if ( pSingleSelectionData ) + { + InterfaceBag aSelection; + aSelection.insert( Reference< XInterface >( pSingleSelectionData->GetFormIface(), UNO_QUERY ) ); + pFormShell->GetImpl()->setCurrentSelection_Lock(std::move(aSelection)); + } + } + + bool NavigatorTree::IsHiddenControl(FmEntryData const * pEntryData) + { + if (pEntryData == nullptr) return false; + + Reference< XPropertySet > xProperties( pEntryData->GetPropertySet() ); + if (::comphelper::hasProperty(FM_PROP_CLASSID, xProperties)) + { + Any aClassID = xProperties->getPropertyValue( FM_PROP_CLASSID ); + return (::comphelper::getINT16(aClassID) == FormComponentType::HIDDENCONTROL); + } + return false; + } + + void NavigatorTree::UnmarkAllViewObj() + { + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if( !pFormShell ) + return; + FmFormView* pFormView = pFormShell->GetFormView(); + pFormView->UnMarkAll(); + } + + void NavigatorTree::MarkViewObj(FmFormData const * pFormData, bool bDeep ) + { + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if( !pFormShell ) + return; + + // first collect all sdrobjects + ::std::set< Reference< XFormComponent > > aObjects; + CollectObjects(pFormData,bDeep,aObjects); + + + // find and select appropriate SdrObj in page + FmFormView* pFormView = pFormShell->GetFormView(); + SdrPageView* pPageView = pFormView->GetSdrPageView(); + SdrPage* pPage = pPageView->GetPage(); + //FmFormPage* pFormPage = dynamic_cast< FmFormPage* >( pPage ); + + SdrObjListIter aIter( pPage ); + while ( aIter.IsMore() ) + { + SdrObject* pSdrObject = aIter.Next(); + FmFormObj* pFormObject = FmFormObj::GetFormObject( pSdrObject ); + if ( !pFormObject ) + continue; + + Reference< XFormComponent > xControlModel( pFormObject->GetUnoControlModel(),UNO_QUERY ); + if ( xControlModel.is() && aObjects.find(xControlModel) != aObjects.end() && !pFormView->IsObjMarked( pSdrObject ) ) + { + // unfortunately, the writer doesn't like marking an already-marked object, again, so reset the mark first + pFormView->MarkObj( pSdrObject, pPageView ); + } + } // while ( aIter.IsMore() ) + // make the mark visible + ::tools::Rectangle aMarkRect( pFormView->GetAllMarkedRect()); + for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i ) + { + SdrPaintWindow* pPaintWindow = pFormView->GetPaintWindow( i ); + OutputDevice& rOutDev = pPaintWindow->GetOutputDevice(); + if ( ( OUTDEV_WINDOW == rOutDev.GetOutDevType() ) && !aMarkRect.IsEmpty() ) + { + pFormView->MakeVisible( aMarkRect, *rOutDev.GetOwnerWindow() ); + } + } // for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i ) + } + + void NavigatorTree::CollectObjects(FmFormData const * pFormData, bool bDeep, ::std::set< Reference< XFormComponent > >& _rObjects) + { + FmEntryDataList* pChildList = pFormData->GetChildList(); + for( size_t i = 0; i < pChildList->size(); ++i ) + { + FmEntryData* pEntryData = pChildList->at( i ); + if( auto pControlData = dynamic_cast<FmControlData*>( pEntryData) ) + { + _rObjects.insert(pControlData->GetFormComponent()); + } // if( dynamic_cast<const FmControlData*>( pEntryData) != nullptr ) + else if (bDeep) + if (auto pEntryFormData = dynamic_cast<FmFormData*>( pEntryData)) + CollectObjects(pEntryFormData, bDeep, _rObjects); + } // for( sal_uInt32 i=0; i<pChildList->Count(); i++ ) + } + + void NavigatorTree::MarkViewObj( FmControlData const * pControlData) + { + if( !pControlData ) + return; + FmFormShell* pFormShell = GetNavModel()->GetFormShell(); + if( !pFormShell ) + return; + + + // find and select appropriate SdrObj + FmFormView* pFormView = pFormShell->GetFormView(); + Reference< XFormComponent > xFormComponent( pControlData->GetFormComponent()); + SdrPageView* pPageView = pFormView->GetSdrPageView(); + SdrPage* pPage = pPageView->GetPage(); + + bool bPaint = false; + SdrObjListIter aIter( pPage ); + while ( aIter.IsMore() ) + { + SdrObject* pSdrObject = aIter.Next(); + FmFormObj* pFormObject = FmFormObj::GetFormObject( pSdrObject ); + if ( !pFormObject ) + continue; + + Reference< XInterface > xControlModel( pFormObject->GetUnoControlModel() ); + if ( xControlModel != xFormComponent ) + continue; + + // mark the object + if ( !pFormView->IsObjMarked( pSdrObject ) ) + // unfortunately, the writer doesn't like marking an already-marked object, again, so reset the mark first + pFormView->MarkObj( pSdrObject, pPageView ); + + bPaint = true; + + } // while ( aIter.IsMore() ) + if ( !bPaint ) + return; + + // make the mark visible + ::tools::Rectangle aMarkRect( pFormView->GetAllMarkedRect()); + for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i ) + { + SdrPaintWindow* pPaintWindow = pFormView->GetPaintWindow( i ); + OutputDevice& rOutDev = pPaintWindow->GetOutputDevice(); + if ( OUTDEV_WINDOW == rOutDev.GetOutDevType() ) + { + pFormView->MakeVisible( aMarkRect, *rOutDev.GetOwnerWindow() ); + } + } // for ( sal_uInt32 i = 0; i < pFormView->PaintWindowCount(); ++i ) + } + + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/navigatortreemodel.cxx b/svx/source/form/navigatortreemodel.cxx new file mode 100644 index 000000000..218e2ba4a --- /dev/null +++ b/svx/source/form/navigatortreemodel.cxx @@ -0,0 +1,907 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/fmshell.hxx> +#include <svx/fmmodel.hxx> +#include <svx/fmpage.hxx> +#include <svx/svditer.hxx> +#include <svx/svdogrp.hxx> + +#include <fmprop.hxx> + +#include <fmundo.hxx> +#include <fmexpl.hxx> +#include <svx/strings.hrc> +#include <fmshimp.hxx> +#include <fmobj.hxx> +#include <o3tl/safeint.hxx> +#include <sfx2/objsh.hxx> +#include <tools/diagnose_ex.h> +#include <com/sun/star/container/XContainer.hpp> +#include <comphelper/types.hxx> + + +namespace svxform +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::form; + using namespace ::com::sun::star::awt; + using namespace ::com::sun::star::container; + using namespace ::com::sun::star::script; + using namespace ::com::sun::star::sdb; + + OFormComponentObserver::OFormComponentObserver(NavigatorTreeModel* _pModel) + :m_pNavModel(_pModel) + ,m_nLocks(0) + ,m_bCanUndo(true) + { + } + + // XPropertyChangeListener + + void SAL_CALL OFormComponentObserver::disposing(const EventObject& Source) + { + Remove( Source.Source ); + } + + + void SAL_CALL OFormComponentObserver::propertyChange(const PropertyChangeEvent& evt) + { + if( !m_pNavModel ) return; + if( evt.PropertyName != FM_PROP_NAME ) return; + + Reference< XFormComponent > xFormComponent(evt.Source, UNO_QUERY); + Reference< XForm > xForm(evt.Source, UNO_QUERY); + + FmEntryData* pEntryData( nullptr ); + if( xForm.is() ) + pEntryData = m_pNavModel->FindData( xForm, m_pNavModel->GetRootList() ); + else if( xFormComponent.is() ) + pEntryData = m_pNavModel->FindData( xFormComponent, m_pNavModel->GetRootList() ); + + if( pEntryData ) + { + OUString aNewName = ::comphelper::getString(evt.NewValue); + pEntryData->SetText( aNewName ); + FmNavNameChangedHint aNameChangedHint( pEntryData, aNewName ); + m_pNavModel->Broadcast( aNameChangedHint ); + } + } + + // XContainerListener + + void SAL_CALL OFormComponentObserver::elementInserted(const ContainerEvent& evt) + { + if (IsLocked() || !m_pNavModel) + return; + + // insert no Undoaction + m_bCanUndo = false; + + Reference< XInterface > xTemp; + evt.Element >>= xTemp; + Insert(xTemp, ::comphelper::getINT32(evt.Accessor)); + + m_bCanUndo = true; + } + + + void OFormComponentObserver::Insert(const Reference< XInterface > & xIface, sal_Int32 nIndex) + { + Reference< XForm > xForm(xIface, UNO_QUERY); + if (xForm.is()) + { + m_pNavModel->InsertForm(xForm, sal_uInt32(nIndex)); + Reference< XIndexContainer > xContainer(xForm, UNO_QUERY); + Reference< XInterface > xTemp; + for (sal_Int32 i = 0; i < xContainer->getCount(); i++) + { + xContainer->getByIndex(i) >>= xTemp; + Insert(xTemp, i); + } + } + else + { + Reference< XFormComponent > xFormComp(xIface, UNO_QUERY); + if (xFormComp.is()) + m_pNavModel->InsertFormComponent(xFormComp, sal_uInt32(nIndex)); + } + } + + + void SAL_CALL OFormComponentObserver::elementReplaced(const ContainerEvent& evt) + { + if (IsLocked() || !m_pNavModel) + return; + + m_bCanUndo = false; + + // delete EntryData + Reference< XFormComponent > xReplaced; + evt.ReplacedElement >>= xReplaced; + FmEntryData* pEntryData = m_pNavModel->FindData(xReplaced, m_pNavModel->GetRootList()); + if (pEntryData) + { + if (dynamic_cast<const FmControlData*>( pEntryData) != nullptr) + { + Reference< XFormComponent > xComp; + evt.Element >>= xComp; + DBG_ASSERT(xComp.is(), "OFormComponentObserver::elementReplaced : invalid argument !"); + // FmControlData should be coupled with XFormComponent + m_pNavModel->ReplaceFormComponent(xReplaced, xComp); + } + else if (dynamic_cast<const FmFormData*>( pEntryData) != nullptr) + { + OSL_FAIL("replacing forms not implemented yet !"); + } + } + + m_bCanUndo = true; + } + + + void OFormComponentObserver::Remove( const css::uno::Reference< css::uno::XInterface >& _rxElement ) + { + if (IsLocked() || !m_pNavModel) + return; + + m_bCanUndo = false; + + + // delete EntryData + FmEntryData* pEntryData = m_pNavModel->FindData( _rxElement, m_pNavModel->GetRootList() ); + if (pEntryData) + m_pNavModel->Remove(pEntryData); + + m_bCanUndo = true; + } + + + void SAL_CALL OFormComponentObserver::elementRemoved(const ContainerEvent& evt) + { + Reference< XInterface > xElement; + evt.Element >>= xElement; + Remove( xElement ); + } + + NavigatorTreeModel::NavigatorTreeModel() + :m_pFormShell(nullptr) + ,m_pFormPage(nullptr) + ,m_pFormModel(nullptr) + { + m_pPropChangeList = new OFormComponentObserver(this); + m_pRootList.reset( new FmEntryDataList() ); + } + + NavigatorTreeModel::~NavigatorTreeModel() + { + + // unregister Listener + if( m_pFormShell) + { + FmFormModel* pFormModel = m_pFormShell->GetFormModel(); + if( pFormModel && IsListening(*pFormModel)) + EndListening( *pFormModel ); + + if (IsListening(*m_pFormShell)) + EndListening(*m_pFormShell); + } + + Clear(); + m_pRootList.reset(); + m_pPropChangeList->ReleaseModel(); + } + + + void NavigatorTreeModel::SetModified() + { + if( !m_pFormShell ) return; + SfxObjectShell* pObjShell = m_pFormShell->GetFormModel()->GetObjectShell(); + if( !pObjShell ) return; + pObjShell->SetModified(); + } + + + void NavigatorTreeModel::Clear() + { + Reference< css::form::XForms > xForms( GetForms()); + if(xForms.is()) + xForms->removeContainerListener(m_pPropChangeList); + + + // delete RootList + GetRootList()->clear(); + + + // notify UI + FmNavClearedHint aClearedHint; + Broadcast( aClearedHint ); + } + + + Reference< css::form::XForms > NavigatorTreeModel::GetForms() const + { + if( !m_pFormShell || !m_pFormShell->GetCurPage()) + return nullptr; + else + return m_pFormShell->GetCurPage()->GetForms(); + } + + + void NavigatorTreeModel::Insert(FmEntryData* pEntry, sal_uInt32 nRelPos, bool bAlterModel) + { + if (IsListening(*m_pFormModel)) + EndListening(*m_pFormModel); + + m_pPropChangeList->Lock(); + FmFormData* pFolder = static_cast<FmFormData*>( pEntry->GetParent() ); + Reference< XChild > xElement( pEntry->GetChildIFace() ); + if (bAlterModel) + { + OUString aStr; + if (dynamic_cast<const FmFormData*>( pEntry) != nullptr) + aStr = SvxResId(RID_STR_FORM); + else + aStr = SvxResId(RID_STR_CONTROL); + + Reference< XIndexContainer > xContainer; + if (pFolder) + xContainer.set(pFolder->GetFormIface(), UNO_QUERY); + else + xContainer = GetForms(); + + bool bUndo = m_pFormModel->IsUndoEnabled(); + + if( bUndo ) + { + OUString aUndoStr(SvxResId(RID_STR_UNDO_CONTAINER_INSERT)); + aUndoStr = aUndoStr.replaceFirst("#", aStr); + m_pFormModel->BegUndo(aUndoStr); + } + + if (nRelPos >= o3tl::make_unsigned(xContainer->getCount())) + nRelPos = static_cast<sal_uInt32>(xContainer->getCount()); + + // UndoAction + if ( bUndo && m_pPropChangeList->CanUndo()) + { + m_pFormModel->AddUndo(std::make_unique<FmUndoContainerAction>(*m_pFormModel, + FmUndoContainerAction::Inserted, + xContainer, + xElement, + nRelPos)); + } + + // Element has to be of the expected type by the container + if (xContainer->getElementType() == + cppu::UnoType<XForm>::get()) + + { + Reference< XForm > xElementAsForm(xElement, UNO_QUERY); + xContainer->insertByIndex(nRelPos, Any(xElementAsForm)); + } + else if (xContainer->getElementType() == + cppu::UnoType<XFormComponent>::get()) + + { + Reference< XFormComponent > xElementAsComponent(xElement, UNO_QUERY); + xContainer->insertByIndex(nRelPos, Any(xElementAsComponent)); + } + else + { + OSL_FAIL("NavigatorTreeModel::Insert : the parent container needs an elementtype I don't know !"); + } + + if( bUndo ) + m_pFormModel->EndUndo(); + } + + // register as PropertyChangeListener + Reference< XPropertySet > xSet(xElement, UNO_QUERY); + if( xSet.is() ) + xSet->addPropertyChangeListener( FM_PROP_NAME, m_pPropChangeList ); + + + // Remove data from model + if (dynamic_cast<const FmFormData*>( pEntry) != nullptr) + { + Reference< XContainer > xContainer(xElement, UNO_QUERY); + if (xContainer.is()) + xContainer->addContainerListener(m_pPropChangeList); + } + + if (pFolder) + pFolder->GetChildList()->insert( std::unique_ptr<FmEntryData>(pEntry), nRelPos ); + else + GetRootList()->insert( std::unique_ptr<FmEntryData>(pEntry), nRelPos ); + + + // notify UI + FmNavInsertedHint aInsertedHint( pEntry, nRelPos ); + Broadcast( aInsertedHint ); + + m_pPropChangeList->UnLock(); + if (IsListening(*m_pFormModel)) + StartListening(*m_pFormModel); + } + + + void NavigatorTreeModel::Remove(FmEntryData* pEntry, bool bAlterModel) + { + + // get form and parent + if (!pEntry || !m_pFormModel) + return; + + if (IsListening(*m_pFormModel)) + EndListening(*m_pFormModel); + + const bool bUndo = m_pFormModel->IsUndoEnabled(); + + m_pPropChangeList->Lock(); + FmFormData* pFolder = static_cast<FmFormData*>( pEntry->GetParent() ); + Reference< XChild > xElement ( pEntry->GetChildIFace() ); + if (bAlterModel) + { + OUString aStr; + if (dynamic_cast<const FmFormData*>( pEntry) != nullptr) + aStr = SvxResId(RID_STR_FORM); + else + aStr = SvxResId(RID_STR_CONTROL); + + if( bUndo ) + { + OUString aUndoStr(SvxResId(RID_STR_UNDO_CONTAINER_REMOVE)); + aUndoStr = aUndoStr.replaceFirst("#", aStr); + m_pFormModel->BegUndo(aUndoStr); + } + } + + // now real deletion of data form model + if (auto pFormData = dynamic_cast<FmFormData*>( pEntry)) + RemoveForm(pFormData); + else + RemoveFormComponent(static_cast<FmControlData*>(pEntry)); + + + if (bAlterModel) + { + Reference< XIndexContainer > xContainer(xElement->getParent(), UNO_QUERY); + // remove from Container + sal_Int32 nContainerIndex = getElementPos(xContainer, xElement); + // UndoAction + if (nContainerIndex >= 0) + { + if ( bUndo && m_pPropChangeList->CanUndo()) + { + m_pFormModel->AddUndo(std::make_unique<FmUndoContainerAction>(*m_pFormModel, + FmUndoContainerAction::Removed, + xContainer, + xElement, nContainerIndex )); + } + else if( !m_pPropChangeList->CanUndo() ) + { + FmUndoContainerAction::DisposeElement( xElement ); + } + + xContainer->removeByIndex(nContainerIndex ); + } + + if( bUndo ) + m_pFormModel->EndUndo(); + } + + // remove from parent + if (pFolder) + pFolder->GetChildList()->removeNoDelete( pEntry ); + else + { + GetRootList()->removeNoDelete( pEntry ); + + // If root has no more form, reset CurForm at shell + if ( !GetRootList()->size() ) + m_pFormShell->GetImpl()->forgetCurrentForm_Lock(); + } + + + // notify UI + FmNavRemovedHint aRemovedHint( pEntry ); + Broadcast( aRemovedHint ); + + // delete entry + delete pEntry; + + m_pPropChangeList->UnLock(); + StartListening(*m_pFormModel); + } + + + void NavigatorTreeModel::RemoveForm(FmFormData const * pFormData) + { + + // get form and parent + if (!pFormData || !m_pFormModel) + return; + + FmEntryDataList* pChildList = pFormData->GetChildList(); + for ( size_t i = pChildList->size(); i > 0; ) + { + FmEntryData* pEntryData = pChildList->at( --i ); + + + // Child is form -> recursive call + if( auto pChildFormData = dynamic_cast<FmFormData*>( pEntryData) ) + RemoveForm(pChildFormData); + else if( auto pChildControlData = dynamic_cast<FmControlData*>( pEntryData) ) + RemoveFormComponent(pChildControlData); + } + + + // unregister as PropertyChangeListener + Reference< XPropertySet > xSet( pFormData->GetPropertySet() ); + if ( xSet.is() ) + xSet->removePropertyChangeListener( FM_PROP_NAME, m_pPropChangeList ); + } + + + void NavigatorTreeModel::RemoveFormComponent(FmControlData const * pControlData) + { + + // get control and parent + if (!pControlData) + return; + + + // unregister as PropertyChangeListener + Reference< XPropertySet > xSet( pControlData->GetPropertySet() ); + if (xSet.is()) + xSet->removePropertyChangeListener( FM_PROP_NAME, m_pPropChangeList); + } + + + void NavigatorTreeModel::FillBranch( FmFormData* pFormData ) + { + + // insert forms from root + if( pFormData == nullptr ) + { + Reference< XIndexContainer > xForms = GetForms(); + if (!xForms.is()) + return; + + Reference< XForm > xSubForm; + for (sal_Int32 i=0; i<xForms->getCount(); ++i) + { + DBG_ASSERT( xForms->getByIndex(i).getValueType() == cppu::UnoType<XForm>::get(), + "NavigatorTreeModel::FillBranch : the root container should supply only elements of type XForm"); + + xForms->getByIndex(i) >>= xSubForm; + FmFormData* pSubFormData = new FmFormData(xSubForm, pFormData); + Insert( pSubFormData ); + + // new branch, if SubForm contains Subforms itself + FillBranch( pSubFormData ); + } + } + + + // insert components + else + { + Reference< XIndexContainer > xComponents( GetFormComponents(pFormData)); + if( !xComponents.is() ) return; + + FmControlData* pNewControlData; + FmFormData* pSubFormData; + + Reference< XFormComponent > xCurrentComponent; + for (sal_Int32 j=0; j<xComponents->getCount(); ++j) + { + xComponents->getByIndex(j) >>= xCurrentComponent; + Reference< XForm > xSubForm(xCurrentComponent, UNO_QUERY); + + if (xSubForm.is()) + { // actual component is a form + pSubFormData = new FmFormData(xSubForm, pFormData); + Insert(pSubFormData); + + + // new branch, if SubForm contains Subforms itself + FillBranch(pSubFormData); + } + else + { + pNewControlData = new FmControlData(xCurrentComponent, pFormData); + Insert(pNewControlData); + } + } + } + } + + + void NavigatorTreeModel::InsertForm(const Reference< XForm > & xForm, sal_uInt32 nRelPos) + { + FmFormData* pFormData = static_cast<FmFormData*>(FindData( xForm, GetRootList() )); + if (pFormData) + return; + + + // set ParentData + Reference< XInterface > xIFace( xForm->getParent()); + Reference< XForm > xParentForm(xIFace, UNO_QUERY); + FmFormData* pParentData = nullptr; + if (xParentForm.is()) + pParentData = static_cast<FmFormData*>(FindData( xParentForm, GetRootList() )); + + pFormData = new FmFormData(xForm, pParentData); + Insert( pFormData, nRelPos ); + } + + + void NavigatorTreeModel::InsertFormComponent(const Reference< XFormComponent > & xComp, sal_uInt32 nRelPos) + { + + // set ParentData + Reference< XInterface > xIFace( xComp->getParent()); + Reference< XForm > xForm(xIFace, UNO_QUERY); + if (!xForm.is()) + return; + + FmFormData* pParentData = static_cast<FmFormData*>(FindData( xForm, GetRootList() )); + if( !pParentData ) + { + pParentData = new FmFormData(xForm, nullptr); + Insert( pParentData ); + } + + if (!FindData(xComp, pParentData->GetChildList(),false)) + { + + // set new EntryData + FmEntryData* pNewEntryData = new FmControlData(xComp, pParentData); + + + // insert new EntryData + Insert( pNewEntryData, nRelPos ); + } + } + + void NavigatorTreeModel::ReplaceFormComponent( + const Reference< XFormComponent > & xOld, + const Reference< XFormComponent > & xNew + ) + { + FmEntryData* pData = FindData(xOld, GetRootList()); + assert(dynamic_cast<const FmControlData*>( pData)); //NavigatorTreeModel::ReplaceFormComponent : invalid argument + auto pControlData = dynamic_cast<FmControlData*>( pData); + if (!pControlData) + return; + pControlData->ModelReplaced(xNew); + + FmNavModelReplacedHint aReplacedHint( pData ); + Broadcast( aReplacedHint ); + } + + FmEntryData* NavigatorTreeModel::FindData(const Reference< XInterface > & xElement, FmEntryDataList* pDataList, bool bRecurs) + { + // normalize + Reference< XInterface > xIFace( xElement, UNO_QUERY ); + + for ( size_t i = 0; i < pDataList->size(); i++ ) + { + FmEntryData* pEntryData = pDataList->at( i ); + if ( pEntryData->GetElement().get() == xIFace.get() ) + return pEntryData; + else if (bRecurs) + { + pEntryData = FindData( xElement, pEntryData->GetChildList() ); + if (pEntryData) + return pEntryData; + } + } + return nullptr; + } + + + FmEntryData* NavigatorTreeModel::FindData( const OUString& rText, FmFormData const * pParentData, bool bRecurs ) + { + FmEntryDataList* pDataList; + if( !pParentData ) + pDataList = GetRootList(); + else + pDataList = pParentData->GetChildList(); + + OUString aEntryText; + FmEntryData* pEntryData; + FmEntryData* pChildData; + + for( size_t i = 0; i < pDataList->size(); i++ ) + { + pEntryData = pDataList->at( i ); + aEntryText = pEntryData->GetText(); + + if (rText == aEntryText) + return pEntryData; + + if (FmFormData* pFormData = bRecurs ? dynamic_cast<FmFormData*>(pEntryData) : nullptr) + { + pChildData = FindData(rText, pFormData, true); + if( pChildData ) + return pChildData; + } + } + + return nullptr; + } + + void NavigatorTreeModel::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) + { + if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint) + { + const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint); + switch( pSdrHint->GetKind() ) + { + case SdrHintKind::ObjectInserted: + InsertSdrObj(pSdrHint->GetObject()); + break; + case SdrHintKind::ObjectRemoved: + RemoveSdrObj(pSdrHint->GetObject()); + break; + default: + break; + } + } + // is shell gone? + else if (rHint.GetId() == SfxHintId::Dying) + { + UpdateContent(nullptr); + } + // changed mark of controls? + else if (const FmNavViewMarksChanged* pvmcHint = dynamic_cast<const FmNavViewMarksChanged*>(&rHint)) + { + BroadcastMarkedObjects(pvmcHint->GetAffectedView()->GetMarkedObjectList()); + } + } + + void NavigatorTreeModel::InsertSdrObj( const SdrObject* pObj ) + { + const FmFormObj* pFormObject = FmFormObj::GetFormObject( pObj ); + if ( pFormObject ) + { + try + { + Reference< XFormComponent > xFormComponent( pFormObject->GetUnoControlModel(), UNO_QUERY_THROW ); + Reference< XIndexAccess > xContainer( xFormComponent->getParent(), UNO_QUERY_THROW ); + + sal_Int32 nPos = getElementPos( xContainer, xFormComponent ); + InsertFormComponent( xFormComponent, nPos ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + else if ( pObj->IsGroupObject() ) + { + SdrObjListIter aIter( pObj->GetSubList() ); + while ( aIter.IsMore() ) + InsertSdrObj( aIter.Next() ); + } + } + + + void NavigatorTreeModel::RemoveSdrObj( const SdrObject* pObj ) + { + const FmFormObj* pFormObject = FmFormObj::GetFormObject( pObj ); + if ( pFormObject ) + { + try + { + Reference< XFormComponent > xFormComponent( pFormObject->GetUnoControlModel(), UNO_QUERY_THROW ); + FmEntryData* pEntryData = FindData( xFormComponent, GetRootList() ); + if ( pEntryData ) + Remove( pEntryData ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + else if ( pObj->IsGroupObject() ) + { + SdrObjListIter aIter( pObj->GetSubList() ); + while ( aIter.IsMore() ) + RemoveSdrObj( aIter.Next() ); + } + } + + bool NavigatorTreeModel::InsertFormComponent(FmNavRequestSelectHint& rHint, SdrObject* pObject) + { + if ( auto pObjGroup = dynamic_cast<const SdrObjGroup*>( pObject) ) + { // descend recursively + const SdrObjList *pChildren = pObjGroup->GetSubList(); + for ( size_t i=0; i<pChildren->GetObjCount(); ++i ) + { + SdrObject* pCurrent = pChildren->GetObj(i); + if (!InsertFormComponent(rHint, pCurrent)) + return false; + } + } + else + { + FmFormObj* pFormObject = FmFormObj::GetFormObject( pObject ); + if ( !pFormObject ) + return false; + + try + { + Reference< XFormComponent > xFormViewControl( pFormObject->GetUnoControlModel(), UNO_QUERY_THROW ); + FmEntryData* pControlData = FindData( xFormViewControl, GetRootList() ); + if ( !pControlData ) + return false; + + rHint.AddItem( pControlData ); + return true; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + return false; + } + } + + return true; + } + + void NavigatorTreeModel::BroadcastMarkedObjects(const SdrMarkList& mlMarked) + { + // search all objects, which can be handled, out of marked objects + FmNavRequestSelectHint rshRequestSelection; + bool bIsMixedSelection = false; + + for (size_t i=0; (i<mlMarked.GetMarkCount()) && !bIsMixedSelection; ++i) + { + SdrObject* pobjCurrent = mlMarked.GetMark(i)->GetMarkedSdrObj(); + bIsMixedSelection |= !InsertFormComponent(rshRequestSelection, pobjCurrent); + // if Not-Form-Control, InsertFormComponent returns sal_False ! + } + + rshRequestSelection.SetMixedSelection(bIsMixedSelection); + if (bIsMixedSelection) + rshRequestSelection.ClearItems(); + + Broadcast(rshRequestSelection); + // an empty list causes NavigatorTree to remove his selection + } + + + void NavigatorTreeModel::UpdateContent( const Reference< css::form::XForms > & xForms ) + { + + // refill model form root upward + Clear(); + if (!xForms.is()) + return; + + xForms->addContainerListener(m_pPropChangeList); + + FillBranch(nullptr); + + // select same control in tree as in view + // (or all of them), if there is one ... + if(!m_pFormShell) return; // no shell + + FmFormView* pFormView = m_pFormShell->GetFormView(); + DBG_ASSERT(pFormView != nullptr, "NavigatorTreeModel::UpdateContent : no FormView"); + BroadcastMarkedObjects(pFormView->GetMarkedObjectList()); + } + + + void NavigatorTreeModel::UpdateContent( FmFormShell* pShell ) + { + + // If shell is unchanged, do nothing + FmFormPage* pNewPage = pShell ? pShell->GetCurPage() : nullptr; + if ((pShell == m_pFormShell) && (m_pFormPage == pNewPage)) + return; + + + // unregister as Listener + if( m_pFormShell ) + { + if (m_pFormModel) + EndListening( *m_pFormModel ); + m_pFormModel = nullptr; + EndListening( *m_pFormShell ); + Clear(); + } + + + // entire update + m_pFormShell = pShell; + if (m_pFormShell) + { + m_pFormPage = pNewPage; + UpdateContent(m_pFormPage->GetForms()); + } else + m_pFormPage = nullptr; + + + // register as Listener again + if( m_pFormShell ) + { + StartListening( *m_pFormShell ); + m_pFormModel = m_pFormShell->GetFormModel(); + if( m_pFormModel ) + StartListening( *m_pFormModel ); + } + } + + + Reference< XIndexContainer > NavigatorTreeModel::GetFormComponents( FmFormData const * pFormData ) + { + + // get components from form + if (pFormData) + return Reference< XIndexContainer > (pFormData->GetFormIface(), UNO_QUERY); + + return Reference< XIndexContainer > (); + } + + + bool NavigatorTreeModel::Rename( FmEntryData* pEntryData, const OUString& rNewText ) + { + + // If name already exist, error message + pEntryData->SetText( rNewText ); + + + // get PropertySet + Reference< XFormComponent > xFormComponent; + + if( auto pFormData = dynamic_cast<FmFormData*>( pEntryData)) + { + xFormComponent = pFormData->GetFormIface(); + } + + if( auto pControlData = dynamic_cast<FmControlData*>( pEntryData) ) + { + xFormComponent = pControlData->GetFormComponent(); + } + + if( !xFormComponent.is() ) return false; + Reference< XPropertySet > xSet(xFormComponent, UNO_QUERY); + if( !xSet.is() ) return false; + + + // set name + xSet->setPropertyValue( FM_PROP_NAME, Any(rNewText) ); + + return true; + } + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/sdbdatacolumn.cxx b/svx/source/form/sdbdatacolumn.cxx new file mode 100644 index 000000000..19a7fd016 --- /dev/null +++ b/svx/source/form/sdbdatacolumn.cxx @@ -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 . + */ + +#include <sdbdatacolumn.hxx> + + +namespace svxform +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::sdbc; + using namespace ::com::sun::star::util; + using namespace ::com::sun::star::io; + using namespace ::com::sun::star::container; + + + //= DataColumn - a class wrapping an object implementing a sdb::DataColumn service + + DataColumn::DataColumn(const Reference< css::beans::XPropertySet>& _rxIFace) + { + m_xPropertySet = _rxIFace; + m_xColumn.set(_rxIFace, UNO_QUERY); + m_xColumnUpdate.set(_rxIFace, UNO_QUERY); + + if (!m_xPropertySet.is() || !m_xColumn.is()) + { + m_xPropertySet = nullptr; + m_xColumn = nullptr; + m_xColumnUpdate = nullptr; + } + } + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/sqlparserclient.cxx b/svx/source/form/sqlparserclient.cxx new file mode 100644 index 000000000..232f0418d --- /dev/null +++ b/svx/source/form/sqlparserclient.cxx @@ -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 . + */ + +#include <sqlparserclient.hxx> + +#include <connectivity/sqlparse.hxx> + +using namespace ::dbtools; +using namespace ::connectivity; + +namespace svxform +{ + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + + OSQLParserClient::OSQLParserClient(const Reference< XComponentContext >& rxContext) + : m_pParser(std::make_shared<OSQLParser>(rxContext, getParseContext())) + { + } + + std::unique_ptr< ::connectivity::OSQLParseNode > OSQLParserClient::predicateTree( + OUString& _rErrorMessage, + const OUString& _rStatement, + const css::uno::Reference< css::util::XNumberFormatter >& _rxFormatter, + const css::uno::Reference< css::beans::XPropertySet >& _rxField + ) const + { + return m_pParser->predicateTree(_rErrorMessage, _rStatement, _rxFormatter, _rxField); + } + +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/tabwin.cxx b/svx/source/form/tabwin.cxx new file mode 100644 index 000000000..4aa65b56e --- /dev/null +++ b/svx/source/form/tabwin.cxx @@ -0,0 +1,304 @@ +/* -*- 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 <tabwin.hxx> +#include <fmservs.hxx> + +#include <svx/strings.hrc> +#include <svx/svxids.hrc> +#include <com/sun/star/sdb/CommandType.hpp> +#include <com/sun/star/sdbc/XConnection.hpp> +#include <comphelper/processfactory.hxx> +#include <comphelper/types.hxx> + +#include <helpids.h> +#include <svx/fmshell.hxx> +#include <fmshimp.hxx> + +#include <fmprop.hxx> + +#include <svx/dialmgr.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/objitem.hxx> +#include <sfx2/frame.hxx> +#include <svx/dataaccessdescriptor.hxx> +#include <tools/diagnose_ex.h> +#include <tabwin.hrc> + +const tools::Long STD_WIN_SIZE_X = 120; +const tools::Long STD_WIN_SIZE_Y = 150; + +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdb; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::datatransfer; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star; +using namespace ::svxform; +using namespace ::svx; +using namespace ::dbtools; + +struct ColumnInfo +{ + OUString sColumnName; + explicit ColumnInfo(const OUString& i_sColumnName) + : sColumnName(i_sColumnName) + { + } +}; + +void FmFieldWin::addToList(const uno::Reference< container::XNameAccess>& i_xColumns ) +{ + const uno::Sequence< OUString > aEntries = i_xColumns->getElementNames(); + for ( const OUString& rEntry : aEntries ) + { + uno::Reference< beans::XPropertySet> xColumn(i_xColumns->getByName(rEntry),UNO_QUERY_THROW); + OUString sLabel; + if ( xColumn->getPropertySetInfo()->hasPropertyByName(FM_PROP_LABEL) ) + xColumn->getPropertyValue(FM_PROP_LABEL) >>= sLabel; + m_aListBoxData.emplace_back(new ColumnInfo(rEntry)); + OUString sId(weld::toId(m_aListBoxData.back().get())); + if ( !sLabel.isEmpty() ) + m_xListBox->append(sId, sLabel); + else + m_xListBox->append(sId, rEntry); + } +} + +IMPL_LINK(FmFieldWin, DragBeginHdl, bool&, rUnsetDragIcon, bool) +{ + rUnsetDragIcon = false; + + ColumnInfo* pSelected = weld::fromId<ColumnInfo*>(m_xListBox->get_selected_id()); + if (!pSelected) + { + // no drag without a field + return true; + } + + svx::ODataAccessDescriptor aDescriptor; + aDescriptor[ DataAccessDescriptorProperty::DataSource ] <<= GetDatabaseName(); + aDescriptor[ DataAccessDescriptorProperty::Connection ] <<= GetConnection().getTyped(); + aDescriptor[ DataAccessDescriptorProperty::Command ] <<= GetObjectName(); + aDescriptor[ DataAccessDescriptorProperty::CommandType ]<<= GetObjectType(); + aDescriptor[ DataAccessDescriptorProperty::ColumnName ] <<= pSelected->sColumnName; + + m_xHelper->setDescriptor(aDescriptor); + + return false; +} + +FmFieldWin::FmFieldWin(SfxBindings* _pBindings, SfxChildWindow* _pMgr, weld::Window* _pParent) + : SfxModelessDialogController(_pBindings, _pMgr, _pParent, "svx/ui/formfielddialog.ui", "FormFieldDialog") + , SfxControllerItem(SID_FM_FIELDS_CONTROL, *_pBindings) + , comphelper::OPropertyChangeListener(m_aMutex) + , m_xListBox(m_xBuilder->weld_tree_view("treeview")) + , m_nObjectType(0) +{ + m_xDialog->set_help_id(HID_FIELD_SEL_WIN); + m_xListBox->set_help_id(HID_FIELD_SEL); + + m_xListBox->connect_row_activated(LINK(this, FmFieldWin, RowActivatedHdl)); + m_xHelper.set(new OColumnTransferable( + ColumnTransferFormatFlags::FIELD_DESCRIPTOR | ColumnTransferFormatFlags::CONTROL_EXCHANGE | ColumnTransferFormatFlags::COLUMN_DESCRIPTOR + )); + rtl::Reference<TransferDataContainer> xHelper(m_xHelper); + m_xListBox->enable_drag_source(xHelper, DND_ACTION_COPY); + m_xListBox->connect_drag_begin(LINK(this, FmFieldWin, DragBeginHdl)); + + UpdateContent(nullptr); + m_xDialog->set_size_request(STD_WIN_SIZE_X, STD_WIN_SIZE_Y); +} + +FmFieldWin::~FmFieldWin() +{ + if (m_xChangeListener.is()) + { + m_xChangeListener->dispose(); + m_xChangeListener.clear(); + } + ::SfxControllerItem::dispose(); +} + +IMPL_LINK_NOARG(FmFieldWin, RowActivatedHdl, weld::TreeView&, bool) +{ + return createSelectionControls(); +} + +bool FmFieldWin::createSelectionControls() +{ + ColumnInfo* pSelected = weld::fromId<ColumnInfo*>(m_xListBox->get_selected_id()); + if (pSelected) + { + // build a descriptor for the currently selected field + ODataAccessDescriptor aDescr; + aDescr.setDataSource(GetDatabaseName()); + + aDescr[ DataAccessDescriptorProperty::Connection ] <<= GetConnection().getTyped(); + + aDescr[ DataAccessDescriptorProperty::Command ] <<= GetObjectName(); + aDescr[ DataAccessDescriptorProperty::CommandType ] <<= GetObjectType(); + aDescr[ DataAccessDescriptorProperty::ColumnName ] <<= pSelected->sColumnName; + + // transfer this to the SFX world + SfxUnoAnyItem aDescriptorItem( SID_FM_DATACCESS_DESCRIPTOR, Any( aDescr.createPropertyValueSequence() ) ); + const SfxPoolItem* pArgs[] = + { + &aDescriptorItem, nullptr + }; + + // execute the create slot + GetBindings().Execute( SID_FM_CREATE_FIELDCONTROL, pArgs ); + } + + return nullptr != pSelected; +} + +void FmFieldWin::_propertyChanged(const css::beans::PropertyChangeEvent& evt) +{ + css::uno::Reference< css::form::XForm > xForm(evt.Source, css::uno::UNO_QUERY); + UpdateContent(xForm); +} + +void FmFieldWin::StateChangedAtToolBoxControl(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState) +{ + if (!pState || SID_FM_FIELDS_CONTROL != nSID) + return; + + if (eState >= SfxItemState::DEFAULT) + { + FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() ); + UpdateContent(pShell); + } + else + UpdateContent(nullptr); +} + +void FmFieldWin::UpdateContent(FmFormShell const * pShell) +{ + m_xListBox->clear(); + m_aListBoxData.clear(); + OUString aTitle(SvxResId(RID_STR_FIELDSELECTION)); + m_xDialog->set_title(aTitle); + + if (!pShell || !pShell->GetImpl()) + return; + + Reference<XForm> const xForm = pShell->GetImpl()->getCurrentForm_Lock(); + if ( xForm.is() ) + UpdateContent( xForm ); +} + +void FmFieldWin::UpdateContent(const css::uno::Reference< css::form::XForm > & xForm) +{ + try + { + // delete ListBox + m_xListBox->clear(); + m_aListBoxData.clear(); + OUString aTitle(SvxResId(RID_STR_FIELDSELECTION)); + m_xDialog->set_title(aTitle); + + if (!xForm.is()) + return; + + Reference< XPropertySet > xSet(xForm, UNO_QUERY); + + m_aObjectName = ::comphelper::getString(xSet->getPropertyValue(FM_PROP_COMMAND)); + m_aDatabaseName = ::comphelper::getString(xSet->getPropertyValue(FM_PROP_DATASOURCE)); + m_nObjectType = ::comphelper::getINT32(xSet->getPropertyValue(FM_PROP_COMMANDTYPE)); + + // get the connection of the form + m_aConnection.reset( + connectRowset( Reference< XRowSet >( xForm, UNO_QUERY ), ::comphelper::getProcessComponentContext(), nullptr ), + SharedConnection::NoTakeOwnership + ); + // TODO: When incompatible changes (such as extending the "virtualdbtools" interface by ensureRowSetConnection) + // are allowed, again, we should change this: dbtools should consistently use SharedConnection all over + // the place, and connectRowset should be replaced with ensureRowSetConnection + + // get the fields of the object + + if ( m_aConnection.is() && !m_aObjectName.isEmpty() ) + { + Reference< XComponent > xKeepFieldsAlive; + Reference< XNameAccess > xColumns = getFieldsByCommandDescriptor( m_aConnection, m_nObjectType, m_aObjectName,xKeepFieldsAlive ); + if ( xColumns.is() ) + addToList(xColumns); + } + + // set prefix + OUString aPrefix; + + switch (m_nObjectType) + { + case CommandType::TABLE: + aPrefix = SvxResId(RID_RSC_TABWIN_PREFIX[0]); + break; + case CommandType::QUERY: + aPrefix = SvxResId(RID_RSC_TABWIN_PREFIX[1]); + break; + default: + aPrefix = SvxResId(RID_RSC_TABWIN_PREFIX[2]); + break; + } + + // listen for changes at ControlSource in PropertySet + if (m_xChangeListener.is()) + { + m_xChangeListener->dispose(); + m_xChangeListener.clear(); + } + m_xChangeListener = new ::comphelper::OPropertyChangeMultiplexer(this, xSet); + m_xChangeListener->addProperty(FM_PROP_DATASOURCE); + m_xChangeListener->addProperty(FM_PROP_COMMAND); + m_xChangeListener->addProperty(FM_PROP_COMMANDTYPE); + + // set title + aTitle += " " + aPrefix + " " + m_aObjectName; + m_xDialog->set_title(aTitle); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "FmTabWin::UpdateContent" ); + } +} + +void FmFieldWin::FillInfo( SfxChildWinInfo& rInfo ) const +{ + rInfo.bVisible = false; +} + +SFX_IMPL_MODELESSDIALOGCONTOLLER(FmFieldWinMgr, SID_FM_ADD_FIELD) + +FmFieldWinMgr::FmFieldWinMgr(vcl::Window* _pParent, sal_uInt16 _nId, + SfxBindings* _pBindings, SfxChildWinInfo const * _pInfo) + :SfxChildWindow(_pParent, _nId) +{ + auto xDlg = std::make_shared<FmFieldWin>(_pBindings, this, _pParent->GetFrameWeld()); + SetController(xDlg); + SetHideNotDelete(true); + xDlg->Initialize(_pInfo); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/tbxform.cxx b/svx/source/form/tbxform.cxx new file mode 100644 index 000000000..05576133d --- /dev/null +++ b/svx/source/form/tbxform.cxx @@ -0,0 +1,208 @@ +/* -*- 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 <comphelper/propertyvalue.hxx> +#include <svl/intitem.hxx> +#include <svl/eitem.hxx> +#include <svl/stritem.hxx> +#include <vcl/toolbox.hxx> +#include <vcl/settings.hxx> + +#include <svx/dialmgr.hxx> +#include <svx/labelitemwindow.hxx> +#include <svx/svxids.hrc> +#include <svx/strings.hrc> +#include <tbxform.hxx> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; + +SvxFmAbsRecWin::SvxFmAbsRecWin(vcl::Window* pParent, SfxToolBoxControl* pController) + : RecordItemWindow(pParent) + , m_pController(pController) +{ + m_xWidget->set_width_chars(6); + SetSizePixel(m_xWidget->get_preferred_size()); +} + +void SvxFmAbsRecWin::PositionFired(sal_Int64 nRecord) +{ + SfxInt32Item aPositionParam( FN_PARAM_1, static_cast<sal_Int32>(nRecord) ); + + Any a; + aPositionParam.QueryValue( a ); + Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue("Position", a) }; + m_pController->Dispatch( ".uno:AbsoluteRecord", + aArgs ); + m_pController->updateStatus(); +} + +SFX_IMPL_TOOLBOX_CONTROL( SvxFmTbxCtlAbsRec, SfxInt32Item ); + +SvxFmTbxCtlAbsRec::SvxFmTbxCtlAbsRec( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) + :SfxToolBoxControl( nSlotId, nId, rTbx ) +{ +} + + +SvxFmTbxCtlAbsRec::~SvxFmTbxCtlAbsRec() +{ +} + +void SvxFmTbxCtlAbsRec::StateChangedAtToolBoxControl( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState ) +{ + ToolBoxItemId nId = GetId(); + ToolBox* pToolBox = &GetToolBox(); + SvxFmAbsRecWin* pWin = static_cast<SvxFmAbsRecWin*>( pToolBox->GetItemWindow(nId) ); + + assert(pWin && "Control not found!"); + + if (pState) + { + const SfxInt32Item* pItem = dynamic_cast< const SfxInt32Item* >( pState ); + DBG_ASSERT( pItem, "SvxFmTbxCtlAbsRec::StateChanged: invalid item!" ); + pWin->set_text(OUString::number(pItem ? pItem->GetValue() : -1)); + } + + bool bEnable = SfxItemState::DISABLED != eState && pState; + if (!bEnable) + pWin->set_text(OUString()); + + + // enabling/disabling of the window + pToolBox->EnableItem(nId, bEnable); + SfxToolBoxControl::StateChangedAtToolBoxControl( nSID, eState,pState ); +} + +VclPtr<InterimItemWindow> SvxFmTbxCtlAbsRec::CreateItemWindow( vcl::Window* pParent ) +{ + return VclPtrInstance<SvxFmAbsRecWin>(pParent, this); +} + +SFX_IMPL_TOOLBOX_CONTROL( SvxFmTbxCtlRecText, SfxBoolItem ); + +SvxFmTbxCtlRecText::SvxFmTbxCtlRecText( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) + :SfxToolBoxControl( nSlotId, nId, rTbx ) +{ + rTbx.SetItemWindowNonInteractive(nId, true); +} + +SvxFmTbxCtlRecText::~SvxFmTbxCtlRecText() +{ +} + +VclPtr<InterimItemWindow> SvxFmTbxCtlRecText::CreateItemWindow( vcl::Window* pParent ) +{ + OUString aText(SvxResId(RID_STR_REC_TEXT)); + VclPtrInstance<LabelItemWindow> xFixedText(pParent, aText); + + xFixedText->Show(); + + return xFixedText; +} + +SFX_IMPL_TOOLBOX_CONTROL( SvxFmTbxCtlRecFromText, SfxBoolItem ); + +SvxFmTbxCtlRecFromText::SvxFmTbxCtlRecFromText( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) + :SfxToolBoxControl( nSlotId, nId, rTbx ) +{ + rTbx.SetItemWindowNonInteractive(nId, true); +} + +SvxFmTbxCtlRecFromText::~SvxFmTbxCtlRecFromText() +{ +} + +VclPtr<InterimItemWindow> SvxFmTbxCtlRecFromText::CreateItemWindow( vcl::Window* pParent ) +{ + OUString aText(SvxResId(RID_STR_REC_FROM_TEXT)); + VclPtrInstance<LabelItemWindow> xFixedText(pParent, aText); + + xFixedText->Show(); + + return xFixedText; +} + +SFX_IMPL_TOOLBOX_CONTROL( SvxFmTbxCtlRecTotal, SfxStringItem ); + +SvxFmTbxCtlRecTotal::SvxFmTbxCtlRecTotal( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) + : SfxToolBoxControl( nSlotId, nId, rTbx ) +{ + rTbx.SetItemWindowNonInteractive(nId, true); +} + +SvxFmTbxCtlRecTotal::~SvxFmTbxCtlRecTotal() +{ +} + +VclPtr<InterimItemWindow> SvxFmTbxCtlRecTotal::CreateItemWindow( vcl::Window* pParent ) +{ + m_xFixedText.reset(VclPtr<LabelItemWindow>::Create(pParent, "123456")); + m_xFixedText->set_label(""); + + m_xFixedText->Show(); + + return m_xFixedText; +} + +void SvxFmTbxCtlRecTotal::StateChangedAtToolBoxControl( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState ) +{ + // setting the FixedText + if (GetSlotId() != SID_FM_RECORD_TOTAL) + return; + + OUString aText; + if (pState) + aText = static_cast<const SfxStringItem*>(pState)->GetValue(); + else + aText = "?"; + + m_xFixedText->set_label(aText); + + SfxToolBoxControl::StateChangedAtToolBoxControl( nSID, eState,pState ); +} + +SFX_IMPL_TOOLBOX_CONTROL( SvxFmTbxNextRec, SfxBoolItem ); + + +SvxFmTbxNextRec::SvxFmTbxNextRec( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) + :SfxToolBoxControl( nSlotId, nId, rTbx ) +{ + rTbx.SetItemBits(nId, rTbx.GetItemBits(nId) | ToolBoxItemBits::REPEAT); + + AllSettings aSettings = rTbx.GetSettings(); + MouseSettings aMouseSettings = aSettings.GetMouseSettings(); + aMouseSettings.SetButtonRepeat(aMouseSettings.GetButtonRepeat() / 4); + aSettings.SetMouseSettings(aMouseSettings); + rTbx.SetSettings(aSettings, true); +} + +SFX_IMPL_TOOLBOX_CONTROL( SvxFmTbxPrevRec, SfxBoolItem ); + + +SvxFmTbxPrevRec::SvxFmTbxPrevRec( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) + :SfxToolBoxControl( nSlotId, nId, rTbx ) +{ + rTbx.SetItemBits(nId, rTbx.GetItemBits(nId) | ToolBoxItemBits::REPEAT); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/typemap.cxx b/svx/source/form/typemap.cxx new file mode 100644 index 000000000..b169b745c --- /dev/null +++ b/svx/source/form/typemap.cxx @@ -0,0 +1,52 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <config_options.h> + +#include <sfx2/objitem.hxx> +#include <sfx2/msg.hxx> +#include <svl/memberid.h> +#include <editeng/wghtitem.hxx> +#include <editeng/udlnitem.hxx> +#include <editeng/crossedoutitem.hxx> +#include <editeng/contouritem.hxx> +#include <editeng/shdditem.hxx> +#include <editeng/postitem.hxx> +#include <svx/clipfmtitem.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/charreliefitem.hxx> +#include <editeng/escapementitem.hxx> +#include <editeng/colritem.hxx> +#include <editeng/wrlmitem.hxx> +#include <editeng/charscaleitem.hxx> +#include <editeng/autokernitem.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/lspcitem.hxx> +#include <editeng/langitem.hxx> +#include <editeng/kernitem.hxx> +#include <editeng/adjustitem.hxx> +#include <editeng/emphasismarkitem.hxx> + +#include <editeng/memberids.h> +#define SFX_TYPEMAP +#include <svxslots.hxx> + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/form/xfm_addcondition.cxx b/svx/source/form/xfm_addcondition.cxx new file mode 100644 index 000000000..6c8d6ef35 --- /dev/null +++ b/svx/source/form/xfm_addcondition.cxx @@ -0,0 +1,157 @@ +/* -*- 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 <xfm_addcondition.hxx> + +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <comphelper/processfactory.hxx> +#include <vcl/svapp.hxx> +#include <datanavi.hxx> +#include <fmservs.hxx> + +namespace svxform +{ + +#define PROPERTY_ID_BINDING 5724 +#define PROPERTY_ID_FORM_MODEL 5725 +#define PROPERTY_ID_FACET_NAME 5726 +#define PROPERTY_ID_CONDITION_VALUE 5727 + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::beans; + using namespace ::com::sun::star::xforms; + + + //= OAddConditionDialog + + + Reference< XInterface > OAddConditionDialog_Create( const Reference< XMultiServiceFactory > & _rxORB ) + { + return OAddConditionDialog::Create( _rxORB ); + } + + + Sequence< OUString > OAddConditionDialog_GetSupportedServiceNames() + { + return { "com.sun.star.xforms.ui.dialogs.AddCondition" }; + } + + + OUString OAddConditionDialog_GetImplementationName() + { + return "org.openoffice.comp.svx.OAddConditionDialog"; + } + + OAddConditionDialog::OAddConditionDialog( const Reference< XComponentContext >& _rxORB ) + :OAddConditionDialogBase( _rxORB ) + { + registerProperty( + "Binding", + PROPERTY_ID_BINDING, + PropertyAttribute::TRANSIENT, + &m_xBinding, + cppu::UnoType<decltype(m_xBinding)>::get() + ); + + registerProperty( + "FacetName", + PROPERTY_ID_FACET_NAME, + PropertyAttribute::TRANSIENT, + &m_sFacetName, + cppu::UnoType<decltype(m_sFacetName)>::get() + ); + + registerProperty( + "ConditionValue", + PROPERTY_ID_CONDITION_VALUE, + PropertyAttribute::TRANSIENT, + &m_sConditionValue, + cppu::UnoType<decltype(m_sConditionValue)>::get() + ); + + registerProperty( + "FormModel", + PROPERTY_ID_FORM_MODEL, + PropertyAttribute::TRANSIENT, + &m_xWorkModel, + cppu::UnoType<decltype(m_xWorkModel)>::get() + ); + } + + + Sequence<sal_Int8> SAL_CALL OAddConditionDialog::getImplementationId( ) + { + return css::uno::Sequence<sal_Int8>(); + } + + + Reference< XInterface > OAddConditionDialog::Create( const Reference< XMultiServiceFactory >& _rxFactory ) + { + return *( new OAddConditionDialog( comphelper::getComponentContext(_rxFactory) ) ); + } + + + OUString SAL_CALL OAddConditionDialog::getImplementationName() + { + return OAddConditionDialog_GetImplementationName(); + } + + + Sequence< OUString > SAL_CALL OAddConditionDialog::getSupportedServiceNames() + { + return OAddConditionDialog_GetSupportedServiceNames(); + } + + + Reference<XPropertySetInfo> SAL_CALL OAddConditionDialog::getPropertySetInfo() + { + return createPropertySetInfo( getInfoHelper() ); + } + + ::cppu::IPropertyArrayHelper& OAddConditionDialog::getInfoHelper() + { + return *getArrayHelper(); + } + + ::cppu::IPropertyArrayHelper* OAddConditionDialog::createArrayHelper( ) const + { + Sequence< Property > aProperties; + describeProperties( aProperties ); + return new ::cppu::OPropertyArrayHelper( aProperties ); + } + + std::unique_ptr<weld::DialogController> OAddConditionDialog::createDialog(const css::uno::Reference<css::awt::XWindow>& rParent) + { + if ( !m_xBinding.is() || m_sFacetName.isEmpty() ) + throw RuntimeException( OUString(), *this ); + + return std::make_unique<AddConditionDialog>(Application::GetFrameWeld(rParent), m_sFacetName, m_xBinding); + } + + void OAddConditionDialog::executedDialog( sal_Int16 _nExecutionResult ) + { + OAddConditionDialogBase::executedDialog( _nExecutionResult ); + if ( _nExecutionResult == RET_OK ) + m_sConditionValue = static_cast<AddConditionDialog*>(m_xDialog.get())->GetCondition(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |