tabledesign.cxx


/* -*- 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/style/XStyle.hpp>
#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/util/XModifiable.hpp>
#include <com/sun/star/util/XModifyListener.hpp>
#include <com/sun/star/form/XReset.hpp>
 
#include <vcl/svapp.hxx>
 
#include <comphelper/compbase.hxx>
#include <comphelper/interfacecontainer4.hxx>
#include <cppuhelper/implbase.hxx>
#include <cppuhelper/supportsservice.hxx>
#include <comphelper/sequence.hxx>
 
#include <svx/sdr/table/tabledesign.hxx>
#include <svx/dialmgr.hxx>
#include <svx/strings.hrc>
 
#include "sdrtableobjimpl.hxx"
 
#include <vector>
#include <map>
 
 
using namespace css;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::style;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::container;
 
namespace sdr::table {
 
typedef std::map< OUString, sal_Int32 > CellStyleNameMap;
 
typedef ::comphelper::WeakComponentImplHelper< XStyle, XNameReplace, XServiceInfo, XIndexReplace, XModifiable, XModifyListener, XPropertySet > TableDesignStyleBase;
 
namespace {
 
class TableDesignStyle : public TableDesignStyleBase
{
public:
    TableDesignStyle();
 
    // XServiceInfo
    virtual OUString SAL_CALL getImplementationName() override;
    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 
    // XStyle
    virtual sal_Bool SAL_CALL isUserDefined() override;
    virtual sal_Bool SAL_CALL isInUse() override;
    virtual OUString SAL_CALL getParentStyle() override;
    virtual void SAL_CALL setParentStyle( const OUString& aParentStyle ) override;
 
    // XNamed
    virtual OUString SAL_CALL getName() override;
    virtual void SAL_CALL setName( const OUString& aName ) override;
 
    // XNameAccess
    virtual Any SAL_CALL getByName( const OUString& aName ) override;
    virtual Sequence< OUString > SAL_CALL getElementNames() override;
    virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
 
    // XElementAccess
    virtual css::uno::Type SAL_CALL getElementType() override;
    virtual sal_Bool SAL_CALL hasElements() override;
 
    // XIndexAccess
    virtual sal_Int32 SAL_CALL getCount() override ;
    virtual Any SAL_CALL getByIndex( sal_Int32 Index ) override;
 
    // XIndexReplace
    virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const Any& Element ) override;
 
    // XNameReplace
    virtual void SAL_CALL replaceByName( const OUString& aName, const Any& aElement ) override;
 
    // XPropertySet
    virtual Reference<XPropertySetInfo> SAL_CALL getPropertySetInfo() override;
    virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const Any& aValue ) override;
    virtual Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override;
    virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName, const Reference<XPropertyChangeListener>& xListener ) override;
    virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName, const Reference<XPropertyChangeListener>& aListener ) override;
    virtual void SAL_CALL addVetoableChangeListener(const OUString& PropertyName, const Reference<XVetoableChangeListener>& aListener ) override;
    virtual void SAL_CALL removeVetoableChangeListener(const OUString& PropertyName,const Reference<XVetoableChangeListener>&aListener ) override;
 
    // XModifiable
    virtual sal_Bool SAL_CALL isModified() override;
    virtual void SAL_CALL setModified( sal_Bool bModified ) override;
 
    // XModifyBroadcaster
    virtual void SAL_CALL addModifyListener( const Reference< XModifyListener >& aListener ) override;
    virtual void SAL_CALL removeModifyListener( const Reference< XModifyListener >& aListener ) override;
 
    // XModifyListener
    virtual void SAL_CALL modified( const css::lang::EventObject& aEvent ) override;
    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
 
    void notifyModifyListener();
    void resetUserDefined();
 
    // this function is called upon disposing the component
    virtual void disposing(std::unique_lock<std::mutex>& aGuard) override;
 
    static const CellStyleNameMap& getCellStyleNameMap();
 
    bool mbUserDefined, mbModified;
    OUString msName;
    Reference< XStyle > maCellStyles[style_count];
    comphelper::OInterfaceContainerHelper4<XModifyListener> maModifyListeners;
};
 
}
 
typedef std::vector< Reference< XStyle > > TableDesignStyleVector;
 
namespace {
 
class TableDesignFamily : public ::cppu::WeakImplHelper< XNameContainer, XNamed, XIndexAccess, XSingleServiceFactory,  XServiceInfo, XComponent, XPropertySet, form::XReset >
{
public:
    // XServiceInfo
    virtual OUString SAL_CALL getImplementationName() override;
    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 
    // XNamed
    virtual OUString SAL_CALL getName(  ) override;
    virtual void SAL_CALL setName( const OUString& aName ) override;
 
    // XNameAccess
    virtual Any SAL_CALL getByName( const OUString& aName ) override;
    virtual Sequence< OUString > SAL_CALL getElementNames() override;
    virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
 
    // XElementAccess
    virtual Type SAL_CALL getElementType() override;
    virtual sal_Bool SAL_CALL hasElements() override;
 
    // XIndexAccess
    virtual sal_Int32 SAL_CALL getCount() override ;
    virtual Any SAL_CALL getByIndex( sal_Int32 Index ) override;
 
    // XNameContainer
    virtual void SAL_CALL insertByName( const OUString& aName, const Any& aElement ) override;
    virtual void SAL_CALL removeByName( const OUString& Name ) override;
 
    // XNameReplace
    virtual void SAL_CALL replaceByName( const OUString& aName, const Any& aElement ) override;
 
    // XSingleServiceFactory
    virtual Reference< XInterface > SAL_CALL createInstance(  ) override;
    virtual Reference< XInterface > SAL_CALL createInstanceWithArguments( const Sequence< Any >& aArguments ) override;
 
    // XComponent
    virtual void SAL_CALL dispose(  ) override;
    virtual void SAL_CALL addEventListener( const Reference< XEventListener >& xListener ) override;
    virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& aListener ) override;
 
    // XPropertySet
    virtual Reference<XPropertySetInfo> SAL_CALL getPropertySetInfo() override;
    virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const Any& aValue ) override;
    virtual Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override;
    virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName, const Reference<XPropertyChangeListener>& xListener ) override;
    virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName, const Reference<XPropertyChangeListener>& aListener ) override;
    virtual void SAL_CALL addVetoableChangeListener(const OUString& PropertyName, const Reference<XVetoableChangeListener>& aListener ) override;
    virtual void SAL_CALL removeVetoableChangeListener(const OUString& PropertyName,const Reference<XVetoableChangeListener>&aListener ) override;
 
    // XReset
    virtual void SAL_CALL reset() override;
    virtual void SAL_CALL addResetListener( const Reference<form::XResetListener>& aListener ) override;
    virtual void SAL_CALL removeResetListener( const Reference<form::XResetListener>& aListener ) override;
 
    TableDesignStyleVector  maDesigns;
};
 
}
 
TableDesignStyle::TableDesignStyle()
    : mbUserDefined(true)
    , mbModified(false)
{
}
 
const CellStyleNameMap& TableDesignStyle::getCellStyleNameMap()
{
    static CellStyleNameMap const aMap
    {
         { u"first-row"_ustr    , first_row_style },
         { u"last-row"_ustr     , last_row_style },
         { u"first-column"_ustr , first_column_style },
         { u"last-column"_ustr  , last_column_style },
         { u"body"_ustr         , body_style },
         { u"even-rows"_ustr    , even_rows_style },
         { u"odd-rows"_ustr     , odd_rows_style },
         { u"even-columns"_ustr , even_columns_style },
         { u"odd-columns"_ustr  , odd_columns_style },
         { u"background"_ustr   , background_style },
    };
 
    return aMap;
}
 
// XServiceInfo
OUString SAL_CALL TableDesignStyle::getImplementationName()
{
    return u"TableDesignStyle"_ustr;
}
 
sal_Bool SAL_CALL TableDesignStyle::supportsService( const OUString& ServiceName )
{
    return cppu::supportsService( this, ServiceName );
}
 
Sequence< OUString > SAL_CALL TableDesignStyle::getSupportedServiceNames()
{
    return { u"com.sun.star.style.Style"_ustr };
}
 
// XStyle
sal_Bool SAL_CALL TableDesignStyle::isUserDefined()
{
    return mbUserDefined;
}
 
void TableDesignStyle::resetUserDefined()
{
    mbUserDefined = false;
}
 
sal_Bool SAL_CALL TableDesignStyle::isInUse()
{
    std::unique_lock aGuard( m_aMutex );
    if (maModifyListeners.getLength(aGuard))
    {
        comphelper::OInterfaceIteratorHelper4 it(aGuard, maModifyListeners);
        while ( it.hasMoreElements() )
        {
            SdrTableObjImpl* pUser = dynamic_cast< SdrTableObjImpl* >( it.next().get() );
            if( pUser && pUser->isInUse() )
                return true;
        }
    }
    return false;
}
 
 
OUString SAL_CALL TableDesignStyle::getParentStyle()
{
    return OUString();
}
 
 
void SAL_CALL TableDesignStyle::setParentStyle( const OUString& )
{
}
 
 
// XNamed
 
 
OUString SAL_CALL TableDesignStyle::getName()
{
    return msName;
}
 
 
void SAL_CALL TableDesignStyle::setName( const OUString& rName )
{
    msName = rName;
}
 
 
// XNameAccess
 
 
Any SAL_CALL TableDesignStyle::getByName( const OUString& rName )
{
    const CellStyleNameMap& rMap = getCellStyleNameMap();
 
    CellStyleNameMap::const_iterator iter = rMap.find( rName );
    if( iter == rMap.end() )
        throw NoSuchElementException();
 
    return Any( maCellStyles[(*iter).second] );
}
 
 
Sequence< OUString > SAL_CALL TableDesignStyle::getElementNames()
{
    return comphelper::mapKeysToSequence( getCellStyleNameMap() );
}
 
 
sal_Bool SAL_CALL TableDesignStyle::hasByName( const OUString& rName )
{
    const CellStyleNameMap& rMap = getCellStyleNameMap();
 
    CellStyleNameMap::const_iterator iter = rMap.find( rName );
    return iter != rMap.end();
}
 
 
// XElementAccess
 
 
Type SAL_CALL TableDesignStyle::getElementType()
{
    return cppu::UnoType<XStyle>::get();
}
 
 
sal_Bool SAL_CALL TableDesignStyle::hasElements()
{
    return true;
}
 
 
// XIndexAccess
 
 
sal_Int32 SAL_CALL TableDesignStyle::getCount()
{
    return style_count;
}
 
 
Any SAL_CALL TableDesignStyle::getByIndex( sal_Int32 Index )
{
    if( (Index < 0) || (Index >= style_count) )
        throw IndexOutOfBoundsException();
 
    std::unique_lock aGuard( m_aMutex );
    return Any( maCellStyles[Index] );
}
 
 
// XIndexReplace
 
void SAL_CALL TableDesignStyle::replaceByIndex( sal_Int32 Index, const Any& aElement )
{
    if( (Index < 0) || (Index >= style_count) )
        throw IndexOutOfBoundsException();
 
    const CellStyleNameMap& rMap = getCellStyleNameMap();
    auto iter = std::find_if(rMap.begin(), rMap.end(),
        [&Index](const auto& item) { return Index == item.second; });
    if (iter != rMap.end())
        replaceByName(iter->first, aElement);
}
 
 
// XNameReplace
 
 
void SAL_CALL TableDesignStyle::replaceByName( const OUString& rName, const Any& aElement )
{
    const CellStyleNameMap& rMap = getCellStyleNameMap();
    CellStyleNameMap::const_iterator iter = rMap.find( rName );
    if( iter == rMap.end() )
        throw NoSuchElementException();
 
 
    Reference< XStyle > xNewStyle;
    if( !(aElement >>= xNewStyle) )
        throw IllegalArgumentException();
 
    const sal_Int32 nIndex = (*iter).second;
 
    std::unique_lock aGuard( m_aMutex );
 
    Reference< XStyle > xOldStyle( maCellStyles[nIndex] );
 
    if( xNewStyle == xOldStyle )
        return;
 
    Reference< XModifyListener > xListener( this );
 
    // end listening to old style, if possible
    Reference< XModifyBroadcaster > xOldBroadcaster( xOldStyle, UNO_QUERY );
    if( xOldBroadcaster.is() )
        xOldBroadcaster->removeModifyListener( xListener );
 
    // start listening to new style, if possible
    Reference< XModifyBroadcaster > xNewBroadcaster( xNewStyle, UNO_QUERY );
    if( xNewBroadcaster.is() )
        xNewBroadcaster->addModifyListener( xListener );
 
    if (xNewStyle && xNewStyle->isUserDefined())
        mbModified = true;
 
    maCellStyles[nIndex] = std::move(xNewStyle);
}
 
 
// XComponent
 
 
void TableDesignStyle::disposing(std::unique_lock<std::mutex>& aGuard)
{
    maModifyListeners.disposeAndClear(aGuard, EventObject(Reference<XComponent>(this)));
 
    for(Reference<XStyle> & rCellStyle : maCellStyles)
    {
        Reference<XModifyBroadcaster> xBroadcaster(rCellStyle, UNO_QUERY);
        if (xBroadcaster)
            xBroadcaster->removeModifyListener(this);
        rCellStyle.clear();
    }
}
 
// XPropertySet
 
Reference<XPropertySetInfo> TableDesignStyle::getPropertySetInfo()
{
    return {};
}
 
void TableDesignStyle::setPropertyValue( const OUString&, const Any& )
{
}
 
Any TableDesignStyle::getPropertyValue( const OUString& PropertyName )
{
    if (PropertyName != "IsPhysical")
        throw UnknownPropertyException("unknown property: " + PropertyName, getXWeak());
 
    return Any(mbModified || mbUserDefined);
}
 
void TableDesignStyle::addPropertyChangeListener( const OUString&, const Reference<XPropertyChangeListener>& )
{
}
 
void TableDesignStyle::removePropertyChangeListener( const OUString&, const Reference<XPropertyChangeListener>& )
{
}
 
void TableDesignStyle::addVetoableChangeListener( const OUString&, const Reference<XVetoableChangeListener>& )
{
}
 
void TableDesignStyle::removeVetoableChangeListener( const OUString&,const Reference<XVetoableChangeListener>& )
{
}
 
// XModifiable
 
sal_Bool TableDesignStyle::isModified()
{
    return mbModified;
}
 
void TableDesignStyle::setModified( sal_Bool bModified )
{
    mbModified = bModified;
    notifyModifyListener();
}
 
 
// XModifyBroadcaster
 
 
void SAL_CALL TableDesignStyle::addModifyListener( const Reference< XModifyListener >& xListener )
{
    std::unique_lock aGuard( m_aMutex );
    if (m_bDisposed)
    {
        aGuard.unlock();
        EventObject aEvt( getXWeak() );
        xListener->disposing( aEvt );
    }
    else
    {
        maModifyListeners.addInterface( aGuard, xListener );
    }
}
 
 
void SAL_CALL TableDesignStyle::removeModifyListener( const Reference< XModifyListener >& xListener )
{
    std::unique_lock aGuard( m_aMutex );
    maModifyListeners.removeInterface( aGuard, xListener );
}
 
 
void TableDesignStyle::notifyModifyListener()
{
    std::unique_lock aGuard( m_aMutex );
 
    if( maModifyListeners.getLength(aGuard) )
    {
        EventObject aEvt( getXWeak() );
        maModifyListeners.forEach(aGuard,
            [&] (Reference<XModifyListener> const& xListener)
                { return xListener->modified(aEvt); });
    }
}
 
 
// XModifyListener
 
 
// if we get a modify hint from a style, notify all registered XModifyListener
void SAL_CALL TableDesignStyle::modified( const css::lang::EventObject& )
{
    notifyModifyListener();
}
 
 
void SAL_CALL TableDesignStyle::disposing( const css::lang::EventObject& )
{
}
 
 
// TableStyle
 
 
// XServiceInfo
OUString SAL_CALL TableDesignFamily::getImplementationName()
{
    return u"TableDesignFamily"_ustr;
}
 
sal_Bool SAL_CALL TableDesignFamily::supportsService( const OUString& ServiceName )
{
    return cppu::supportsService( this, ServiceName );
}
 
Sequence< OUString > SAL_CALL TableDesignFamily::getSupportedServiceNames()
{
    return { u"com.sun.star.style.StyleFamily"_ustr };
}
 
// XNamed
OUString SAL_CALL TableDesignFamily::getName()
{
    return u"table"_ustr;
}
 
void SAL_CALL TableDesignFamily::setName( const OUString& )
{
}
 
// XNameAccess
Any SAL_CALL TableDesignFamily::getByName( const OUString& rName )
{
    SolarMutexGuard aGuard;
 
    auto iter = std::find_if(maDesigns.begin(), maDesigns.end(),
        [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; });
    if (iter != maDesigns.end())
        return Any( (*iter) );
 
    throw NoSuchElementException();
}
 
 
Sequence< OUString > SAL_CALL TableDesignFamily::getElementNames()
{
    SolarMutexGuard aGuard;
 
    Sequence< OUString > aRet( maDesigns.size() );
    OUString* pNames = aRet.getArray();
 
    for( const auto& rpStyle : maDesigns )
        *pNames++ = rpStyle->getName();
 
    return aRet;
}
 
 
sal_Bool SAL_CALL TableDesignFamily::hasByName( const OUString& aName )
{
    SolarMutexGuard aGuard;
 
    return std::any_of(maDesigns.begin(), maDesigns.end(),
        [&aName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == aName; });
}
 
 
// XElementAccess
 
 
Type SAL_CALL TableDesignFamily::getElementType()
{
    return cppu::UnoType<XStyle>::get();
}
 
 
sal_Bool SAL_CALL TableDesignFamily::hasElements()
{
    SolarMutexGuard aGuard;
 
    return !maDesigns.empty();
}
 
 
// XIndexAccess
 
 
sal_Int32 SAL_CALL TableDesignFamily::getCount()
{
    SolarMutexGuard aGuard;
 
    return sal::static_int_cast< sal_Int32 >( maDesigns.size() );
}
 
 
Any SAL_CALL TableDesignFamily::getByIndex( sal_Int32 Index )
{
    SolarMutexGuard aGuard;
 
    if( (Index >= 0) && (Index < sal::static_int_cast< sal_Int32 >( maDesigns.size() ) ) )
        return Any( maDesigns[Index] );
 
    throw IndexOutOfBoundsException();
}
 
 
// XNameContainer
 
 
void SAL_CALL TableDesignFamily::insertByName( const OUString& rName, const Any& rElement )
{
    SolarMutexGuard aGuard;
 
    Reference< XStyle > xStyle( rElement, UNO_QUERY );
    if( !xStyle.is() )
        throw IllegalArgumentException();
 
    xStyle->setName( rName );
    if (std::any_of(maDesigns.begin(), maDesigns.end(),
            [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; }))
        throw ElementExistException();
 
    maDesigns.push_back( xStyle );
}
 
 
void SAL_CALL TableDesignFamily::removeByName( const OUString& rName )
{
    SolarMutexGuard aGuard;
 
    auto iter = std::find_if(maDesigns.begin(), maDesigns.end(),
        [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; });
    if (iter != maDesigns.end())
    {
        Reference<XComponent> xComponent(*iter, UNO_QUERY);
        if (xComponent)
            xComponent->dispose();
        maDesigns.erase( iter );
        return;
    }
 
    throw NoSuchElementException();
}
 
 
// XNameReplace
 
 
void SAL_CALL TableDesignFamily::replaceByName( const OUString& rName, const Any& aElement )
{
    SolarMutexGuard aGuard;
 
    Reference< XStyle > xStyle( aElement, UNO_QUERY );
    if( !xStyle.is() )
        throw IllegalArgumentException();
 
    auto iter = std::find_if(maDesigns.begin(), maDesigns.end(),
        [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; });
    if (iter != maDesigns.end())
    {
        if (!(*iter)->isUserDefined())
            static_cast<TableDesignStyle*>(xStyle.get())->resetUserDefined();
 
        Reference<XComponent> xComponent(*iter, UNO_QUERY);
        if (xComponent)
            xComponent->dispose();
        (*iter) = xStyle;
        xStyle->setName( rName );
        return;
    }
 
    throw NoSuchElementException();
}
 
 
// XSingleServiceFactory
 
 
Reference< XInterface > SAL_CALL TableDesignFamily::createInstance()
{
    return Reference< XInterface >( static_cast< XStyle* >( new TableDesignStyle ) );
}
 
 
Reference< XInterface > SAL_CALL TableDesignFamily::createInstanceWithArguments( const Sequence< Any >&  )
{
    return createInstance();
}
 
 
// XComponent
 
 
void SAL_CALL TableDesignFamily::dispose(  )
{
    TableDesignStyleVector aDesigns;
    aDesigns.swap( maDesigns );
 
    for( const auto& rStyle : aDesigns )
    {
        Reference< XComponent > xComp( rStyle, UNO_QUERY );
        if( xComp.is() )
            xComp->dispose();
    }
}
 
 
void SAL_CALL TableDesignFamily::addEventListener( const Reference< XEventListener >&  )
{
}
 
 
void SAL_CALL TableDesignFamily::removeEventListener( const Reference< XEventListener >&  )
{
}
 
 
// XPropertySet
 
 
Reference<XPropertySetInfo> TableDesignFamily::getPropertySetInfo()
{
    OSL_FAIL( "###unexpected!" );
    return Reference<XPropertySetInfo>();
}
 
 
void TableDesignFamily::setPropertyValue( const OUString& , const Any&  )
{
    OSL_FAIL( "###unexpected!" );
}
 
 
Any TableDesignFamily::getPropertyValue( const OUString& PropertyName )
{
    if ( PropertyName != "DisplayName" )
    {
        throw UnknownPropertyException( "unknown property: " + PropertyName, getXWeak() );
    }
 
    OUString sDisplayName( SvxResId( RID_SVXSTR_STYLEFAMILY_TABLEDESIGN ) );
    return Any( sDisplayName );
}
 
 
void TableDesignFamily::addPropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
{
    OSL_FAIL( "###unexpected!" );
}
 
 
void TableDesignFamily::removePropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
{
    OSL_FAIL( "###unexpected!" );
}
 
 
void TableDesignFamily::addVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>& )
{
    OSL_FAIL( "###unexpected!" );
}
 
 
void TableDesignFamily::removeVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>&  )
{
    OSL_FAIL( "###unexpected!" );
}
 
// XReset
 
void TableDesignFamily::reset()
{
    for (const auto& aDesign : maDesigns)
    {
        auto aStyle = static_cast<TableDesignStyle*>(aDesign.get());
        aStyle->resetUserDefined();
        aStyle->setModified(false);
    }
}
 
void TableDesignFamily::addResetListener( const Reference<form::XResetListener>& )
{
}
 
void TableDesignFamily::removeResetListener( const Reference<form::XResetListener>& )
{
}
 
Reference< XNameAccess > CreateTableDesignFamily()
{
    return new TableDesignFamily;
}
 
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V572 It is odd that the object which was created using 'new' operator is immediately cast to another type.