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 "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     return { "com.sun.star.frame.FrameLoader", "com.sun.star.frame.Bibliography" };
 186 }
 187
 188 extern "C"
 189 {
 190     SAL_DLLPUBLIC_EXPORT void * bib_component_getFactory(
 191         const sal_Char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
 192     {
 193         void * pRet = nullptr;
 194         if (BibliographyLoader::getImplementationName_Static().equalsAscii( pImplName ) )
 195         {
 196             // create the factory
 197             Reference< XSingleServiceFactory > xFactory =
 198                 cppu::createSingleFactory(
 199                     static_cast<css::lang::XMultiServiceFactory *>(pServiceManager),
 200                     BibliographyLoader::getImplementationName_Static(),
 201                     BibliographyLoader_CreateInstance,
 202                     BibliographyLoader::getSupportedServiceNames_Static() );
 203             // acquire, because we return an interface pointer instead of a reference
 204             xFactory->acquire();
 205             pRet = xFactory.get();
 206         }
 207         return pRet;
 208     }
 209
 210 }
 211
 212 void BibliographyLoader::cancel()
 213 {
 214     //!
 215     //!
 216 }
 217
 218 void BibliographyLoader::load(const Reference< XFrame > & rFrame, const OUString& rURL,
 219         const Sequence< PropertyValue >& /*rArgs*/,
 220         const Reference< XLoadEventListener > & rListener)
 221 {
 222
 223     SolarMutexGuard aGuard;
 224
 225     m_pBibMod = OpenBibModul();
 226
 227     OUString aPartName = rURL.getToken( 1, '/' );
 228     Reference<XPropertySet> xPrSet(rFrame, UNO_QUERY);
 229     if(xPrSet.is())
 230     {
 231         Any aTitle;
 232         aTitle <<= BibResId(RID_BIB_STR_FRAME_TITLE);
 233         xPrSet->setPropertyValue("Title", aTitle);
 234     }
 235     if(aPartName == "View" || aPartName == "View1")
 236     {
 237         loadView(rFrame, rListener);
 238     }
 239 }
 240
 241
 242 void BibliographyLoader::loadView(const Reference< XFrame > & rFrame,
 243         const Reference< XLoadEventListener > & rListener)
 244 {
 245     SolarMutexGuard aGuard;
 246     //!
 247     if(!m_pBibMod)
 248         m_pBibMod = OpenBibModul();
 249
 250     m_xDatMan = BibModul::createDataManager();
 251     BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL();
 252
 253     if(aBibDesc.sDataSource.isEmpty())
 254     {
 255         DBChangeDialogConfig_Impl aConfig;
 256         const Sequence<OUString> aSources = aConfig.GetDataSourceNames();
 257         if(aSources.hasElements())
 258             aBibDesc.sDataSource = aSources.getConstArray()[0];
 259     }
 260
 261     Reference< XForm > xForm = m_xDatMan->createDatabaseForm( aBibDesc );
 262
 263     Reference< awt::XWindow >  aWindow = rFrame->getContainerWindow();
 264     VCLXWindow* pParentComponent = comphelper::getUnoTunnelImplementation<VCLXWindow>(aWindow);
 265     assert(pParentComponent);
 266
 267     VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow( aWindow );
 268
 269     VclPtrInstance<BibBookContainer> pMyWindow( pParent );
 270     pMyWindow->Show();
 271
 272     VclPtrInstance< ::bib::BibView> pView( pMyWindow, m_xDatMan.get(), WB_VSCROLL | WB_HSCROLL | WB_3DLOOK );
 273     pView->Show();
 274     m_xDatMan->SetView( pView );
 275
 276     VclPtrInstance< ::bib::BibBeamer> pBeamer( pMyWindow, m_xDatMan.get() );
 277     pBeamer->Show();
 278     pMyWindow->createTopFrame(pBeamer);
 279
 280     pMyWindow->createBottomFrame(pView);
 281
 282     Reference< awt::XWindow >  xWin ( pMyWindow->GetComponentInterface(), UNO_QUERY );
 283
 284     Reference< XController >  xCtrRef( new BibFrameController_Impl( xWin, m_xDatMan.get() ) );
 285
 286     xCtrRef->attachFrame(rFrame);
 287     rFrame->setComponent( xWin, xCtrRef);
 288     pBeamer->SetXController(xCtrRef);
 289
 290     if (pParentComponent)
 291     {
 292         // not earlier because SetFocus() is triggered in setVisible()
 293         pParentComponent->setVisible(true);
 294     }
 295
 296     Reference<XLoadable>(m_xDatMan.get())->load();
 297     m_xDatMan->RegisterInterceptor(pBeamer);
 298
 299     if ( rListener.is() )
 300         rListener->loadFinished( this );
 301
 302     // attach menu bar
 303     Reference< XPropertySet > xPropSet( rFrame, UNO_QUERY );
 304     Reference< css::frame::XLayoutManager > xLayoutManager;
 305     if ( xPropSet.is() )
 306     {
 307         try
 308         {
 309             Any a = xPropSet->getPropertyValue("LayoutManager");
 310             a >>= xLayoutManager;
 311         }
 312         catch ( const uno::Exception& )
 313         {
 314         }
 315     }
 316
 317     if ( xLayoutManager.is() )
 318         xLayoutManager->createElement( "private:resource/menubar/menubar" );
 319 }
 320
 321 BibDataManager* BibliographyLoader::GetDataManager()const
 322 {
 323     if(!m_xDatMan.is())
 324     {
 325         if(!m_pBibMod)
 326             const_cast< BibliographyLoader* >( this )->m_pBibMod = OpenBibModul();
 327         const_cast< BibliographyLoader* >( this )->m_xDatMan = BibModul::createDataManager();
 328     }
 329     return m_xDatMan.get();
 330 }
 331
 332 Reference< XNameAccess > const & BibliographyLoader::GetDataColumns() const
 333 {
 334     if (!m_xColumns.is())
 335     {
 336         Reference< XMultiServiceFactory >  xMgr = comphelper::getProcessServiceFactory();
 337         Reference< XRowSet >  xRowSet(xMgr->createInstance("com.sun.star.sdb.RowSet"), UNO_QUERY);
 338         Reference< XPropertySet >  xResultSetProps(xRowSet, UNO_QUERY);
 339         DBG_ASSERT(xResultSetProps.is() , "BibliographyLoader::GetDataCursor : invalid row set (no XResultSet or no XPropertySet) !");
 340
 341         BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL();
 342
 343         Any aBibUrlAny; aBibUrlAny <<= aBibDesc.sDataSource;
 344         xResultSetProps->setPropertyValue("DataSourceName", aBibUrlAny);
 345         Any aCommandType; aCommandType <<= aBibDesc.nCommandType;
 346         xResultSetProps->setPropertyValue("CommandType", aCommandType);
 347         Any aTableName; aTableName <<= aBibDesc.sTableOrQuery;
 348         xResultSetProps->setPropertyValue("Command", aTableName);
 349         Any aResultSetType; aResultSetType <<= sal_Int32(ResultSetType::SCROLL_INSENSITIVE);
 350         xResultSetProps->setPropertyValue("ResultSetType", aResultSetType);
 351         Any aResultSetCurrency; aResultSetCurrency <<= sal_Int32(ResultSetConcurrency::UPDATABLE);
 352         xResultSetProps->setPropertyValue("ResultSetConcurrency", aResultSetCurrency);
 353
 354         bool bSuccess = false;
 355         try
 356         {
 357             xRowSet->execute();
 358             bSuccess = true;
 359         }
 360         catch(const SQLException&)
 361         {
 362             DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 363         }
 364         catch(const Exception& )
 365         {
 366             DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 367             bSuccess = false;
 368         }
 369
 370         if (!bSuccess)
 371         {
 372             Reference< XComponent >  xSetComp(xRowSet, UNO_QUERY);
 373             if (xSetComp.is())
 374                 xSetComp->dispose();
 375             xRowSet = nullptr;
 376         }
 377         else
 378             const_cast<BibliographyLoader*>(this)->m_xCursor = xRowSet.get();
 379
 380         Reference< sdbcx::XColumnsSupplier >  xSupplyCols(m_xCursor, UNO_QUERY);
 381         if (xSupplyCols.is())
 382             const_cast<BibliographyLoader*>(this)->m_xColumns = xSupplyCols->getColumns();
 383     }
 384
 385     return m_xColumns;
 386 }
 387
 388 Reference< sdb::XColumn >  BibliographyLoader::GetIdentifierColumn() const
 389 {
 390     BibDataManager* pDatMan = GetDataManager();
 391     Reference< XNameAccess >  xColumns = GetDataColumns();
 392     OUString sIdentifierColumnName = pDatMan->GetIdentifierMapping();
 393
 394     Reference< sdb::XColumn >  xReturn;
 395     if (xColumns.is() && xColumns->hasByName(sIdentifierColumnName))
 396     {
 397         xReturn.set(xColumns->getByName(sIdentifierColumnName), UNO_QUERY);
 398     }
 399     return xReturn;
 400 }
 401
 402 Reference< XResultSet > const &  BibliographyLoader::GetDataCursor() const
 403 {
 404     if (!m_xCursor.is())
 405         GetDataColumns();
 406     if (m_xCursor.is())
 407         m_xCursor->first();
 408     return m_xCursor;
 409 }
 410
 411 static OUString lcl_AddProperty(const Reference< XNameAccess >&  xColumns,
 412         const Mapping* pMapping, const OUString& rColumnName)
 413 {
 414     OUString sColumnName(rColumnName);
 415     if(pMapping)
 416     {
 417         for(const auto & aColumnPair : pMapping->aColumnPairs)
 418         {
 419             if(aColumnPair.sLogicalColumnName == rColumnName)
 420             {
 421                 sColumnName = aColumnPair.sRealColumnName;
 422                 break;
 423             }
 424         }
 425     }
 426     OUString uColumnName(sColumnName);
 427     OUString uRet;
 428     Reference< sdb::XColumn >  xCol;
 429     if (xColumns->hasByName(uColumnName))
 430         xCol.set(xColumns->getByName(uColumnName), UNO_QUERY);
 431     if (xCol.is())
 432         uRet = xCol->getString();
 433     return uRet;
 434 }
 435
 436 Any BibliographyLoader::getByName(const OUString& rName)
 437 {
 438     Any aRet;
 439     try
 440     {
 441         BibDataManager* pDatMan = GetDataManager();
 442         Reference< XResultSet >  xCursor = GetDataCursor();
 443         Reference< sdbcx::XColumnsSupplier >  xSupplyCols(xCursor, UNO_QUERY);
 444         Reference< XNameAccess >  xColumns;
 445         if (!xSupplyCols.is())
 446             return aRet;
 447         xColumns = xSupplyCols->getColumns();
 448         DBG_ASSERT(xSupplyCols.is(), "BibliographyLoader::getByName : invalid columns returned by the data cursor (may be the result set is not alive ?) !");
 449         if (!xColumns.is())
 450             return aRet;
 451
 452         const OUString sIdentifierMapping = pDatMan->GetIdentifierMapping();
 453         Reference< sdb::XColumn >  xColumn;
 454         if (xColumns->hasByName(sIdentifierMapping))
 455             xColumn.set(xColumns->getByName(sIdentifierMapping), UNO_QUERY);
 456         if (xColumn.is())
 457         {
 458             do
 459             {
 460                 if ((rName == xColumn->getString()) && !xColumn->wasNull())
 461                 {
 462                     Sequence<PropertyValue> aPropSequ(COLUMN_COUNT);
 463                     PropertyValue* pValues = aPropSequ.getArray();
 464                     BibConfig* pConfig = BibModul::GetConfig();
 465                     BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL();
 466                     const Mapping* pMapping = pConfig->GetMapping(aBibDesc);
 467                     for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++)
 468                     {
 469                         const OUString& sColName = pConfig->GetDefColumnName(
 470                                                     nEntry);
 471                         pValues[nEntry].Name = sColName;
 472                         pValues[nEntry].Value <<= lcl_AddProperty(xColumns, pMapping, sColName);
 473                     }
 474                     aRet <<= aPropSequ;
 475
 476                     break;
 477                 }
 478             }
 479             while(xCursor->next());
 480         }
 481     }
 482     catch(const Exception&)
 483     {
 484         DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 485     }
 486     return aRet;
 487 }
 488
 489 Sequence< OUString > BibliographyLoader::getElementNames()
 490 {
 491     Sequence< OUString > aRet(10);
 492     int nRealNameCount = 0;
 493     try
 494     {
 495         Reference< XResultSet >  xCursor(GetDataCursor());
 496         Reference< sdb::XColumn >  xIdColumn(GetIdentifierColumn());
 497         if (xIdColumn.is()) // implies xCursor.is()
 498         {
 499             do
 500             {
 501                 OUString sTemp = xIdColumn->getString();
 502                 if (!sTemp.isEmpty() && !xIdColumn->wasNull())
 503                 {
 504                     int nLen = aRet.getLength();
 505                     if(nLen == nRealNameCount)
 506                         aRet.realloc(nLen + 10);
 507                     OUString* pArray = aRet.getArray();
 508                     pArray[nRealNameCount] = sTemp;
 509                     nRealNameCount++;
 510                 }
 511             }
 512             while (xCursor->next());
 513         }
 514     }
 515     catch(const Exception&)
 516     {
 517         DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 518     }
 519
 520     aRet.realloc(nRealNameCount);
 521     return aRet;
 522 }
 523
 524 sal_Bool BibliographyLoader::hasByName(const OUString& rName)
 525 {
 526     bool bRet = false;
 527     try
 528     {
 529         Reference< XResultSet >  xCursor = GetDataCursor();
 530         Reference< sdb::XColumn >  xIdColumn = GetIdentifierColumn();
 531
 532         if (xIdColumn.is())     // implies xCursor.is()
 533         {
 534             do
 535             {
 536                 OUString sCurrentId = xIdColumn->getString();
 537                 if (!xIdColumn->wasNull() && rName.startsWith(sCurrentId))
 538                 {
 539                     bRet = true;
 540                     break;
 541                 }
 542             }
 543             while(xCursor->next());
 544         }
 545     }
 546     catch(const Exception&)
 547     {
 548         DBG_UNHANDLED_EXCEPTION("extensions.biblio");
 549     }
 550     return bRet;
 551 }
 552
 553 Type  BibliographyLoader::getElementType()
 554 {
 555     return cppu::UnoType<Sequence<PropertyValue>>::get();
 556 }
 557
 558 sal_Bool BibliographyLoader::hasElements()
 559 {
 560     Reference< XResultSet >  xCursor = GetDataCursor();
 561     Reference< XNameAccess >  xColumns = GetDataColumns();
 562     return xColumns.is() && xColumns->getElementNames().hasElements();
 563 }
 564
 565 Reference< XPropertySetInfo >  BibliographyLoader::getPropertySetInfo()
 566 {
 567     static const SfxItemPropertyMapEntry aBibProps_Impl[] =
 568     {
 569         { OUString("BibliographyDataFieldNames"), 0, cppu::UnoType<Sequence<PropertyValue>>::get(), PropertyAttribute::READONLY, 0},
 570         { OUString(), 0, css::uno::Type(), 0, 0 }
 571     };
 572     static Reference< XPropertySetInfo >  xRet =
 573         SfxItemPropertySet(aBibProps_Impl).getPropertySetInfo();
 574     return xRet;
 575 }
 576
 577 void BibliographyLoader::setPropertyValue(const OUString& /*PropertyName*/,
 578                                         const Any& /*aValue*/)
 579 {
 580     throw UnknownPropertyException();
 581     //no changeable properties
 582 }
 583
 584 Any BibliographyLoader::getPropertyValue(const OUString& rPropertyName)
 585 {
 586     Any aRet;
 587     static const sal_uInt16 aInternalMapping[] =
 588     {
 589         IDENTIFIER_POS             , // BibliographyDataField_IDENTIFIER
 590         AUTHORITYTYPE_POS          , // BibliographyDataField_BIBILIOGRAPHIC_TYPE
 591         ADDRESS_POS                , // BibliographyDataField_ADDRESS
 592         ANNOTE_POS                 , // BibliographyDataField_ANNOTE
 593         AUTHOR_POS                 , // BibliographyDataField_AUTHOR
 594         BOOKTITLE_POS              , // BibliographyDataField_BOOKTITLE
 595         CHAPTER_POS                , // BibliographyDataField_CHAPTER
 596         EDITION_POS                , // BibliographyDataField_EDITION
 597         EDITOR_POS                 , // BibliographyDataField_EDITOR
 598         HOWPUBLISHED_POS           , // BibliographyDataField_HOWPUBLISHED
 599         INSTITUTION_POS            , // BibliographyDataField_INSTITUTION
 600         JOURNAL_POS                , // BibliographyDataField_JOURNAL
 601         MONTH_POS                  , // BibliographyDataField_MONTH
 602         NOTE_POS                   , // BibliographyDataField_NOTE
 603         NUMBER_POS                 , // BibliographyDataField_NUMBER
 604         ORGANIZATIONS_POS          , // BibliographyDataField_ORGANIZATIONS
 605         PAGES_POS                  , // BibliographyDataField_PAGES
 606         PUBLISHER_POS              , // BibliographyDataField_PUBLISHER
 607         SCHOOL_POS                 , // BibliographyDataField_SCHOOL
 608         SERIES_POS                 , // BibliographyDataField_SERIES
 609         TITLE_POS                  , // BibliographyDataField_TITLE
 610         REPORTTYPE_POS             , // BibliographyDataField_REPORT_TYPE
 611         VOLUME_POS                 , // BibliographyDataField_VOLUME
 612         YEAR_POS                   , // BibliographyDataField_YEAR
 613         URL_POS                    , // BibliographyDataField_URL
 614         CUSTOM1_POS                , // BibliographyDataField_CUSTOM1
 615         CUSTOM2_POS                , // BibliographyDataField_CUSTOM2
 616         CUSTOM3_POS                , // BibliographyDataField_CUSTOM3
 617         CUSTOM4_POS                , // BibliographyDataField_CUSTOM4
 618         CUSTOM5_POS                , // BibliographyDataField_CUSTOM5
 619         ISBN_POS                    //BibliographyDataField_ISBN
 620     };
 621     if(rPropertyName != "BibliographyDataFieldNames")
 622         throw UnknownPropertyException(rPropertyName);
 623     Sequence<PropertyValue> aSeq(COLUMN_COUNT);
 624     PropertyValue* pArray = aSeq.getArray();
 625     BibConfig* pConfig = BibModul::GetConfig();
 626     for(sal_uInt16 i = 0; i <= text::BibliographyDataField::ISBN ; i++)
 627     {
 628         pArray[i].Name = pConfig->GetDefColumnName(aInternalMapping[i]);
 629         pArray[i].Value <<= static_cast<sal_Int16>(i);
 630     }
 631     aRet <<= aSeq;
 632     return aRet;
 633 }
 634
 635 void BibliographyLoader::addPropertyChangeListener(
 636         const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
 637 {
 638     //no bound properties
 639 }
 640
 641 void BibliographyLoader::removePropertyChangeListener(
 642         const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
 643 {
 644     //no bound properties
 645 }
 646
 647 void BibliographyLoader::addVetoableChangeListener(
 648     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
 649 {
 650     //no vetoable properties
 651 }
 652
 653 void BibliographyLoader::removeVetoableChangeListener(
 654     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
 655 {
 656     //no vetoable properties
 657 }
 658
 659
 660 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */