Replace some macros in dbaccess part 8

Remove DECLARE_PROPERTY_MULTIPLEXER + IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD
+ IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD + IMPLEMENT_LISTENER_ADMINISTRATION
+ IMPLEMENT_PROPERTY_MULTIPLEXER + IMPLEMENT_PROPERTY_LISTENER_ADMINISTRATION

Change-Id: Ib0522fc895166489c70c163b9d6c0f65cd9a3d59
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/125078
Tested-by: Jenkins
Reviewed-by: Julien Nabet <serval2412@yahoo.fr>

3 files changed, 515 insertions, 210 deletions

diff --git a/dbaccess/source/ui/browser/formadapter.cxx b/dbaccess/source/ui/browser/formadapter.cxx
index a1e9b1f31ecb..344b3ff8dd4d 100644
--- a/dbaccess/source/ui/browser/formadapter.cxx
+++ b/dbaccess/source/ui/browser/formadapter.cxx
@@ -736,7 +736,26 @@ void SAL_CALL SbaXFormAdapter::execute()
         m_xMainForm->execute();
 }
 
-IMPLEMENT_LISTENER_ADMINISTRATION(SbaXFormAdapter, sdbc, RowSetListener, m_aRowSetListeners, css::sdbc::XRowSet, m_xMainForm)
+void SAL_CALL SbaXFormAdapter::addRowSetListener(const css::uno::Reference< css::sdbc::XRowSetListener >& l)
+{
+    m_aRowSetListeners.addInterface(l);
+    if (m_aRowSetListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::sdbc::XRowSet > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addRowSetListener(&m_aRowSetListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removeRowSetListener(const css::uno::Reference< css::sdbc::XRowSetListener >& l)
+{
+    if (m_aRowSetListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::sdbc::XRowSet > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removeRowSetListener(&m_aRowSetListeners);
+    }
+    m_aRowSetListeners.removeInterface(l);
+}
 
 // css::sdbcx::XDeleteRows
 Sequence<sal_Int32> SAL_CALL SbaXFormAdapter::deleteRows(const Sequence< Any >& rows)
@@ -764,10 +783,48 @@ void SAL_CALL SbaXFormAdapter::clearWarnings()
 }
 
 // css::sdb::XRowSetApproveBroadcaster
-IMPLEMENT_LISTENER_ADMINISTRATION(SbaXFormAdapter, sdb, RowSetApproveListener, m_aRowSetApproveListeners, css::sdb::XRowSetApproveBroadcaster, m_xMainForm)
+void SAL_CALL SbaXFormAdapter::addRowSetApproveListener(const css::uno::Reference< css::sdb::XRowSetApproveListener >& l)
+{
+    m_aRowSetApproveListeners.addInterface(l);
+    if (m_aRowSetApproveListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::sdb::XRowSetApproveBroadcaster > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addRowSetApproveListener(&m_aRowSetApproveListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removeRowSetApproveListener(const css::uno::Reference< css::sdb::XRowSetApproveListener >& l)
+{
+    if (m_aRowSetApproveListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::sdb::XRowSetApproveBroadcaster > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removeRowSetApproveListener(&m_aRowSetApproveListeners);
+    }
+    m_aRowSetApproveListeners.removeInterface(l);
+}
 
 // css::sdbc::XSQLErrorBroadcaster
-IMPLEMENT_LISTENER_ADMINISTRATION(SbaXFormAdapter, sdb, SQLErrorListener, m_aErrorListeners, css::sdb::XSQLErrorBroadcaster, m_xMainForm)
+void SAL_CALL SbaXFormAdapter::addSQLErrorListener(const css::uno::Reference< css::sdb::XSQLErrorListener >& l)
+{
+    m_aErrorListeners.addInterface(l);
+    if (m_aErrorListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::sdb::XSQLErrorBroadcaster > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addSQLErrorListener(&m_aErrorListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removeSQLErrorListener(const css::uno::Reference< css::sdb::XSQLErrorListener >& l)
+{
+    if (m_aErrorListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::sdb::XSQLErrorBroadcaster > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removeSQLErrorListener(&m_aErrorListeners);
+    }
+    m_aErrorListeners.removeInterface(l);
+}
 
 // css::sdb::XResultSetAccess
 Reference< css::sdbc::XResultSet > SAL_CALL SbaXFormAdapter::createResultSet()
@@ -808,7 +865,26 @@ sal_Bool SAL_CALL SbaXFormAdapter::isLoaded()
     return false;
 }
 
-IMPLEMENT_LISTENER_ADMINISTRATION(SbaXFormAdapter, form, LoadListener, m_aLoadListeners, css::form::XLoadable, m_xMainForm)
+void SAL_CALL SbaXFormAdapter::addLoadListener(const css::uno::Reference< css::form::XLoadListener>& l)
+{
+    m_aLoadListeners.addInterface(l);
+    if (m_aLoadListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::form::XLoadable > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addLoadListener(&m_aLoadListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removeLoadListener(const css::uno::Reference< css::form::XLoadListener >& l)
+{
+    if (m_aLoadListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::form::XLoadable > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removeLoadListener(&m_aLoadListeners);
+    }
+    m_aLoadListeners.removeInterface(l);
+}
 
 // css::sdbc::XParameters
 void SAL_CALL SbaXFormAdapter::setNull(sal_Int32 parameterIndex, sal_Int32 sqlType)
@@ -1014,7 +1090,26 @@ void SAL_CALL SbaXFormAdapter::submit(const Reference< css::awt::XControl >& aCo
         xSubmit->submit(aControl, aMouseEvt);
 }
 
-IMPLEMENT_LISTENER_ADMINISTRATION(SbaXFormAdapter, form, SubmitListener, m_aSubmitListeners, css::form::XSubmit, m_xMainForm)
+void SAL_CALL SbaXFormAdapter::addSubmitListener(const css::uno::Reference< css::form::XSubmitListener >& l)
+{
+    m_aSubmitListeners.addInterface(l);
+    if (m_aSubmitListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::form::XSubmit > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addSubmitListener(&m_aSubmitListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removeSubmitListener(const css::uno::Reference< css::form::XSubmitListener >& l)
+{
+    if (m_aSubmitListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::form::XSubmit > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removeSubmitListener(&m_aSubmitListeners);
+    }
+    m_aSubmitListeners.removeInterface(l);
+}
 
 // css::awt::XTabControllerModel
 sal_Bool SAL_CALL SbaXFormAdapter::getGroupControl()
@@ -1298,8 +1393,48 @@ Any SAL_CALL SbaXFormAdapter::getPropertyValue(const OUString& PropertyName)
     return xSet->getPropertyValue(PropertyName);
 }
 
-IMPLEMENT_PROPERTY_LISTENER_ADMINISTRATION(SbaXFormAdapter, PropertyChangeListener, m_aPropertyChangeListeners, css::beans::XPropertySet, m_xMainForm);
-IMPLEMENT_PROPERTY_LISTENER_ADMINISTRATION(SbaXFormAdapter, VetoableChangeListener, m_aVetoablePropertyChangeListeners, css::beans::XPropertySet, m_xMainForm);
+void SAL_CALL SbaXFormAdapter::addPropertyChangeListener(const OUString& rName, const css::uno::Reference< css::beans::XPropertyChangeListener>& l )
+{
+    m_aPropertyChangeListeners.addInterface(rName, l);
+    if (m_aPropertyChangeListeners.getOverallLen() == 1)
+    {
+        css::uno::Reference< css::beans::XPropertySet > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addPropertyChangeListener(OUString(), &m_aPropertyChangeListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removePropertyChangeListener(const OUString& rName, const css::uno::Reference< css::beans::XPropertyChangeListener>& l )
+{
+    if (m_aPropertyChangeListeners.getOverallLen() == 1)
+    {
+        css::uno::Reference< css::beans::XPropertySet > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removePropertyChangeListener(OUString(), &m_aPropertyChangeListeners);
+    }
+    m_aPropertyChangeListeners.removeInterface(rName, l);
+}
+
+void SAL_CALL SbaXFormAdapter::addVetoableChangeListener(const OUString& rName, const css::uno::Reference< css::beans::XVetoableChangeListener>& l )
+{
+    m_aVetoablePropertyChangeListeners.addInterface(rName, l);
+    if (m_aVetoablePropertyChangeListeners.getOverallLen() == 1)
+    {
+        css::uno::Reference< css::beans::XPropertySet > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addVetoableChangeListener(OUString(), &m_aVetoablePropertyChangeListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removeVetoableChangeListener(const OUString& rName, const css::uno::Reference< css::beans::XVetoableChangeListener>& l )
+{
+    if (m_aVetoablePropertyChangeListeners.getOverallLen() == 1)
+    {
+        css::uno::Reference< css::beans::XPropertySet > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removeVetoableChangeListener(OUString(), &m_aVetoablePropertyChangeListeners);
+    }
+    m_aVetoablePropertyChangeListeners.removeInterface(rName, l);
+}
+
 
 // css::util::XCancellable
 void SAL_CALL SbaXFormAdapter::cancel()
@@ -1355,7 +1490,26 @@ void SAL_CALL SbaXFormAdapter::reset()
         xReset->reset();
 }
 
-IMPLEMENT_LISTENER_ADMINISTRATION(SbaXFormAdapter, form, ResetListener, m_aResetListeners, css::form::XReset, m_xMainForm)
+void SAL_CALL SbaXFormAdapter::addResetListener(const css::uno::Reference< css::form::XResetListener >& l)
+{
+    m_aResetListeners.addInterface(l);
+    if (m_aResetListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::form::XReset > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->addResetListener(&m_aResetListeners);
+    }
+}
+void SAL_CALL SbaXFormAdapter::removeResetListener(const css::uno::Reference< css::form::XResetListener >& l)
+{
+    if (m_aResetListeners.getLength() == 1)
+    {
+        css::uno::Reference< css::form::XReset > xBroadcaster(m_xMainForm, css::uno::UNO_QUERY);
+        if (xBroadcaster.is())
+            xBroadcaster->removeResetListener(&m_aResetListeners);
+    }
+    m_aResetListeners.removeInterface(l);
+}
 
 // css::container::XNameContainer
 void SbaXFormAdapter::implInsert(const Any& aElement, sal_Int32 nIndex, const OUString* pNewElName)
diff --git a/dbaccess/source/ui/browser/sbamultiplex.cxx b/dbaccess/source/ui/browser/sbamultiplex.cxx
index f31b4c7ac27f..fcc53ea8702e 100644
--- a/dbaccess/source/ui/browser/sbamultiplex.cxx
+++ b/dbaccess/source/ui/browser/sbamultiplex.cxx
@@ -36,46 +36,321 @@ void SAL_CALL SbaXStatusMultiplexer::statusChanged(const css::frame::FeatureStat
 
 // LoadListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXLoadMultiplexer, css::form::XLoadListener)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXLoadMultiplexer, css::form::XLoadListener, loaded, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXLoadMultiplexer, css::form::XLoadListener, unloaded, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXLoadMultiplexer, css::form::XLoadListener, unloading, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXLoadMultiplexer, css::form::XLoadListener, reloading, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXLoadMultiplexer, css::form::XLoadListener, reloaded, css::lang::EventObject)
+void SAL_CALL SbaXLoadMultiplexer::loaded(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::form::XLoadListener*>(aIt.next())->loaded(aMulti);
+}
+void SAL_CALL SbaXLoadMultiplexer::unloaded(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::form::XLoadListener*>(aIt.next())->unloaded(aMulti);
+}
+
+void SAL_CALL SbaXLoadMultiplexer::unloading(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::form::XLoadListener*>(aIt.next())->unloading(aMulti);
+}
+
+void SAL_CALL SbaXLoadMultiplexer::reloading(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::form::XLoadListener*>(aIt.next())->reloading(aMulti);
+}
+
+void SAL_CALL SbaXLoadMultiplexer::reloaded(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::form::XLoadListener*>(aIt.next())->reloaded(aMulti);
+}
+
 
 // css::sdbc::XRowSetListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXRowSetMultiplexer, css::sdbc::XRowSetListener)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXRowSetMultiplexer, css::sdbc::XRowSetListener, cursorMoved, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXRowSetMultiplexer, css::sdbc::XRowSetListener, rowChanged, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXRowSetMultiplexer, css::sdbc::XRowSetListener, rowSetChanged, css::lang::EventObject)
+void SAL_CALL SbaXRowSetMultiplexer::cursorMoved(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::sdbc::XRowSetListener*>(aIt.next())->cursorMoved(aMulti);
+}
+
+void SAL_CALL SbaXRowSetMultiplexer::rowChanged(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::sdbc::XRowSetListener*>(aIt.next())->rowChanged(aMulti);
+}
+
+void SAL_CALL SbaXRowSetMultiplexer::rowSetChanged(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::sdbc::XRowSetListener*>(aIt.next())->rowSetChanged(aMulti);
+}
 
 // css::sdb::XRowSetApproveListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXRowSetApproveMultiplexer, css::sdb::XRowSetApproveListener)
-IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD(SbaXRowSetApproveMultiplexer, css::sdb::XRowSetApproveListener, approveCursorMove, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD(SbaXRowSetApproveMultiplexer, css::sdb::XRowSetApproveListener, approveRowChange, css::sdb::RowChangeEvent)
-IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD(SbaXRowSetApproveMultiplexer, css::sdb::XRowSetApproveListener, approveRowSetChange, css::lang::EventObject)
+sal_Bool SAL_CALL SbaXRowSetApproveMultiplexer::approveCursorMove(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    bool bResult = true;
+    while (bResult && aIt.hasMoreElements())
+        bResult = static_cast< css::sdb::XRowSetApproveListener*>(aIt.next())->approveCursorMove(aMulti);
+    return bResult;
+}
+
+sal_Bool SAL_CALL SbaXRowSetApproveMultiplexer::approveRowChange(const css::sdb::RowChangeEvent& e)
+{
+    css::sdb::RowChangeEvent aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    bool bResult = true;
+    while (bResult && aIt.hasMoreElements())
+        bResult = static_cast< css::sdb::XRowSetApproveListener*>(aIt.next())->approveRowChange(aMulti);
+    return bResult;
+}
+
+sal_Bool SAL_CALL SbaXRowSetApproveMultiplexer::approveRowSetChange(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    bool bResult = true;
+    while (bResult && aIt.hasMoreElements())
+        bResult = static_cast< css::sdb::XRowSetApproveListener*>(aIt.next())->approveRowSetChange(aMulti);
+    return bResult;
+}
 
 // css::sdb::XSQLErrorListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXSQLErrorMultiplexer, css::sdb::XSQLErrorListener)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXSQLErrorMultiplexer, css::sdb::XSQLErrorListener, errorOccured, css::sdb::SQLErrorEvent)
+void SAL_CALL SbaXSQLErrorMultiplexer::errorOccured(const css::sdb::SQLErrorEvent& e)
+{
+    css::sdb::SQLErrorEvent aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::sdb::XSQLErrorListener*>(aIt.next())->errorOccured(aMulti);
+}
 
 // css::form::XDatabaseParameterListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXParameterMultiplexer, css::form::XDatabaseParameterListener)
-IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD(SbaXParameterMultiplexer, css::form::XDatabaseParameterListener, approveParameter, css::form::DatabaseParameterEvent)
+sal_Bool SAL_CALL SbaXParameterMultiplexer::approveParameter(const css::form::DatabaseParameterEvent& e)
+{
+    css::form::DatabaseParameterEvent aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    bool bResult = true;
+    while (bResult && aIt.hasMoreElements())
+        bResult = static_cast< css::form::XDatabaseParameterListener*>(aIt.next())->approveParameter(aMulti);
+    return bResult;
+}
 
 // css::form::XSubmitListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXSubmitMultiplexer, css::form::XSubmitListener)
-IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD(SbaXSubmitMultiplexer, css::form::XSubmitListener, approveSubmit, css::lang::EventObject)
+sal_Bool SAL_CALL SbaXSubmitMultiplexer::approveSubmit(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    bool bResult = true;
+    while (bResult && aIt.hasMoreElements())
+        bResult = static_cast< css::form::XSubmitListener*>(aIt.next())->approveSubmit(aMulti);
+    return bResult;
+}
 
 // css::form::XResetListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXResetMultiplexer, css::form::XResetListener)
-IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD(SbaXResetMultiplexer, css::form::XResetListener, approveReset, css::lang::EventObject)
-IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(SbaXResetMultiplexer, css::form::XResetListener, resetted, css::lang::EventObject)
+sal_Bool SAL_CALL SbaXResetMultiplexer::approveReset(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    bool bResult = true;
+    while (bResult && aIt.hasMoreElements())
+        bResult = static_cast< css::form::XResetListener*>(aIt.next())->approveReset(aMulti);
+    return bResult;
+}
+
+void SAL_CALL SbaXResetMultiplexer::resetted(const css::lang::EventObject& e)
+{
+    css::lang::EventObject aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(*this);
+    while (aIt.hasMoreElements())
+        static_cast< css::form::XResetListener*>(aIt.next())->resetted(aMulti);
+}
 
 // css::beans::XPropertyChangeListener
-IMPLEMENT_PROPERTY_MULTIPLEXER(SbaXPropertyChangeMultiplexer, css::beans::XPropertyChangeListener, propertyChange, css::beans::PropertyChangeEvent)
+SbaXPropertyChangeMultiplexer::SbaXPropertyChangeMultiplexer(::cppu::OWeakObject& rSource, ::osl::Mutex& rMutex)
+    :OSbaWeakSubObject(rSource)
+    ,m_aListeners(rMutex)
+{
+}
+
+css::uno::Any  SAL_CALL SbaXPropertyChangeMultiplexer::queryInterface(const css::uno::Type& _rType)
+{
+    css::uno::Any aReturn = OSbaWeakSubObject::queryInterface(_rType);
+    if (!aReturn.hasValue())
+        aReturn = ::cppu::queryInterface(_rType,
+            static_cast< css::beans::XPropertyChangeListener* >(this),
+            static_cast< css::lang::XEventListener* >(static_cast< css::beans::XPropertyChangeListener* >(this))
+        );
+
+    return aReturn;
+}
+void SAL_CALL SbaXPropertyChangeMultiplexer::disposing(const css::lang::EventObject& )
+{
+}
+void SAL_CALL SbaXPropertyChangeMultiplexer::propertyChange(const css::beans::PropertyChangeEvent& e)
+{
+    ::comphelper::OInterfaceContainerHelper2* pListeners = m_aListeners.getContainer(e.PropertyName);
+    if (pListeners)
+        Notify(*pListeners, e);
+
+    /* do the notification for the unspecialized listeners, too */
+    pListeners = m_aListeners.getContainer(OUString());
+    if (pListeners)
+        Notify(*pListeners, e);
+}
+
+void SbaXPropertyChangeMultiplexer::addInterface(const OUString& rName,
+    const css::uno::Reference< css::uno::XInterface > & rListener)
+{
+    m_aListeners.addInterface(rName, rListener);
+}
+
+void SbaXPropertyChangeMultiplexer::removeInterface(const OUString& rName,
+    const css::uno::Reference< css::uno::XInterface > & rListener)
+{
+    m_aListeners.removeInterface(rName, rListener);
+}
+
+void SbaXPropertyChangeMultiplexer::disposeAndClear()
+{
+    css::lang::EventObject aEvt(m_rParent);
+    m_aListeners.disposeAndClear(aEvt);
+}
+
+sal_Int32 SbaXPropertyChangeMultiplexer::getOverallLen() const
+{
+    sal_Int32 nLen = 0;
+    const std::vector< OUString > aContained = m_aListeners.getContainedTypes();
+    for ( OUString const & s : aContained)
+    {
+        ::comphelper::OInterfaceContainerHelper2* pListeners = m_aListeners.getContainer(s);
+        if (!pListeners)
+            continue;
+        nLen += pListeners->getLength();
+    }
+    return nLen;
+}
+
+void SbaXPropertyChangeMultiplexer::Notify(::comphelper::OInterfaceContainerHelper2& rListeners, const css::beans::PropertyChangeEvent& e)
+{
+    css::beans::PropertyChangeEvent aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(rListeners);
+    while (aIt.hasMoreElements())
+        static_cast< css::beans::XPropertyChangeListener*>(aIt.next())->propertyChange(aMulti);
+}
 
 // css::beans::XVetoableChangeListener
-IMPLEMENT_PROPERTY_MULTIPLEXER(SbaXVetoableChangeMultiplexer, css::beans::XVetoableChangeListener, vetoableChange, css::beans::PropertyChangeEvent)
+SbaXVetoableChangeMultiplexer::SbaXVetoableChangeMultiplexer(::cppu::OWeakObject& rSource, ::osl::Mutex& rMutex)
+    :OSbaWeakSubObject(rSource)
+    ,m_aListeners(rMutex)
+{
+}
+
+css::uno::Any  SAL_CALL SbaXVetoableChangeMultiplexer::queryInterface(const css::uno::Type& _rType)
+{
+    css::uno::Any aReturn = OSbaWeakSubObject::queryInterface(_rType);
+    if (!aReturn.hasValue())
+        aReturn = ::cppu::queryInterface(_rType,
+            static_cast< css::beans::XVetoableChangeListener* >(this),
+            static_cast< css::lang::XEventListener* >(static_cast< css::beans::XVetoableChangeListener* >(this))
+        );
+
+    return aReturn;
+}
+void SAL_CALL SbaXVetoableChangeMultiplexer::disposing(const css::lang::EventObject& )
+{
+}
+void SAL_CALL SbaXVetoableChangeMultiplexer::vetoableChange(const css::beans::PropertyChangeEvent& e)
+{
+    ::comphelper::OInterfaceContainerHelper2* pListeners = m_aListeners.getContainer(e.PropertyName);
+    if (pListeners)
+        Notify(*pListeners, e);
+
+    /* do the notification for the unspecialized listeners, too */
+    pListeners = m_aListeners.getContainer(OUString());
+    if (pListeners)
+        Notify(*pListeners, e);
+}
+
+void SbaXVetoableChangeMultiplexer::addInterface(const OUString& rName,
+    const css::uno::Reference< css::uno::XInterface > & rListener)
+{
+    m_aListeners.addInterface(rName, rListener);
+}
+
+void SbaXVetoableChangeMultiplexer::removeInterface(const OUString& rName,
+    const css::uno::Reference< css::uno::XInterface > & rListener)
+{
+    m_aListeners.removeInterface(rName, rListener);
+}
+
+void SbaXVetoableChangeMultiplexer::disposeAndClear()
+{
+    css::lang::EventObject aEvt(m_rParent);
+    m_aListeners.disposeAndClear(aEvt);
+}
+
+sal_Int32 SbaXVetoableChangeMultiplexer::getOverallLen() const
+{
+    sal_Int32 nLen = 0;
+    const std::vector< OUString > aContained = m_aListeners.getContainedTypes();
+    for ( OUString const & s : aContained)
+    {
+        ::comphelper::OInterfaceContainerHelper2* pListeners = m_aListeners.getContainer(s);
+        if (!pListeners)
+            continue;
+        nLen += pListeners->getLength();
+    }
+    return nLen;
+}
+
+void SbaXVetoableChangeMultiplexer::Notify(::comphelper::OInterfaceContainerHelper2& rListeners, const css::beans::PropertyChangeEvent& e)
+{
+    css::beans::PropertyChangeEvent aMulti(e);
+    aMulti.Source = &m_rParent;
+    ::comphelper::OInterfaceIteratorHelper2 aIt(rListeners);
+    while (aIt.hasMoreElements())
+        static_cast< css::beans::XVetoableChangeListener*>(aIt.next())->vetoableChange(aMulti);
+}
 
 // css::beans::XPropertiesChangeListener
 IMPLEMENT_LISTENER_MULTIPLEXER_CORE(SbaXPropertiesChangeMultiplexer, css::beans::XPropertiesChangeListener);
diff --git a/dbaccess/source/ui/inc/sbamultiplex.hxx b/dbaccess/source/ui/inc/sbamultiplex.hxx
index a83d5543b61d..286fa3c8bfc7 100644
--- a/dbaccess/source/ui/inc/sbamultiplex.hxx
+++ b/dbaccess/source/ui/inc/sbamultiplex.hxx
@@ -107,50 +107,6 @@ namespace dbaui
     {                                                                                       \
     }                                                                                       \
 
-    #define IMPLEMENT_LISTENER_MULTIPLEXER_VOID_METHOD(classname, listenerclass, methodname, eventtype) \
-    void SAL_CALL classname::methodname(const eventtype& e) \
-    {                                                                                       \
-        eventtype aMulti(e);                                                                \
-        aMulti.Source = &m_rParent;                                                         \
-        ::comphelper::OInterfaceIteratorHelper2 aIt(*this);                                        \
-        while (aIt.hasMoreElements())                                                       \
-            static_cast< listenerclass*>(aIt.next())->methodname(aMulti);               \
-    }                                                                                       \
-
-    #define IMPLEMENT_LISTENER_MULTIPLEXER_BOOL_METHOD(classname, listenerclass, methodname, eventtype) \
-    sal_Bool SAL_CALL classname::methodname(const eventtype& e) \
-    {                                                                                       \
-        eventtype aMulti(e);                                                                \
-        aMulti.Source = &m_rParent;                                                         \
-        ::comphelper::OInterfaceIteratorHelper2 aIt(*this);                                        \
-        bool bResult = true;                                                        \
-        while (bResult && aIt.hasMoreElements())                                            \
-            bResult = static_cast< listenerclass*>(aIt.next())->methodname(aMulti);     \
-        return bResult;                                                                     \
-    }                                                                                       \
-
-    // helper for classes which do event multiplexing
-    #define IMPLEMENT_LISTENER_ADMINISTRATION(classname, listenernamespace, listenerdesc, multiplexer, broadcasterclass, broadcaster) \
-    void SAL_CALL classname::add##listenerdesc(const css::uno::Reference< css::listenernamespace::X##listenerdesc >& l)\
-    {                                                                                       \
-        multiplexer.addInterface(l);                                                            \
-        if (multiplexer.getLength() == 1)                                                   \
-        {                                                                                   \
-            css::uno::Reference< broadcasterclass > xBroadcaster(broadcaster, css::uno::UNO_QUERY);   \
-            if (xBroadcaster.is())                                                          \
-                xBroadcaster->add##listenerdesc(&multiplexer);                              \
-        }                                                                                   \
-    }                                                                                       \
-    void SAL_CALL classname::remove##listenerdesc(const css::uno::Reference< css::listenernamespace::X##listenerdesc >& l)\
-    {                                                                                       \
-        if (multiplexer.getLength() == 1)                                                   \
-        {                                                                                   \
-            css::uno::Reference< broadcasterclass > xBroadcaster(broadcaster, css::uno::UNO_QUERY);   \
-            if (xBroadcaster.is())                                                          \
-                xBroadcaster->remove##listenerdesc(&multiplexer);                           \
-        }                                                                                   \
-        multiplexer.removeInterface(l);                                                     \
-    }                                                                                       \
 
     #define STOP_MULTIPLEXER_LISTENING(listenerdesc, multiplexer, broadcasterclass, broadcaster) \
     if (multiplexer.getLength())                                                            \
@@ -168,144 +124,6 @@ namespace dbaui
             xBroadcaster->add##listenerdesc(&multiplexer);                              \
     }                                                                                   \
 
-    // declaration of property listener multiplexers
-    // (with support for specialized and unspecialized property listeners)
-
-    #define DECLARE_PROPERTY_MULTIPLEXER(classname, listenerclass, methodname, eventtype)   \
-    class classname final                                                                   \
-            :public OSbaWeakSubObject                                                           \
-            ,public listenerclass                                                           \
-    {                                                                                       \
-        typedef ::comphelper::OMultiTypeInterfaceContainerHelperVar2<                              \
-                OUString >  ListenerContainerMap;   \
-        ListenerContainerMap    m_aListeners;                                               \
-                                                                                            \
-    public:                                                                                 \
-        classname( ::cppu::OWeakObject& rSource, ::osl::Mutex& rMutex );                    \
-        DECLARE_UNO3_DEFAULTS(classname, OSbaWeakSubObject)                                     \
-        virtual css::uno::Any  SAL_CALL queryInterface(                        \
-            const css::uno::Type& _rType) override; \
-                                                                                            \
-        /* css::lang::XEventListener */                                        \
-        virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;  \
-                                                                                            \
-        virtual void SAL_CALL methodname(const eventtype& e) override;             \
-                                                                                            \
-        void addInterface(const OUString& rName, const css::uno::Reference< css::uno::XInterface >& rListener);    \
-        void removeInterface(const OUString& rName, const css::uno::Reference< css::uno::XInterface >& rListener); \
-                                                                                            \
-        void disposeAndClear();                                                             \
-                                                                                            \
-        sal_Int32 getOverallLen() const;                                                    \
-                                                                                            \
-        ::comphelper::OInterfaceContainerHelper2* getContainer(const OUString& rName)       \
-            { return m_aListeners.getContainer(rName); }                                    \
-                                                                                            \
-    private:                                                                                \
-        void Notify(::comphelper::OInterfaceContainerHelper2& rListeners, const eventtype& e);     \
-    };                                                                                      \
-
-    // implementation of property listener multiplexers
-    #define IMPLEMENT_PROPERTY_MULTIPLEXER(classname, listenerclass, methodname, eventtype) \
-    classname::classname(::cppu::OWeakObject& rSource, ::osl::Mutex& rMutex)                \
-            :OSbaWeakSubObject(rSource)                                                     \
-            ,m_aListeners(rMutex)                                                           \
-    {                                                                                       \
-    }                                                                                       \
-                                                                                            \
-    css::uno::Any  SAL_CALL classname::queryInterface(                         \
-        const css::uno::Type& _rType) \
-    {                                                                                       \
-        css::uno::Any aReturn =                                                \
-            OSbaWeakSubObject::queryInterface(_rType);                                          \
-        if (!aReturn.hasValue())                                                            \
-            aReturn = ::cppu::queryInterface(_rType,                                        \
-                static_cast< listenerclass* >(this),                                        \
-                static_cast< css::lang::XEventListener* >(static_cast< listenerclass* >(this)) \
-            );                                                                              \
-                                                                                            \
-        return aReturn;                                                                     \
-    }                                                                                       \
-    void SAL_CALL classname::disposing(const css::lang::EventObject& )\
-    {                                                                                       \
-    }                                                                                       \
-                                                                                            \
-    void SAL_CALL classname::methodname(const eventtype& e)                \
-    {                                                                                       \
-        ::comphelper::OInterfaceContainerHelper2* pListeners = m_aListeners.getContainer(e.PropertyName);  \
-        if (pListeners)                                                                     \
-            Notify(*pListeners, e);                                                         \
-                                                                                            \
-        /* do the notification for the unspecialized listeners, too */                      \
-        pListeners = m_aListeners.getContainer(OUString());                          \
-        if (pListeners)                                                                     \
-            Notify(*pListeners, e);                                                         \
-    }                                                                                       \
-                                                                                            \
-    void classname::addInterface(const OUString& rName,                              \
-            const css::uno::Reference< css::uno::XInterface > & rListener)    \
-    {                                                                                       \
-        m_aListeners.addInterface(rName, rListener);                                        \
-    }                                                                                       \
-                                                                                            \
-    void classname::removeInterface(const OUString& rName,                           \
-            const css::uno::Reference< css::uno::XInterface > & rListener)    \
-    {                                                                                       \
-        m_aListeners.removeInterface(rName, rListener);                                     \
-    }                                                                                       \
-                                                                                            \
-    void classname::disposeAndClear()                                                       \
-    {                                                                                       \
-        css::lang::EventObject aEvt(m_rParent);                                \
-        m_aListeners.disposeAndClear(aEvt);                                                             \
-    }                                                                                       \
-                                                                                            \
-    sal_Int32 classname::getOverallLen() const                                              \
-    {                                                                                       \
-        sal_Int32 nLen = 0;                                                                 \
-        const std::vector< OUString > aContained = m_aListeners.getContainedTypes(); \
-        for ( OUString const & s : aContained)                 \
-        {                                                                                   \
-            ::comphelper::OInterfaceContainerHelper2* pListeners = m_aListeners.getContainer(s);  \
-            if (!pListeners)                                                                \
-                continue;                                                                   \
-            nLen += pListeners->getLength();                                                \
-        }                                                                                   \
-        return nLen;                                                                        \
-    }                                                                                       \
-                                                                                            \
-    void classname::Notify(::comphelper::OInterfaceContainerHelper2& rListeners, const eventtype& e)   \
-    {                                                                                       \
-        eventtype aMulti(e);                                                                \
-        aMulti.Source = &m_rParent;                                                         \
-        ::comphelper::OInterfaceIteratorHelper2 aIt(rListeners);                                   \
-        while (aIt.hasMoreElements())                                                       \
-            static_cast< listenerclass*>(aIt.next())->methodname(aMulti);               \
-    }                                                                                       \
-
-    // helper for classes which do property event multiplexing
-    #define IMPLEMENT_PROPERTY_LISTENER_ADMINISTRATION(classname, listenerdesc, multiplexer, broadcasterclass, broadcaster) \
-    void SAL_CALL classname::add##listenerdesc(const OUString& rName, const css::uno::Reference< css::beans::X##listenerdesc >& l )\
-    {                                                                                       \
-        multiplexer.addInterface(rName, l);                                                 \
-        if (multiplexer.getOverallLen() == 1)                                               \
-        {                                                                                   \
-            css::uno::Reference< broadcasterclass > xBroadcaster(broadcaster, css::uno::UNO_QUERY);   \
-            if (xBroadcaster.is())                                                          \
-                xBroadcaster->add##listenerdesc(OUString(), &multiplexer);                           \
-        }                                                                                   \
-    }                                                                                       \
-    void SAL_CALL classname::remove##listenerdesc(const OUString& rName, const css::uno::Reference< css::beans::X##listenerdesc >& l )\
-    {                                                                                       \
-        if (multiplexer.getOverallLen() == 1)                                               \
-        {                                                                                   \
-            css::uno::Reference< broadcasterclass > xBroadcaster(broadcaster, css::uno::UNO_QUERY);   \
-            if (xBroadcaster.is())                                                          \
-                xBroadcaster->remove##listenerdesc(OUString(), &multiplexer);                        \
-        }                                                                                   \
-        multiplexer.removeInterface(rName, l);                                              \
-    }                                                                                       \
-
     #define STOP_PROPERTY_MULTIPLEXER_LISTENING(listenerdesc, multiplexer, broadcasterclass, broadcaster) \
     if (multiplexer.getOverallLen())                                                        \
     {                                                                                       \
@@ -378,10 +196,68 @@ namespace dbaui
     END_DECLARE_LISTENER_MULTIPLEXER()
 
     // css::beans::XPropertyChangeListener
-    DECLARE_PROPERTY_MULTIPLEXER(SbaXPropertyChangeMultiplexer, css::beans::XPropertyChangeListener, propertyChange, css::beans::PropertyChangeEvent)
+    class SbaXPropertyChangeMultiplexer final
+            :public OSbaWeakSubObject
+            ,public css::beans::XPropertyChangeListener
+    {
+        typedef ::comphelper::OMultiTypeInterfaceContainerHelperVar2<OUString >  ListenerContainerMap;
+        ListenerContainerMap    m_aListeners;
+
+    public:
+        SbaXPropertyChangeMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& rMutex );
+        DECLARE_UNO3_DEFAULTS(SbaXPropertyChangeMultiplexer, OSbaWeakSubObject)
+        virtual css::uno::Any  SAL_CALL queryInterface(const css::uno::Type& _rType) override;
+
+        /* css::lang::XEventListener */
+        virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
+
+        virtual void SAL_CALL propertyChange(const css::beans::PropertyChangeEvent& e) override;
+
+        void addInterface(const OUString& rName, const css::uno::Reference< css::uno::XInterface >& rListener);
+        void removeInterface(const OUString& rName, const css::uno::Reference< css::uno::XInterface >& rListener);
+
+        void disposeAndClear();
+
+        sal_Int32 getOverallLen() const;
+
+        ::comphelper::OInterfaceContainerHelper2* getContainer(const OUString& rName)
+            { return m_aListeners.getContainer(rName); }
+
+    private:
+        void Notify(::comphelper::OInterfaceContainerHelper2& rListeners, const css::beans::PropertyChangeEvent& e);
+    };
 
     // css::beans::XVetoableChangeListener
-    DECLARE_PROPERTY_MULTIPLEXER(SbaXVetoableChangeMultiplexer, css::beans::XVetoableChangeListener, vetoableChange, css::beans::PropertyChangeEvent)
+    class SbaXVetoableChangeMultiplexer final
+            :public OSbaWeakSubObject
+            ,public css::beans::XVetoableChangeListener
+    {
+        typedef ::comphelper::OMultiTypeInterfaceContainerHelperVar2<OUString >  ListenerContainerMap;
+        ListenerContainerMap    m_aListeners;
+
+    public:
+        SbaXVetoableChangeMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& rMutex );
+        DECLARE_UNO3_DEFAULTS(SbaXVetoableChangeMultiplexer, OSbaWeakSubObject)
+        virtual css::uno::Any  SAL_CALL queryInterface(const css::uno::Type& _rType) override;
+
+        /* css::lang::XEventListener */
+        virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
+
+        virtual void SAL_CALL vetoableChange(const css::beans::PropertyChangeEvent& e) override;
+
+        void addInterface(const OUString& rName, const css::uno::Reference< css::uno::XInterface >& rListener);
+        void removeInterface(const OUString& rName, const css::uno::Reference< css::uno::XInterface >& rListener);
+
+        void disposeAndClear();
+
+        sal_Int32 getOverallLen() const;
+
+        ::comphelper::OInterfaceContainerHelper2* getContainer(const OUString& rName)
+            { return m_aListeners.getContainer(rName); }
+
+    private:
+        void Notify(::comphelper::OInterfaceContainerHelper2& rListeners, const css::beans::PropertyChangeEvent& e);
+    };
 
     // css::beans::XPropertiesChangeListener
     BEGIN_DECLARE_LISTENER_MULTIPLEXER(SbaXPropertiesChangeMultiplexer, css::beans::XPropertiesChangeListener)