svx/source/table/tabledesign.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <com/sun/star/style/XStyle.hpp>
  22 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  23 #include <com/sun/star/lang/XServiceInfo.hpp>
  24 #include <com/sun/star/lang/XComponent.hpp>
  25 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  26 #include <com/sun/star/container/XIndexAccess.hpp>
  27 #include <com/sun/star/container/XNameContainer.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/util/XModifyBroadcaster.hpp>
  30 #include <com/sun/star/util/XModifyListener.hpp>
  31
  32 #include <osl/mutex.hxx>
  33 #include <vcl/svapp.hxx>
  34
  35 #include <cppuhelper/basemutex.hxx>
  36 #include <cppuhelper/compbase.hxx>
  37 #include <cppuhelper/implbase.hxx>
  38 #include <cppuhelper/interfacecontainer.h>
  39 #include <cppuhelper/supportsservice.hxx>
  40 #include <comphelper/sequence.hxx>
  41
  42 #include <svx/unoprov.hxx>
  43 #include <svx/sdr/table/tabledesign.hxx>
  44 #include <svx/dialmgr.hxx>
  45 #include <svx/strings.hrc>
  46
  47 #include <celltypes.hxx>
  48
  49 #include <vector>
  50 #include <map>
  51
  52
  53 using namespace ::com::sun::star::uno;
  54 using namespace ::com::sun::star::style;
  55 using namespace ::com::sun::star::lang;
  56 using namespace ::com::sun::star::beans;
  57 using namespace ::com::sun::star::util;
  58 using namespace ::com::sun::star::container;
  59
  60 using ::osl::MutexGuard;
  61 using ::osl::ClearableMutexGuard;
  62 using ::cppu::OInterfaceContainerHelper;
  63
  64 namespace sdr { namespace table {
  65
  66 typedef std::map< OUString, sal_Int32 > CellStyleNameMap;
  67
  68 typedef ::cppu::WeakComponentImplHelper< XStyle, XNameReplace, XServiceInfo, XIndexAccess, XModifyBroadcaster, XModifyListener > TableDesignStyleBase;
  69
  70 class TableDesignStyle : private ::cppu::BaseMutex, public TableDesignStyleBase
  71 {
  72 public:
  73     TableDesignStyle();
  74
  75     // XServiceInfo
  76     virtual OUString SAL_CALL getImplementationName() override;
  77     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
  78     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
  79
  80     // XStyle
  81     virtual sal_Bool SAL_CALL isUserDefined() override;
  82     virtual sal_Bool SAL_CALL isInUse() override;
  83     virtual OUString SAL_CALL getParentStyle() override;
  84     virtual void SAL_CALL setParentStyle( const OUString& aParentStyle ) override;
  85
  86     // XNamed
  87     virtual OUString SAL_CALL getName() override;
  88     virtual void SAL_CALL setName( const OUString& aName ) override;
  89
  90     // XNameAccess
  91     virtual Any SAL_CALL getByName( const OUString& aName ) override;
  92     virtual Sequence< OUString > SAL_CALL getElementNames() override;
  93     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
  94
  95     // XElementAccess
  96     virtual css::uno::Type SAL_CALL getElementType() override;
  97     virtual sal_Bool SAL_CALL hasElements() override;
  98
  99     // XIndexAccess
 100     virtual sal_Int32 SAL_CALL getCount() override ;
 101     virtual Any SAL_CALL getByIndex( sal_Int32 Index ) override;
 102
 103     // XNameReplace
 104     virtual void SAL_CALL replaceByName( const OUString& aName, const Any& aElement ) override;
 105
 106     // XModifyBroadcaster
 107     virtual void SAL_CALL addModifyListener( const Reference< XModifyListener >& aListener ) override;
 108     virtual void SAL_CALL removeModifyListener( const Reference< XModifyListener >& aListener ) override;
 109
 110     // XModifyListener
 111     virtual void SAL_CALL modified( const css::lang::EventObject& aEvent ) override;
 112     virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
 113
 114     void notifyModifyListener();
 115
 116     // this function is called upon disposing the component
 117     virtual void SAL_CALL disposing() override;
 118
 119     static const CellStyleNameMap& getCellStyleNameMap();
 120
 121     OUString msName;
 122     Reference< XStyle > maCellStyles[style_count];
 123 };
 124
 125 typedef std::vector< Reference< XStyle > > TableDesignStyleVector;
 126
 127 class TableDesignFamily : public ::cppu::WeakImplHelper< XNameContainer, XNamed, XIndexAccess, XSingleServiceFactory,  XServiceInfo, XComponent, XPropertySet >
 128 {
 129 public:
 130     // XServiceInfo
 131     virtual OUString SAL_CALL getImplementationName() override;
 132     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
 133     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 134
 135     // XNamed
 136     virtual OUString SAL_CALL getName(  ) override;
 137     virtual void SAL_CALL setName( const OUString& aName ) override;
 138
 139     // XNameAccess
 140     virtual Any SAL_CALL getByName( const OUString& aName ) override;
 141     virtual Sequence< OUString > SAL_CALL getElementNames() override;
 142     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
 143
 144     // XElementAccess
 145     virtual Type SAL_CALL getElementType() override;
 146     virtual sal_Bool SAL_CALL hasElements() override;
 147
 148     // XIndexAccess
 149     virtual sal_Int32 SAL_CALL getCount() override ;
 150     virtual Any SAL_CALL getByIndex( sal_Int32 Index ) override;
 151
 152     // XNameContainer
 153     virtual void SAL_CALL insertByName( const OUString& aName, const Any& aElement ) override;
 154     virtual void SAL_CALL removeByName( const OUString& Name ) override;
 155
 156     // XNameReplace
 157     virtual void SAL_CALL replaceByName( const OUString& aName, const Any& aElement ) override;
 158
 159     // XSingleServiceFactory
 160     virtual Reference< XInterface > SAL_CALL createInstance(  ) override;
 161     virtual Reference< XInterface > SAL_CALL createInstanceWithArguments( const Sequence< Any >& aArguments ) override;
 162
 163     // XComponent
 164     virtual void SAL_CALL dispose(  ) override;
 165     virtual void SAL_CALL addEventListener( const Reference< XEventListener >& xListener ) override;
 166     virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& aListener ) override;
 167
 168     // XPropertySet
 169     virtual Reference<XPropertySetInfo> SAL_CALL getPropertySetInfo() override;
 170     virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const Any& aValue ) override;
 171     virtual Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override;
 172     virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName, const Reference<XPropertyChangeListener>& xListener ) override;
 173     virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName, const Reference<XPropertyChangeListener>& aListener ) override;
 174     virtual void SAL_CALL addVetoableChangeListener(const OUString& PropertyName, const Reference<XVetoableChangeListener>& aListener ) override;
 175     virtual void SAL_CALL removeVetoableChangeListener(const OUString& PropertyName,const Reference<XVetoableChangeListener>&aListener ) override;
 176
 177     TableDesignStyleVector  maDesigns;
 178 };
 179
 180 TableDesignStyle::TableDesignStyle()
 181 : TableDesignStyleBase(m_aMutex)
 182 {
 183 }
 184
 185 const CellStyleNameMap& TableDesignStyle::getCellStyleNameMap()
 186 {
 187     static CellStyleNameMap const aMap
 188     {
 189          { OUString( "first-row" )    , first_row_style },
 190          { OUString( "last-row" )     , last_row_style },
 191          { OUString( "first-column" ) , first_column_style },
 192          { OUString( "last-column" )  , last_column_style },
 193          { OUString( "body" )         , body_style },
 194          { OUString( "even-rows" )    , even_rows_style },
 195          { OUString( "odd-rows" )     , odd_rows_style },
 196          { OUString( "even-columns" ) , even_columns_style },
 197          { OUString( "odd-columns" )  , odd_columns_style },
 198          { OUString( "background" )   , background_style },
 199     };
 200
 201     return aMap;
 202 }
 203
 204 // XServiceInfo
 205 OUString SAL_CALL TableDesignStyle::getImplementationName()
 206 {
 207     return "TableDesignStyle";
 208 }
 209
 210 sal_Bool SAL_CALL TableDesignStyle::supportsService( const OUString& ServiceName )
 211 {
 212     return cppu::supportsService( this, ServiceName );
 213 }
 214
 215 Sequence< OUString > SAL_CALL TableDesignStyle::getSupportedServiceNames()
 216 {
 217     return { "com.sun.star.style.Style" };
 218 }
 219
 220 // XStyle
 221 sal_Bool SAL_CALL TableDesignStyle::isUserDefined()
 222 {
 223     return false;
 224 }
 225
 226 sal_Bool SAL_CALL TableDesignStyle::isInUse()
 227 {
 228     ClearableMutexGuard aGuard( rBHelper.rMutex );
 229     OInterfaceContainerHelper * pContainer = rBHelper.getContainer( cppu::UnoType<XModifyListener>::get() );
 230     if( pContainer )
 231     {
 232         Sequence< Reference< XInterface > > aListener( pContainer->getElements() );
 233         aGuard.clear();
 234
 235         sal_Int32 nIndex = aListener.getLength();
 236         while( --nIndex >= 0 )
 237         {
 238             TableDesignUser* pUser = dynamic_cast< TableDesignUser* >( aListener[nIndex].get() );
 239             if( pUser && pUser->isInUse() )
 240                 return true;
 241         }
 242     }
 243     return false;
 244 }
 245
 246
 247 OUString SAL_CALL TableDesignStyle::getParentStyle()
 248 {
 249     return OUString();
 250 }
 251
 252
 253 void SAL_CALL TableDesignStyle::setParentStyle( const OUString& )
 254 {
 255 }
 256
 257
 258 // XNamed
 259
 260
 261 OUString SAL_CALL TableDesignStyle::getName()
 262 {
 263     return msName;
 264 }
 265
 266
 267 void SAL_CALL TableDesignStyle::setName( const OUString& rName )
 268 {
 269     msName = rName;
 270 }
 271
 272
 273 // XNameAccess
 274
 275
 276 Any SAL_CALL TableDesignStyle::getByName( const OUString& rName )
 277 {
 278     SolarMutexGuard aGuard;
 279
 280     const CellStyleNameMap& rMap = getCellStyleNameMap();
 281
 282     CellStyleNameMap::const_iterator iter = rMap.find( rName );
 283     if( iter == rMap.end() )
 284         throw NoSuchElementException();
 285
 286     return Any( maCellStyles[(*iter).second] );
 287 }
 288
 289
 290 Sequence< OUString > SAL_CALL TableDesignStyle::getElementNames()
 291 {
 292     SolarMutexGuard aGuard;
 293
 294     return comphelper::mapKeysToSequence( getCellStyleNameMap() );
 295 }
 296
 297
 298 sal_Bool SAL_CALL TableDesignStyle::hasByName( const OUString& rName )
 299 {
 300     SolarMutexGuard aGuard;
 301
 302     const CellStyleNameMap& rMap = getCellStyleNameMap();
 303
 304     CellStyleNameMap::const_iterator iter = rMap.find( rName );
 305     return iter != rMap.end();
 306 }
 307
 308
 309 // XElementAccess
 310
 311
 312 Type SAL_CALL TableDesignStyle::getElementType()
 313 {
 314     return cppu::UnoType<XStyle>::get();
 315 }
 316
 317
 318 sal_Bool SAL_CALL TableDesignStyle::hasElements()
 319 {
 320     return true;
 321 }
 322
 323
 324 // XIndexAccess
 325
 326
 327 sal_Int32 SAL_CALL TableDesignStyle::getCount()
 328 {
 329     return style_count;
 330 }
 331
 332
 333 Any SAL_CALL TableDesignStyle::getByIndex( sal_Int32 Index )
 334 {
 335     SolarMutexGuard aGuard;
 336
 337     if( (Index < 0) || (Index >= style_count) )
 338         throw IndexOutOfBoundsException();
 339
 340     return Any( maCellStyles[Index] );
 341 }
 342
 343
 344 // XNameReplace
 345
 346
 347 void SAL_CALL TableDesignStyle::replaceByName( const OUString& rName, const Any& aElement )
 348 {
 349     SolarMutexGuard aGuard;
 350
 351     const CellStyleNameMap& rMap = getCellStyleNameMap();
 352     CellStyleNameMap::const_iterator iter = rMap.find( rName );
 353     if( iter == rMap.end() )
 354         throw NoSuchElementException();
 355
 356
 357     Reference< XStyle > xNewStyle;
 358     if( !(aElement >>= xNewStyle) )
 359         throw IllegalArgumentException();
 360
 361     const sal_Int32 nIndex = (*iter).second;
 362
 363     Reference< XStyle > xOldStyle( maCellStyles[nIndex] );
 364
 365     if( xNewStyle != xOldStyle )
 366     {
 367         Reference< XModifyListener > xListener( this );
 368
 369         // end listening to old style, if possible
 370         Reference< XModifyBroadcaster > xOldBroadcaster( xOldStyle, UNO_QUERY );
 371         if( xOldBroadcaster.is() )
 372             xOldBroadcaster->removeModifyListener( xListener );
 373
 374         // start listening to new style, if possible
 375         Reference< XModifyBroadcaster > xNewBroadcaster( xNewStyle, UNO_QUERY );
 376         if( xNewBroadcaster.is() )
 377             xNewBroadcaster->addModifyListener( xListener );
 378
 379         maCellStyles[nIndex] = xNewStyle;
 380     }
 381 }
 382
 383
 384 // XComponent
 385
 386
 387 void SAL_CALL TableDesignStyle::disposing()
 388 {
 389     for(Reference<XStyle> & rCellStyle : maCellStyles)
 390         rCellStyle.clear();
 391 }
 392
 393
 394 // XModifyBroadcaster
 395
 396
 397 void SAL_CALL TableDesignStyle::addModifyListener( const Reference< XModifyListener >& xListener )
 398 {
 399     ClearableMutexGuard aGuard( rBHelper.rMutex );
 400     if (rBHelper.bDisposed || rBHelper.bInDispose)
 401     {
 402         aGuard.clear();
 403         EventObject aEvt( static_cast< OWeakObject * >( this ) );
 404         xListener->disposing( aEvt );
 405     }
 406     else
 407     {
 408         rBHelper.addListener( cppu::UnoType<XModifyListener>::get(), xListener );
 409     }
 410 }
 411
 412
 413 void SAL_CALL TableDesignStyle::removeModifyListener( const Reference< XModifyListener >& xListener )
 414 {
 415     rBHelper.removeListener( cppu::UnoType<XModifyListener>::get(), xListener );
 416 }
 417
 418
 419 void TableDesignStyle::notifyModifyListener()
 420 {
 421     MutexGuard aGuard( rBHelper.rMutex );
 422
 423     OInterfaceContainerHelper * pContainer = rBHelper.getContainer( cppu::UnoType<XModifyListener>::get() );
 424     if( pContainer )
 425     {
 426         EventObject aEvt( static_cast< OWeakObject * >( this ) );
 427         pContainer->forEach<XModifyListener>(
 428             [&] (Reference<XModifyListener> const& xListener)
 429                 { return xListener->modified(aEvt); });
 430     }
 431 }
 432
 433
 434 // XModifyListener
 435
 436
 437 // if we get a modify hint from a style, notify all registered XModifyListener
 438 void SAL_CALL TableDesignStyle::modified( const css::lang::EventObject& )
 439 {
 440     notifyModifyListener();
 441 }
 442
 443
 444 void SAL_CALL TableDesignStyle::disposing( const css::lang::EventObject& )
 445 {
 446 }
 447
 448
 449 // TableStyle
 450
 451
 452 // XServiceInfo
 453 OUString SAL_CALL TableDesignFamily::getImplementationName()
 454 {
 455     return "TableDesignFamily";
 456 }
 457
 458 sal_Bool SAL_CALL TableDesignFamily::supportsService( const OUString& ServiceName )
 459 {
 460     return cppu::supportsService( this, ServiceName );
 461 }
 462
 463 Sequence< OUString > SAL_CALL TableDesignFamily::getSupportedServiceNames()
 464 {
 465     return { "com.sun.star.style.StyleFamily" };
 466 }
 467
 468 // XNamed
 469 OUString SAL_CALL TableDesignFamily::getName()
 470 {
 471     return "table";
 472 }
 473
 474 void SAL_CALL TableDesignFamily::setName( const OUString& )
 475 {
 476 }
 477
 478 // XNameAccess
 479 Any SAL_CALL TableDesignFamily::getByName( const OUString& rName )
 480 {
 481     SolarMutexGuard aGuard;
 482
 483     auto iter = std::find_if(maDesigns.begin(), maDesigns.end(),
 484         [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; });
 485     if (iter != maDesigns.end())
 486         return Any( (*iter) );
 487
 488     throw NoSuchElementException();
 489 }
 490
 491
 492 Sequence< OUString > SAL_CALL TableDesignFamily::getElementNames()
 493 {
 494     SolarMutexGuard aGuard;
 495
 496     Sequence< OUString > aRet( maDesigns.size() );
 497     OUString* pNames = aRet.getArray();
 498
 499     for( const auto& rpStyle : maDesigns )
 500         *pNames++ = rpStyle->getName();
 501
 502     return aRet;
 503 }
 504
 505
 506 sal_Bool SAL_CALL TableDesignFamily::hasByName( const OUString& aName )
 507 {
 508     SolarMutexGuard aGuard;
 509
 510     return std::any_of(maDesigns.begin(), maDesigns.end(),
 511         [&aName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == aName; });
 512 }
 513
 514
 515 // XElementAccess
 516
 517
 518 Type SAL_CALL TableDesignFamily::getElementType()
 519 {
 520     return cppu::UnoType<XStyle>::get();
 521 }
 522
 523
 524 sal_Bool SAL_CALL TableDesignFamily::hasElements()
 525 {
 526     SolarMutexGuard aGuard;
 527
 528     return !maDesigns.empty();
 529 }
 530
 531
 532 // XIndexAccess
 533
 534
 535 sal_Int32 SAL_CALL TableDesignFamily::getCount()
 536 {
 537     SolarMutexGuard aGuard;
 538
 539     return sal::static_int_cast< sal_Int32 >( maDesigns.size() );
 540 }
 541
 542
 543 Any SAL_CALL TableDesignFamily::getByIndex( sal_Int32 Index )
 544 {
 545     SolarMutexGuard aGuard;
 546
 547     if( (Index >= 0) && (Index < sal::static_int_cast< sal_Int32 >( maDesigns.size() ) ) )
 548         return Any( maDesigns[Index] );
 549
 550     throw IndexOutOfBoundsException();
 551 }
 552
 553
 554 // XNameContainer
 555
 556
 557 void SAL_CALL TableDesignFamily::insertByName( const OUString& rName, const Any& rElement )
 558 {
 559     SolarMutexGuard aGuard;
 560
 561     Reference< XStyle > xStyle( rElement, UNO_QUERY );
 562     if( !xStyle.is() )
 563         throw IllegalArgumentException();
 564
 565     xStyle->setName( rName );
 566     if (std::any_of(maDesigns.begin(), maDesigns.end(),
 567             [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; }))
 568         throw ElementExistException();
 569
 570     maDesigns.push_back( xStyle );
 571 }
 572
 573
 574 void SAL_CALL TableDesignFamily::removeByName( const OUString& rName )
 575 {
 576     SolarMutexGuard aGuard;
 577
 578     auto iter = std::find_if(maDesigns.begin(), maDesigns.end(),
 579         [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; });
 580     if (iter != maDesigns.end())
 581     {
 582         maDesigns.erase( iter );
 583         return;
 584     }
 585
 586     throw NoSuchElementException();
 587 }
 588
 589
 590 // XNameReplace
 591
 592
 593 void SAL_CALL TableDesignFamily::replaceByName( const OUString& rName, const Any& aElement )
 594 {
 595     SolarMutexGuard aGuard;
 596
 597     Reference< XStyle > xStyle( aElement, UNO_QUERY );
 598     if( !xStyle.is() )
 599         throw IllegalArgumentException();
 600
 601     auto iter = std::find_if(maDesigns.begin(), maDesigns.end(),
 602         [&rName](const Reference<XStyle>& rpStyle) { return rpStyle->getName() == rName; });
 603     if (iter != maDesigns.end())
 604     {
 605         (*iter) = xStyle;
 606         xStyle->setName( rName );
 607         return;
 608     }
 609
 610     throw NoSuchElementException();
 611 }
 612
 613
 614 // XSingleServiceFactory
 615
 616
 617 Reference< XInterface > SAL_CALL TableDesignFamily::createInstance()
 618 {
 619     SolarMutexGuard aGuard;
 620
 621     return Reference< XInterface >( static_cast< XStyle* >( new TableDesignStyle ) );
 622 }
 623
 624
 625 Reference< XInterface > SAL_CALL TableDesignFamily::createInstanceWithArguments( const Sequence< Any >&  )
 626 {
 627     return createInstance();
 628 }
 629
 630
 631 // XComponent
 632
 633
 634 void SAL_CALL TableDesignFamily::dispose(  )
 635 {
 636     TableDesignStyleVector aDesigns;
 637     aDesigns.swap( maDesigns );
 638
 639     for( const auto& rStyle : aDesigns )
 640     {
 641         Reference< XComponent > xComp( rStyle, UNO_QUERY );
 642         if( xComp.is() )
 643             xComp->dispose();
 644     }
 645 }
 646
 647
 648 void SAL_CALL TableDesignFamily::addEventListener( const Reference< XEventListener >&  )
 649 {
 650 }
 651
 652
 653 void SAL_CALL TableDesignFamily::removeEventListener( const Reference< XEventListener >&  )
 654 {
 655 }
 656
 657
 658 // XPropertySet
 659
 660
 661 Reference<XPropertySetInfo> TableDesignFamily::getPropertySetInfo()
 662 {
 663     OSL_FAIL( "###unexpected!" );
 664     return Reference<XPropertySetInfo>();
 665 }
 666
 667
 668 void TableDesignFamily::setPropertyValue( const OUString& , const Any&  )
 669 {
 670     OSL_FAIL( "###unexpected!" );
 671 }
 672
 673
 674 Any TableDesignFamily::getPropertyValue( const OUString& PropertyName )
 675 {
 676     if ( PropertyName != "DisplayName" )
 677     {
 678         throw UnknownPropertyException( "unknown property: " + PropertyName, static_cast<OWeakObject *>(this) );
 679     }
 680
 681     OUString sDisplayName( SvxResId( RID_SVXSTR_STYLEFAMILY_TABLEDESIGN ) );
 682     return Any( sDisplayName );
 683 }
 684
 685
 686 void TableDesignFamily::addPropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
 687 {
 688     OSL_FAIL( "###unexpected!" );
 689 }
 690
 691
 692 void TableDesignFamily::removePropertyChangeListener( const OUString& , const Reference<XPropertyChangeListener>&  )
 693 {
 694     OSL_FAIL( "###unexpected!" );
 695 }
 696
 697
 698 void TableDesignFamily::addVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>& )
 699 {
 700     OSL_FAIL( "###unexpected!" );
 701 }
 702
 703
 704 void TableDesignFamily::removeVetoableChangeListener( const OUString& , const Reference<XVetoableChangeListener>&  )
 705 {
 706     OSL_FAIL( "###unexpected!" );
 707 }
 708
 709
 710 Reference< XNameAccess > CreateTableDesignFamily()
 711 {
 712     return new TableDesignFamily;
 713 }
 714
 715 } }
 716
 717 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */