extensions/source/bibliography/bibload.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 #include <tools/debug.hxx>
  21 #include <tools/diagnose_ex.h>
  22 #include <cppuhelper/weak.hxx>
  23 #include <cppuhelper/supportsservice.hxx>
  24 #include <svl/itemprop.hxx>
  25 #include <uno/environment.h>
  26 #include <svl/urihelper.hxx>
  27 #include <toolkit/helper/vclunohelper.hxx>
  28 #include <comphelper/processfactory.hxx>
  29 #include <cppuhelper/factory.hxx>
  30 #include <com/sun/star/sdbc/ResultSetType.hpp>
  31 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  32 #include <com/sun/star/sdbc/SQLException.hpp>
  33 #include <com/sun/star/sdb/XColumn.hpp>
  34 #include <com/sun/star/util/XURLTransformer.hpp>
  35 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  36 #include <com/sun/star/sdbc/XRowSet.hpp>
  37 #include <com/sun/star/sdb/CommandType.hpp>
  38 #include <com/sun/star/frame/XFrameLoader.hpp>
  39 #include <com/sun/star/lang/XServiceInfo.hpp>
  40 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  41 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  42 #include <com/sun/star/beans/PropertyAttribute.hpp>
  43 #include <com/sun/star/beans/XPropertySet.hpp>
  44 #include <com/sun/star/container/XNameAccess.hpp>
  45 #include <com/sun/star/text/BibliographyDataField.hpp>
  46 #include <com/sun/star/form/XLoadListener.hpp>
  47 #include <com/sun/star/frame/XLayoutManager.hpp>
  48 #include <com/sun/star/uno/XAggregation.hpp>
  49 #include <toolkit/awt/vclxwindow.hxx>
  50 #include <vcl/window.hxx>
  51 #include <vcl/edit.hxx>
  52 #include <vcl/svapp.hxx>
  53
  54 #include "bibresid.hxx"
  55 #include <strings.hrc>
  56 #include "bibcont.hxx"
  57 #include "bibbeam.hxx"
  58 #include "bibmod.hxx"
  59 #include "bibview.hxx"
  60 #include "framectr.hxx"
  61 #include "datman.hxx"
  62 #include "bibconfig.hxx"
  63 #include <cppuhelper/implbase.hxx>
  64 #include <rtl/ref.hxx>
  65
  66 using namespace ::com::sun::star;
  67 using namespace ::com::sun::star::uno;
  68 using namespace ::com::sun::star::beans;
  69 using namespace ::com::sun::star::lang;
  70 using namespace ::com::sun::star::sdb;
  71 using namespace ::com::sun::star::sdbc;
  72 using namespace ::com::sun::star::form;
  73 using namespace ::com::sun::star::container;
  74 using namespace ::com::sun::star::frame;
  75
  76 static Reference< XInterface > BibliographyLoader_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr );
  77
  78 class BibliographyLoader : public cppu::WeakImplHelper
  79                             < XServiceInfo, XNameAccess, XPropertySet, XFrameLoader >
  80 {
  81     HdlBibModul                                     m_pBibMod;
  82     rtl::Reference<BibDataManager>                  m_xDatMan;
  83     Reference< XNameAccess >                        m_xColumns;
  84     Reference< XResultSet >                         m_xCursor;
  85
  86 private:
  87
  88     void                    loadView(const Reference< XFrame > & aFrame,
  89                                 const Reference< XLoadEventListener > & aListener);
  90
  91     BibDataManager*         GetDataManager()const;
  92     Reference< XNameAccess > const &    GetDataColumns() const;
  93     Reference< XResultSet > const &     GetDataCursor() const;
  94     Reference< sdb::XColumn >           GetIdentifierColumn() const;
  95
  96 public:
  97                             BibliographyLoader();
  98                             virtual ~BibliographyLoader() override;
  99
 100     // XServiceInfo
 101     OUString               SAL_CALL getImplementationName() override;
 102     sal_Bool                    SAL_CALL supportsService(const OUString& ServiceName) override;
 103     Sequence< OUString >   SAL_CALL getSupportedServiceNames() override;
 104     static OUString                getImplementationName_Static() throw(  )
 105
 106                             {
 107                                 //!
 108                                 return OUString("com.sun.star.extensions.Bibliography");
 109                                 //!
 110                             }
 111
 112     //XNameAccess
 113     virtual Any SAL_CALL getByName(const OUString& aName) override;
 114     virtual Sequence< OUString > SAL_CALL getElementNames() override;
 115     virtual sal_Bool SAL_CALL hasByName(const OUString& aName) override;
 116
 117     //XElementAccess
 118     virtual Type  SAL_CALL getElementType() override;
 119     virtual sal_Bool SAL_CALL hasElements() override;
 120
 121     //XPropertySet
 122     virtual Reference< XPropertySetInfo >  SAL_CALL getPropertySetInfo() override;
 123     virtual void SAL_CALL setPropertyValue(const OUString& PropertyName, const Any& aValue) override;
 124     virtual Any SAL_CALL getPropertyValue(const OUString& PropertyName) override;
 125     virtual void SAL_CALL addPropertyChangeListener(const OUString& PropertyName, const Reference< XPropertyChangeListener > & aListener) override;
 126     virtual void SAL_CALL removePropertyChangeListener(const OUString& PropertyName, const Reference< XPropertyChangeListener > & aListener) override;
 127     virtual void SAL_CALL addVetoableChangeListener(const OUString& PropertyName, const Reference< XVetoableChangeListener > & aListener) override;
 128     virtual void SAL_CALL removeVetoableChangeListener(const OUString& PropertyName, const Reference< XVetoableChangeListener > & aListener) override;
 129
 130     static Sequence<OUString> getSupportedServiceNames_Static() throw(  );
 131
 132     /// @throws Exception
 133     friend  Reference< XInterface > BibliographyLoader_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr );
 134
 135     // XLoader
 136     virtual void            SAL_CALL load(const Reference< XFrame > & aFrame, const OUString& aURL,
 137                                 const Sequence< PropertyValue >& aArgs,
 138                                 const Reference< XLoadEventListener > & aListener) override;
 139     virtual void            SAL_CALL cancel() override;
 140 };
 141
 142 BibliographyLoader::BibliographyLoader() :
 143     m_pBibMod(nullptr)
 144 {
 145 }
 146
 147 BibliographyLoader::~BibliographyLoader()
 148 {
 149     Reference< lang::XComponent >  xComp(m_xCursor, UNO_QUERY);
 150     if (xComp.is())
 151         xComp->dispose();
 152     if(m_pBibMod)
 153         CloseBibModul(m_pBibMod);
 154 }
 155
 156
 157 Reference< XInterface > BibliographyLoader_CreateInstance( const Reference< XMultiServiceFactory >  & /*rSMgr*/ )
 158 {
 159     return *(new BibliographyLoader);
 160 }
 161
 162
 163 // XServiceInfo
 164 OUString BibliographyLoader::getImplementationName()
 165
 166 {
 167     return getImplementationName_Static();
 168 }
 169
 170 // XServiceInfo
 171 sal_Bool BibliographyLoader::supportsService(const OUString& ServiceName)
 172 {
 173     return cppu::supportsService(this, ServiceName);
 174 }
 175
 176 // XServiceInfo
 177 Sequence< OUString > BibliographyLoader::getSupportedServiceNames()
 178 {
 179     return getSupportedServiceNames_Static();
 180 }
 181
 182 // ORegistryServiceManager_Static
 183 Sequence< OUString > BibliographyLoader::getSupportedServiceNames_Static() throw(  )
 184 {
 185     Sequence< OUString > aSNS( 2 );
 186     aSNS.getArray()[0] = "com.sun.star.frame.FrameLoader";
 187     //!
 188     aSNS.getArray()[1] = "com.sun.star.frame.Bibliography";
 189     //!
 190     return aSNS;
 191 }
 192
 193 extern "C"
 194 {
 195     SAL_DLLPUBLIC_EXPORT void * bib_component_getFactory(
 196         const sal_Char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
 197     {
 198         void * pRet = nullptr;
 199         if (BibliographyLoader::getImplementationName_Static().equalsAscii( pImplName ) )
 200         {
 201             // create the factory
 202             Reference< XSingleServiceFactory > xFactory =
 203                 cppu::createSingleFactory(
 204                     static_cast<css::lang::XMultiServiceFactory *>(pServiceManager),
 205                     BibliographyLoader::getImplementationName_Static(),
 206                     BibliographyLoader_CreateInstance,
 207                     BibliographyLoader::getSupportedServiceNames_Static() );
 208             // acquire, because we return an interface pointer instead of a reference
 209             xFactory->acquire();
 210             pRet = xFactory.get();
 211         }
 212         return pRet;
 213     }
 214
 215 }
 216
 217 void BibliographyLoader::cancel()
 218 {
 219     //!
 220     //!
 221 }
 222
 223 void BibliographyLoader::load(const Reference< XFrame > & rFrame, const OUString& rURL,
 224         const Sequence< PropertyValue >& /*rArgs*/,
 225         const Reference< XLoadEventListener > & rListener)
 226 {
 227
 228     SolarMutexGuard aGuard;
 229
 230     m_pBibMod = OpenBibModul();
 231
 232     OUString aPartName = rURL.getToken( 1, '/' );
 233     Reference<XPropertySet> xPrSet(rFrame, UNO_QUERY);
 234     if(xPrSet.is())
 235     {
 236         Any aTitle;
 237         aTitle <<= BibResId(RID_BIB_STR_FRAME_TITLE);
 238         xPrSet->setPropertyValue("Title", aTitle);
 239     }
 240     if(aPartName == "View" || aPartName == "View1")
 241     {
 242         loadView(rFrame, rListener);
 243     }
 244 }
 245
 246
 247 void BibliographyLoader::loadView(const Reference< XFrame > & rFrame,
 248         const Reference< XLoadEventListener > & rListener)
 249 {
 250     SolarMutexGuard aGuard;
 251     //!
 252     if(!m_pBibMod)
 253         m_pBibMod = OpenBibModul();
 254
 255     m_xDatMan = BibModul::createDataManager();
 256     BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL();
 257
 258     if(aBibDesc.sDataSource.isEmpty())
 259     {
 260         DBChangeDialogConfig_Impl aConfig;
 261         const Sequence<OUString> aSources = aConfig.GetDataSourceNames();
 262         if(aSources.hasElements())
 263             aBibDesc.sDataSource = aSources.getConstArray()[0];
 264     }
 265
 266     Reference< XForm > xForm = m_xDatMan->createDatabaseForm( aBibDesc );
 267
 268     Reference< awt::XWindow >  aWindow = rFrame->getContainerWindow();
 269     VCLXWindow* pParentComponent = VCLXWindow::GetImplementation(aWindow);
 270     assert(pParentComponent);
 271
 272     VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow( aWindow );
 273
 274     VclPtrInstance<BibBookContainer> pMyWindow( pParent );
 275     pMyWindow->Show();
 276
 277     VclPtrInstance< ::bib::BibView> pView( pMyWindow, m_xDatMan.get(), WB_VSCROLL | WB_HSCROLL | WB_3DLOOK );
 278     pView->Show();
 279     m_xDatMan->SetView( pView );
 280
 281     VclPtrInstance< ::bib::BibBeamer> pBeamer( pMyWindow, m_xDatMan.get() );
 282     pBeamer->Show();
 283     pMyWindow->createTopFrame(pBeamer);
 284
 285     pMyWindow->createBottomFrame(pView);
 286
 287     Reference< awt::XWindow >  xWin ( pMyWindow->GetComponentInterface(), UNO_QUERY );
 288
 289     Reference< XController >  xCtrRef( new BibFrameController_Impl( xWin, m_xDatMan.get() ) );
 290
 291     xCtrRef->attachFrame(rFrame);
 292     rFrame->setComponent( xWin, xCtrRef);
 293     pBeamer->SetXController(xCtrRef);
 294
 295     if (pParentComponent)
 296     {
 297         // not earlier because SetFocus() is triggered in setVisible()
 298         pParentComponent->setVisible(true);
 299     }
 300
 301     Reference<XLoadable>(m_xDatMan.get())->load();
 302     m_xDatMan->RegisterInterceptor(pBeamer);
 303
 304     if ( rListener.is() )
 305         rListener->loadFinished( this );
 306
 307     // attach menu bar
 308     Reference< XPropertySet > xPropSet( rFrame, UNO_QUERY );
 309     Reference< css::frame::XLayoutManager > xLayoutManager;
 310     if ( xPropSet.is() )
 311     {
 312         try
 313         {
 314             Any a = xPropSet->getPropertyValue("LayoutManager");
 315             a >>= xLayoutManager;
 316         }
 317         catch ( const uno::Exception& )
 318         {
 319         }
 320     }
 321
 322     if ( xLayoutManager.is() )
 323         xLayoutManager->createElement( "private:resource/menubar/menubar" );
 324 }
 325
 326 BibDataManager* BibliographyLoader::GetDataManager()const
 327 {
 328     if(!m_xDatMan.is())
 329     {
 330         if(!m_pBibMod)
 331             const_cast< BibliographyLoader* >( this )->m_pBibMod = OpenBibModul();
 332         const_cast< BibliographyLoader* >( this )->m_xDatMan = BibModul::createDataManager();
 333     }
 334     return m_xDatMan.get();
 335 }
 336
 337 Reference< XNameAccess > const & BibliographyLoader::GetDataColumns() const
 338 {
 339     if (!m_xColumns.is())
 340     {
 341         Reference< XMultiServiceFactory >  xMgr = comphelper::getProcessServiceFactory();
 342         Reference< XRowSet >  xRowSet(xMgr->createInstance("com.sun.star.sdb.RowSet"), UNO_QUERY);
 343         Reference< XPropertySet >  xResultSetProps(xRowSet, UNO_QUERY);
 344         DBG_ASSERT(xResultSetProps.is() , "BibliographyLoader::GetDataCursor : invalid row set (no XResultSet or no XPropertySet) !");
 345
 346         BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL();
 347
 348         Any aBibUrlAny; aBibUrlAny <<= aBibDesc.sDataSource;
 349         xResultSetProps->setPropertyValue("DataSourceName", aBibUrlAny);
 350         Any aCommandType; aCommandType <<= aBibDesc.nCommandType;
 351         xResultSetProps->setPropertyValue("CommandType", aCommandType);
 352         Any aTableName; aTableName <<= aBibDesc.sTableOrQuery;
 353         xResultSetProps->setPropertyValue("Command", aTableName);
 354         Any aResultSetType; aResultSetType <<= sal_Int32(ResultSetType::SCROLL_INSENSITIVE);
 355         xResultSetProps->setPropertyValue("ResultSetType", aResultSetType);
 356         Any aResultSetCurrency; aResultSetCurrency <<= sal_Int32(ResultSetConcurrency::UPDATABLE);
 357         xResultSetProps->setPropertyValue("ResultSetConcurrency", aResultSetCurrency);
 358
 359         bool bSuccess = false;
 360         try
 361         {
 362             xRowSet->execute();
 363             bSuccess = true;
 364         }
 365         catch(const SQLException&)
 366         {
 367             DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 368         }
 369         catch(const Exception& )
 370         {
 371             DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 372             bSuccess = false;
 373         }
 374
 375         if (!bSuccess)
 376         {
 377             Reference< XComponent >  xSetComp(xRowSet, UNO_QUERY);
 378             if (xSetComp.is())
 379                 xSetComp->dispose();
 380             xRowSet = nullptr;
 381         }
 382         else
 383             const_cast<BibliographyLoader*>(this)->m_xCursor = xRowSet.get();
 384
 385         Reference< sdbcx::XColumnsSupplier >  xSupplyCols(m_xCursor, UNO_QUERY);
 386         if (xSupplyCols.is())
 387             const_cast<BibliographyLoader*>(this)->m_xColumns = xSupplyCols->getColumns();
 388     }
 389
 390     return m_xColumns;
 391 }
 392
 393 Reference< sdb::XColumn >  BibliographyLoader::GetIdentifierColumn() const
 394 {
 395     BibDataManager* pDatMan = GetDataManager();
 396     Reference< XNameAccess >  xColumns = GetDataColumns();
 397     OUString sIdentifierColumnName = pDatMan->GetIdentifierMapping();
 398
 399     Reference< sdb::XColumn >  xReturn;
 400     if (xColumns.is() && xColumns->hasByName(sIdentifierColumnName))
 401     {
 402         xReturn.set(xColumns->getByName(sIdentifierColumnName), UNO_QUERY);
 403     }
 404     return xReturn;
 405 }
 406
 407 Reference< XResultSet > const &  BibliographyLoader::GetDataCursor() const
 408 {
 409     if (!m_xCursor.is())
 410         GetDataColumns();
 411     if (m_xCursor.is())
 412         m_xCursor->first();
 413     return m_xCursor;
 414 }
 415
 416 static OUString lcl_AddProperty(const Reference< XNameAccess >&  xColumns,
 417         const Mapping* pMapping, const OUString& rColumnName)
 418 {
 419     OUString sColumnName(rColumnName);
 420     if(pMapping)
 421     {
 422         for(const auto & aColumnPair : pMapping->aColumnPairs)
 423         {
 424             if(aColumnPair.sLogicalColumnName == rColumnName)
 425             {
 426                 sColumnName = aColumnPair.sRealColumnName;
 427                 break;
 428             }
 429         }
 430     }
 431     OUString uColumnName(sColumnName);
 432     OUString uRet;
 433     Reference< sdb::XColumn >  xCol;
 434     if (xColumns->hasByName(uColumnName))
 435         xCol.set(xColumns->getByName(uColumnName), UNO_QUERY);
 436     if (xCol.is())
 437         uRet = xCol->getString();
 438     return uRet;
 439 }
 440
 441 Any BibliographyLoader::getByName(const OUString& rName)
 442 {
 443     Any aRet;
 444     try
 445     {
 446         BibDataManager* pDatMan = GetDataManager();
 447         Reference< XResultSet >  xCursor = GetDataCursor();
 448         Reference< sdbcx::XColumnsSupplier >  xSupplyCols(xCursor, UNO_QUERY);
 449         Reference< XNameAccess >  xColumns;
 450         if (!xSupplyCols.is())
 451             return aRet;
 452         xColumns = xSupplyCols->getColumns();
 453         DBG_ASSERT(xSupplyCols.is(), "BibliographyLoader::getByName : invalid columns returned by the data cursor (may be the result set is not alive ?) !");
 454         if (!xColumns.is())
 455             return aRet;
 456
 457         const OUString sIdentifierMapping = pDatMan->GetIdentifierMapping();
 458         Reference< sdb::XColumn >  xColumn;
 459         if (xColumns->hasByName(sIdentifierMapping))
 460             xColumn.set(xColumns->getByName(sIdentifierMapping), UNO_QUERY);
 461         if (xColumn.is())
 462         {
 463             do
 464             {
 465                 if ((rName == xColumn->getString()) && !xColumn->wasNull())
 466                 {
 467                     Sequence<PropertyValue> aPropSequ(COLUMN_COUNT);
 468                     PropertyValue* pValues = aPropSequ.getArray();
 469                     BibConfig* pConfig = BibModul::GetConfig();
 470                     BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL();
 471                     const Mapping* pMapping = pConfig->GetMapping(aBibDesc);
 472                     for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++)
 473                     {
 474                         const OUString& sColName = pConfig->GetDefColumnName(
 475                                                     nEntry);
 476                         pValues[nEntry].Name = sColName;
 477                         pValues[nEntry].Value <<= lcl_AddProperty(xColumns, pMapping, sColName);
 478                     }
 479                     aRet <<= aPropSequ;
 480
 481                     break;
 482                 }
 483             }
 484             while(xCursor->next());
 485         }
 486     }
 487     catch(const Exception&)
 488     {
 489         DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 490     }
 491     return aRet;
 492 }
 493
 494 Sequence< OUString > BibliographyLoader::getElementNames()
 495 {
 496     Sequence< OUString > aRet(10);
 497     int nRealNameCount = 0;
 498     try
 499     {
 500         Reference< XResultSet >  xCursor(GetDataCursor());
 501         Reference< sdb::XColumn >  xIdColumn(GetIdentifierColumn());
 502         if (xIdColumn.is()) // implies xCursor.is()
 503         {
 504             do
 505             {
 506                 OUString sTemp = xIdColumn->getString();
 507                 if (!sTemp.isEmpty() && !xIdColumn->wasNull())
 508                 {
 509                     int nLen = aRet.getLength();
 510                     if(nLen == nRealNameCount)
 511                         aRet.realloc(nLen + 10);
 512                     OUString* pArray = aRet.getArray();
 513                     pArray[nRealNameCount] = sTemp;
 514                     nRealNameCount++;
 515                 }
 516             }
 517             while (xCursor->next());
 518         }
 519     }
 520     catch(const Exception&)
 521     {
 522         DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 523     }
 524
 525     aRet.realloc(nRealNameCount);
 526     return aRet;
 527 }
 528
 529 sal_Bool BibliographyLoader::hasByName(const OUString& rName)
 530 {
 531     bool bRet = false;
 532     try
 533     {
 534         Reference< XResultSet >  xCursor = GetDataCursor();
 535         Reference< sdb::XColumn >  xIdColumn = GetIdentifierColumn();
 536
 537         if (xIdColumn.is())     // implies xCursor.is()
 538         {
 539             do
 540             {
 541                 OUString sCurrentId = xIdColumn->getString();
 542                 if (!xIdColumn->wasNull() && rName.startsWith(sCurrentId))
 543                 {
 544                     bRet = true;
 545                     break;
 546                 }
 547             }
 548             while(xCursor->next());
 549         }
 550     }
 551     catch(const Exception&)
 552     {
 553         DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 554     }
 555     return bRet;
 556 }
 557
 558 Type  BibliographyLoader::getElementType()
 559 {
 560     return cppu::UnoType<Sequence<PropertyValue>>::get();
 561 }
 562
 563 sal_Bool BibliographyLoader::hasElements()
 564 {
 565     Reference< XResultSet >  xCursor = GetDataCursor();
 566     Reference< XNameAccess >  xColumns = GetDataColumns();
 567     return xColumns.is() && xColumns->getElementNames().hasElements();
 568 }
 569
 570 Reference< XPropertySetInfo >  BibliographyLoader::getPropertySetInfo()
 571 {
 572     static const SfxItemPropertyMapEntry aBibProps_Impl[] =
 573     {
 574         { OUString("BibliographyDataFieldNames"), 0, cppu::UnoType<Sequence<PropertyValue>>::get(), PropertyAttribute::READONLY, 0},
 575         { OUString(), 0, css::uno::Type(), 0, 0 }
 576     };
 577     static Reference< XPropertySetInfo >  xRet =
 578         SfxItemPropertySet(aBibProps_Impl).getPropertySetInfo();
 579     return xRet;
 580 }
 581
 582 void BibliographyLoader::setPropertyValue(const OUString& /*PropertyName*/,
 583                                         const Any& /*aValue*/)
 584 {
 585     throw UnknownPropertyException();
 586     //no changeable properties
 587 }
 588
 589 Any BibliographyLoader::getPropertyValue(const OUString& rPropertyName)
 590 {
 591     Any aRet;
 592     static const sal_uInt16 aInternalMapping[] =
 593     {
 594         IDENTIFIER_POS             , // BibliographyDataField_IDENTIFIER
 595         AUTHORITYTYPE_POS          , // BibliographyDataField_BIBILIOGRAPHIC_TYPE
 596         ADDRESS_POS                , // BibliographyDataField_ADDRESS
 597         ANNOTE_POS                 , // BibliographyDataField_ANNOTE
 598         AUTHOR_POS                 , // BibliographyDataField_AUTHOR
 599         BOOKTITLE_POS              , // BibliographyDataField_BOOKTITLE
 600         CHAPTER_POS                , // BibliographyDataField_CHAPTER
 601         EDITION_POS                , // BibliographyDataField_EDITION
 602         EDITOR_POS                 , // BibliographyDataField_EDITOR
 603         HOWPUBLISHED_POS           , // BibliographyDataField_HOWPUBLISHED
 604         INSTITUTION_POS            , // BibliographyDataField_INSTITUTION
 605         JOURNAL_POS                , // BibliographyDataField_JOURNAL
 606         MONTH_POS                  , // BibliographyDataField_MONTH
 607         NOTE_POS                   , // BibliographyDataField_NOTE
 608         NUMBER_POS                 , // BibliographyDataField_NUMBER
 609         ORGANIZATIONS_POS          , // BibliographyDataField_ORGANIZATIONS
 610         PAGES_POS                  , // BibliographyDataField_PAGES
 611         PUBLISHER_POS              , // BibliographyDataField_PUBLISHER
 612         SCHOOL_POS                 , // BibliographyDataField_SCHOOL
 613         SERIES_POS                 , // BibliographyDataField_SERIES
 614         TITLE_POS                  , // BibliographyDataField_TITLE
 615         REPORTTYPE_POS             , // BibliographyDataField_REPORT_TYPE
 616         VOLUME_POS                 , // BibliographyDataField_VOLUME
 617         YEAR_POS                   , // BibliographyDataField_YEAR
 618         URL_POS                    , // BibliographyDataField_URL
 619         CUSTOM1_POS                , // BibliographyDataField_CUSTOM1
 620         CUSTOM2_POS                , // BibliographyDataField_CUSTOM2
 621         CUSTOM3_POS                , // BibliographyDataField_CUSTOM3
 622         CUSTOM4_POS                , // BibliographyDataField_CUSTOM4
 623         CUSTOM5_POS                , // BibliographyDataField_CUSTOM5
 624         ISBN_POS                    //BibliographyDataField_ISBN
 625     };
 626     if(rPropertyName != "BibliographyDataFieldNames")
 627         throw UnknownPropertyException();
 628     Sequence<PropertyValue> aSeq(COLUMN_COUNT);
 629     PropertyValue* pArray = aSeq.getArray();
 630     BibConfig* pConfig = BibModul::GetConfig();
 631     for(sal_uInt16 i = 0; i <= text::BibliographyDataField::ISBN ; i++)
 632     {
 633         pArray[i].Name = pConfig->GetDefColumnName(aInternalMapping[i]);
 634         pArray[i].Value <<= static_cast<sal_Int16>(i);
 635     }
 636     aRet <<= aSeq;
 637     return aRet;
 638 }
 639
 640 void BibliographyLoader::addPropertyChangeListener(
 641         const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
 642 {
 643     //no bound properties
 644 }
 645
 646 void BibliographyLoader::removePropertyChangeListener(
 647         const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
 648 {
 649     //no bound properties
 650 }
 651
 652 void BibliographyLoader::addVetoableChangeListener(
 653     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
 654 {
 655     //no vetoable properties
 656 }
 657
 658 void BibliographyLoader::removeVetoableChangeListener(
 659     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
 660 {
 661     //no vetoable properties
 662 }
 663
 664
 665 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */