| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_extensions.hxx" |
| |
| |
| #include <osl/mutex.hxx> |
| #include <tools/urlobj.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <cppuhelper/weak.hxx> |
| #include <svl/itemprop.hxx> |
| #include <uno/environment.h> |
| #include <svl/urihelper.hxx> |
| #ifndef _TOOLKIT_UNOHLP_HXX |
| #include <toolkit/helper/vclunohelper.hxx> |
| #endif |
| #include <comphelper/processfactory.hxx> |
| #include <cppuhelper/factory.hxx> // helper for factories |
| #include <com/sun/star/sdbc/ResultSetType.hpp> |
| #include <com/sun/star/sdbc/ResultSetConcurrency.hpp> |
| #include <com/sun/star/sdb/XColumn.hpp> |
| #include <com/sun/star/util/XURLTransformer.hpp> |
| #include <com/sun/star/sdbcx/XColumnsSupplier.hpp> |
| #include <com/sun/star/sdbc/XRowSet.hpp> |
| #include <com/sun/star/sdb/CommandType.hpp> |
| #include <com/sun/star/frame/XFrameLoader.hpp> |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/lang/XSingleServiceFactory.hpp> |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/container/XNameAccess.hpp> |
| #include <com/sun/star/text/BibliographyDataField.hpp> |
| #include <com/sun/star/form/XLoadListener.hpp> |
| #include <com/sun/star/frame/XLayoutManager.hpp> |
| #include <toolkit/awt/vclxwindow.hxx> |
| #include <vcl/window.hxx> |
| #include <vcl/edit.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/group.hxx> |
| #include <svtools/svmedit.hxx> |
| |
| #include "bibresid.hxx" |
| #ifndef BIB_HRC |
| #include "bib.hrc" |
| #endif |
| #include "bibcont.hxx" |
| #include "bibbeam.hxx" |
| #include "bibmod.hxx" |
| #include "bibview.hxx" |
| #include "framectr.hxx" |
| #include "datman.hxx" |
| #include <bibconfig.hxx> |
| #include <cppuhelper/implbase4.hxx> // helper for implementations |
| |
| using namespace ::rtl; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::sdb; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::form; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::frame; |
| |
| #define C2U(cChar) OUString::createFromAscii(cChar) |
| |
| |
| //----------------------------------------------------------------------------- |
| |
| #define PROPERTY_FRAME 1 |
| |
| class BibliographyLoader : public cppu::WeakImplHelper4 |
| < XServiceInfo, XNameAccess, XPropertySet, XFrameLoader > |
| { |
| HdlBibModul m_pBibMod; |
| Reference< XLoadable > m_xDatMan; |
| BibDataManager* m_pDatMan; |
| Reference< XNameAccess > m_xColumns; |
| Reference< XResultSet > m_xCursor; |
| |
| private: |
| |
| void loadView(const Reference< XFrame > & aFrame, const rtl::OUString& aURL, |
| const Sequence< PropertyValue >& aArgs, |
| const Reference< XLoadEventListener > & aListener); |
| |
| BibDataManager* GetDataManager()const; |
| Reference< XNameAccess > GetDataColumns() const; |
| Reference< XResultSet > GetDataCursor() const; |
| Reference< sdb::XColumn > GetIdentifierColumn() const; |
| |
| public: |
| BibliographyLoader(); |
| ~BibliographyLoader(); |
| |
| // XServiceInfo |
| rtl::OUString SAL_CALL getImplementationName() throw( ); |
| sal_Bool SAL_CALL supportsService(const rtl::OUString& ServiceName) throw( ); |
| Sequence< rtl::OUString > SAL_CALL getSupportedServiceNames(void) throw( ); |
| static rtl::OUString getImplementationName_Static() throw( ) |
| |
| { |
| //! |
| return C2U("com.sun.star.extensions.Bibliography"); |
| //! |
| } |
| |
| //XNameAccess |
| virtual Any SAL_CALL getByName(const rtl::OUString& aName) throw ( NoSuchElementException, WrappedTargetException, RuntimeException ); |
| virtual Sequence< rtl::OUString > SAL_CALL getElementNames(void) throw ( RuntimeException ); |
| virtual sal_Bool SAL_CALL hasByName(const rtl::OUString& aName) throw ( RuntimeException ); |
| |
| //XElementAccess |
| virtual Type SAL_CALL getElementType(void) throw ( RuntimeException ); |
| virtual sal_Bool SAL_CALL hasElements(void) throw ( RuntimeException ); |
| |
| //XPropertySet |
| virtual Reference< XPropertySetInfo > SAL_CALL getPropertySetInfo(void) throw ( RuntimeException ); |
| virtual void SAL_CALL setPropertyValue(const rtl::OUString& PropertyName, const Any& aValue) throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException ); |
| virtual Any SAL_CALL getPropertyValue(const rtl::OUString& PropertyName) throw ( UnknownPropertyException, WrappedTargetException, RuntimeException ); |
| virtual void SAL_CALL addPropertyChangeListener(const rtl::OUString& PropertyName, const Reference< XPropertyChangeListener > & aListener) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ); |
| virtual void SAL_CALL removePropertyChangeListener(const rtl::OUString& PropertyName, const Reference< XPropertyChangeListener > & aListener) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ); |
| virtual void SAL_CALL addVetoableChangeListener(const rtl::OUString& PropertyName, const Reference< XVetoableChangeListener > & aListener) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ); |
| virtual void SAL_CALL removeVetoableChangeListener(const rtl::OUString& PropertyName, const Reference< XVetoableChangeListener > & aListener) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ); |
| |
| static Sequence<rtl::OUString> SAL_CALL getSupportedServiceNames_Static(void) throw( ); |
| |
| friend Reference< XInterface > SAL_CALL BibliographyLoader_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw( Exception ); |
| |
| // XLoader |
| virtual void SAL_CALL load(const Reference< XFrame > & aFrame, const rtl::OUString& aURL, |
| const Sequence< PropertyValue >& aArgs, |
| const Reference< XLoadEventListener > & aListener) throw (::com::sun::star::uno::RuntimeException); |
| virtual void SAL_CALL cancel(void) throw (::com::sun::star::uno::RuntimeException); |
| }; |
| |
| BibliographyLoader::BibliographyLoader() : |
| m_pBibMod(0), |
| m_pDatMan(0) |
| { |
| } |
| |
| BibliographyLoader::~BibliographyLoader() |
| { |
| Reference< lang::XComponent > xComp(m_xCursor, UNO_QUERY); |
| if (xComp.is()) |
| xComp->dispose(); |
| if(m_pBibMod) |
| CloseBibModul(m_pBibMod); |
| } |
| |
| |
| Reference< XInterface > SAL_CALL BibliographyLoader_CreateInstance( const Reference< XMultiServiceFactory > & /*rSMgr*/ ) throw( Exception ) |
| { |
| return *(new BibliographyLoader); |
| } |
| |
| |
| // XServiceInfo |
| rtl::OUString BibliographyLoader::getImplementationName() throw( ) |
| |
| { |
| return getImplementationName_Static(); |
| } |
| |
| // XServiceInfo |
| sal_Bool BibliographyLoader::supportsService(const rtl::OUString& ServiceName) throw( ) |
| { |
| Sequence< rtl::OUString > aSNL = getSupportedServiceNames(); |
| const rtl::OUString * pArray = aSNL.getConstArray(); |
| for( sal_Int32 i = 0; i < aSNL.getLength(); i++ ) |
| if( pArray[i] == ServiceName ) |
| return sal_True; |
| return sal_False; |
| } |
| |
| // XServiceInfo |
| Sequence< rtl::OUString > BibliographyLoader::getSupportedServiceNames(void) throw( ) |
| { |
| return getSupportedServiceNames_Static(); |
| } |
| |
| // ORegistryServiceManager_Static |
| Sequence< rtl::OUString > BibliographyLoader::getSupportedServiceNames_Static(void) throw( ) |
| { |
| Sequence< rtl::OUString > aSNS( 2 ); |
| aSNS.getArray()[0] = C2U("com.sun.star.frame.FrameLoader"); |
| //! |
| aSNS.getArray()[1] = C2U("com.sun.star.frame.Bibliography"); |
| //! |
| return aSNS; |
| } |
| |
| extern "C" |
| { |
| void SAL_CALL component_getImplementationEnvironment( |
| const sal_Char ** ppEnvTypeName, uno_Environment ** /*ppEnv*/ ) |
| { |
| *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; |
| } |
| |
| void * SAL_CALL component_getFactory( |
| const sal_Char * pImplName, XMultiServiceFactory * pServiceManager, void * /*pRegistryKey*/ ) |
| { |
| void * pRet = 0; |
| if (!BibliographyLoader::getImplementationName_Static().compareToAscii( pImplName ) ) |
| { |
| // create the factory |
| Reference< XSingleServiceFactory > xFactory = |
| cppu::createSingleFactory( |
| pServiceManager, |
| BibliographyLoader::getImplementationName_Static(), |
| BibliographyLoader_CreateInstance, |
| BibliographyLoader::getSupportedServiceNames_Static() ); |
| // acquire, because we return an interface pointer instead of a reference |
| xFactory->acquire(); |
| pRet = xFactory.get(); |
| } |
| return pRet; |
| } |
| |
| } |
| // ----------------------------------------------------------------------- |
| void BibliographyLoader::cancel(void) throw (::com::sun::star::uno::RuntimeException) |
| { |
| //! |
| //! |
| } |
| |
| // ----------------------------------------------------------------------- |
| void BibliographyLoader::load(const Reference< XFrame > & rFrame, const rtl::OUString& rURL, |
| const Sequence< PropertyValue >& rArgs, |
| const Reference< XLoadEventListener > & rListener) throw (::com::sun::star::uno::RuntimeException) |
| { |
| //! |
| |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| m_pBibMod = OpenBibModul(); |
| |
| String aURLStr( rURL ); |
| String aPartName = aURLStr.GetToken( 1, '/' ); |
| Reference<XPropertySet> xPrSet(rFrame, UNO_QUERY); |
| if(xPrSet.is()) |
| { |
| Any aTitle; |
| aTitle <<= OUString(String(BibResId(RID_BIB_STR_FRAME_TITLE))); |
| xPrSet->setPropertyValue(C2U("Title"), aTitle); |
| } |
| if(aPartName.EqualsAscii("View") || aPartName.EqualsAscii("View1")) |
| { |
| loadView(rFrame, rURL, rArgs, rListener); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| void BibliographyLoader::loadView(const Reference< XFrame > & rFrame, const rtl::OUString& /*rURL*/, |
| const Sequence< PropertyValue >& /*rArgs*/, |
| const Reference< XLoadEventListener > & rListener) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| //! |
| if(!m_pBibMod) |
| m_pBibMod = OpenBibModul(); |
| |
| /* |
| //create the menu |
| ResMgr* pResMgr = (*m_pBibMod)->GetResMgr(); |
| INetURLObject aEntry( URIHelper::SmartRelToAbs(pResMgr->GetFileName()) ); |
| String aMenuRes( RTL_CONSTASCII_USTRINGPARAM( "private:resource/" )); |
| aMenuRes += ( aEntry.GetName() += '/' ); |
| aMenuRes+=String::CreateFromInt32(RID_MAIN_MENU); |
| |
| util::URL aURL; |
| aURL.Complete = aMenuRes; |
| |
| Reference< XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory(); |
| Reference< util::XURLTransformer > xTrans ( xMgr->createInstance( C2U("com.sun.star.util.URLTransformer") ), UNO_QUERY ); |
| if( xTrans.is() ) |
| { |
| // Datei laden |
| xTrans->parseStrict( aURL ); |
| |
| Reference< XDispatchProvider > xProv( rFrame, UNO_QUERY ); |
| if ( xProv.is() ) |
| { |
| Reference< XDispatch > aDisp = xProv->queryDispatch( aURL, C2U("_menubar"), 12 ); |
| if ( aDisp.is() ) |
| aDisp->dispatch( aURL, Sequence<PropertyValue>() ); |
| } |
| } |
| */ |
| m_pDatMan = (*m_pBibMod)->createDataManager(); |
| m_xDatMan = m_pDatMan; |
| BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL(); |
| |
| if(!aBibDesc.sDataSource.getLength()) |
| { |
| DBChangeDialogConfig_Impl aConfig; |
| const Sequence<OUString> aSources = aConfig.GetDataSourceNames(); |
| if(aSources.getLength()) |
| aBibDesc.sDataSource = aSources.getConstArray()[0]; |
| } |
| |
| Reference< XForm > xForm = m_pDatMan->createDatabaseForm( aBibDesc ); |
| |
| Reference< awt::XWindow > aWindow = rFrame->getContainerWindow(); |
| VCLXWindow* pParentComponent = VCLXWindow::GetImplementation(aWindow); |
| |
| Window* pParent = VCLUnoHelper::GetWindow( aWindow ); |
| |
| BibBookContainer *pMyWindow = new BibBookContainer( pParent, m_pDatMan ); |
| pMyWindow->Show(); |
| |
| ::bib::BibView* pView = new ::bib::BibView( pMyWindow, m_pDatMan, WB_VSCROLL | WB_HSCROLL | WB_3DLOOK ); |
| pView->Show(); |
| m_pDatMan->SetView( pView ); |
| |
| ::bib::BibBeamer* pBeamer = new ::bib::BibBeamer( pMyWindow, m_pDatMan ); |
| pBeamer->Show(); |
| pMyWindow->createTopFrame(pBeamer); |
| |
| pMyWindow->createBottomFrame(pView); |
| |
| Reference< awt::XWindow > xWin ( pMyWindow->GetComponentInterface(), UNO_QUERY ); |
| |
| Reference< XController > xCtrRef( new BibFrameController_Impl( xWin, m_pDatMan ) ); |
| |
| xCtrRef->attachFrame(rFrame); |
| rFrame->setComponent( xWin, xCtrRef); |
| pBeamer->SetXController(xCtrRef); |
| //! |
| |
| // not earlier because SetFocus() is triggered in setVisible() |
| pParentComponent->setVisible(sal_True); |
| |
| m_xDatMan->load(); |
| // #100312# ---------- |
| m_pDatMan->RegisterInterceptor(pBeamer); |
| |
| if ( rListener.is() ) |
| rListener->loadFinished( this ); |
| |
| // attach menu bar |
| Reference< XPropertySet > xPropSet( rFrame, UNO_QUERY ); |
| Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; |
| if ( xPropSet.is() ) |
| { |
| try |
| { |
| Any a = xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ))); |
| a >>= xLayoutManager; |
| } |
| catch ( uno::Exception& ) |
| { |
| } |
| } |
| |
| if ( xLayoutManager.is() ) |
| xLayoutManager->createElement( OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/menubar/menubar" ))); |
| } |
| /* -----------------06.12.99 14:37------------------- |
| |
| --------------------------------------------------*/ |
| BibDataManager* BibliographyLoader::GetDataManager()const |
| { |
| if(!m_pDatMan) |
| { |
| if(!m_pBibMod) |
| const_cast< BibliographyLoader* >( this )->m_pBibMod = OpenBibModul(); |
| const_cast< BibliographyLoader* >( this )->m_pDatMan = (*m_pBibMod)->createDataManager(); |
| const_cast< BibliographyLoader* >( this )->m_xDatMan = m_pDatMan; |
| } |
| return m_pDatMan; |
| } |
| /* -----------------06.12.99 14:39------------------- |
| |
| --------------------------------------------------*/ |
| Reference< XNameAccess > BibliographyLoader::GetDataColumns() const |
| { |
| if (!m_xColumns.is()) |
| { |
| Reference< XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory(); |
| Reference< XRowSet > xRowSet(xMgr->createInstance(C2U("com.sun.star.sdb.RowSet")), UNO_QUERY); |
| Reference< XPropertySet > xResultSetProps(xRowSet, UNO_QUERY); |
| DBG_ASSERT(xResultSetProps.is() , "BibliographyLoader::GetDataCursor : invalid row set (no XResultSet or no XPropertySet) !"); |
| |
| BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL(); |
| |
| Any aBibUrlAny; aBibUrlAny <<= aBibDesc.sDataSource; |
| xResultSetProps->setPropertyValue(C2U("DataSourceName"), aBibUrlAny); |
| Any aCommandType; aCommandType <<= aBibDesc.nCommandType; |
| xResultSetProps->setPropertyValue(C2U("CommandType"), aCommandType); |
| Any aTableName; aTableName <<= aBibDesc.sTableOrQuery; |
| xResultSetProps->setPropertyValue(C2U("Command"), aTableName); |
| Any aResultSetType; aResultSetType <<= (sal_Int32)(ResultSetType::SCROLL_INSENSITIVE); |
| xResultSetProps->setPropertyValue(C2U("ResultSetType"), aResultSetType); |
| Any aResultSetCurrency; aResultSetCurrency <<= (sal_Int32)(ResultSetConcurrency::UPDATABLE); |
| xResultSetProps->setPropertyValue(C2U("ResultSetConcurrency"), aResultSetCurrency); |
| |
| sal_Bool bSuccess = sal_False; |
| try |
| { |
| xRowSet->execute(); |
| bSuccess = sal_True; |
| } |
| catch(const SQLException&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| catch(const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| bSuccess = sal_False; |
| } |
| |
| if (!bSuccess) |
| { |
| Reference< XComponent > xSetComp(xRowSet, UNO_QUERY); |
| if (xSetComp.is()) |
| xSetComp->dispose(); |
| xRowSet = NULL; |
| } |
| else |
| ((BibliographyLoader*)this)->m_xCursor = xRowSet.get(); |
| |
| Reference< sdbcx::XColumnsSupplier > xSupplyCols(m_xCursor, UNO_QUERY); |
| if (xSupplyCols.is()) |
| ((BibliographyLoader*)this)->m_xColumns = xSupplyCols->getColumns(); |
| } |
| |
| return m_xColumns; |
| } |
| /* -----------------17.12.99 12:29------------------- |
| |
| --------------------------------------------------*/ |
| Reference< sdb::XColumn > BibliographyLoader::GetIdentifierColumn() const |
| { |
| BibDataManager* pDatMan = GetDataManager(); |
| Reference< XNameAccess > xColumns = GetDataColumns(); |
| rtl::OUString sIdentifierColumnName = pDatMan->GetIdentifierMapping(); |
| |
| Reference< sdb::XColumn > xReturn; |
| if (xColumns.is() && xColumns->hasByName(sIdentifierColumnName)) |
| { |
| xReturn = Reference< XColumn > (*(Reference< XInterface > *) |
| xColumns->getByName(sIdentifierColumnName).getValue(), UNO_QUERY); |
| } |
| return xReturn; |
| } |
| |
| /* -----------------06.12.99 15:05------------------- |
| |
| --------------------------------------------------*/ |
| Reference< XResultSet > BibliographyLoader::GetDataCursor() const |
| { |
| if (!m_xCursor.is()) |
| GetDataColumns(); |
| if (m_xCursor.is()) |
| m_xCursor->first(); |
| return m_xCursor; |
| } |
| |
| /*-- 17.11.99 12:51:38--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| rtl::OUString lcl_AddProperty(Reference< XNameAccess > xColumns, |
| const Mapping* pMapping, const String& rColumnName) |
| { |
| String sColumnName(rColumnName); |
| if(pMapping) |
| { |
| for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++) |
| { |
| if(pMapping->aColumnPairs[nEntry].sLogicalColumnName == OUString(rColumnName)) |
| { |
| sColumnName = pMapping->aColumnPairs[nEntry].sRealColumnName; |
| break; |
| } |
| } |
| } |
| rtl::OUString uColumnName(sColumnName); |
| rtl::OUString uRet; |
| Reference< sdb::XColumn > xCol; |
| if (xColumns->hasByName(uColumnName)) |
| xCol = Reference< sdb::XColumn > (*(Reference< XInterface > *)xColumns->getByName(uColumnName).getValue(), UNO_QUERY); |
| if (xCol.is()) |
| uRet = xCol->getString(); |
| return uRet; |
| } |
| //----------------------------------------------------------------------------- |
| Any BibliographyLoader::getByName(const rtl::OUString& rName) throw |
| ( NoSuchElementException, WrappedTargetException, RuntimeException ) |
| { |
| Any aRet; |
| try |
| { |
| BibDataManager* pDatMan = ((BibliographyLoader*)this)->GetDataManager(); |
| Reference< XResultSet > xCursor = GetDataCursor(); |
| Reference< sdbcx::XColumnsSupplier > xSupplyCols(xCursor, UNO_QUERY); |
| Reference< XNameAccess > xColumns; |
| if (!xSupplyCols.is()) |
| return aRet; |
| xColumns = xSupplyCols->getColumns(); |
| DBG_ASSERT(xSupplyCols.is(), "BibliographyLoader::getByName : invalid columns returned by the data cursor (may be the result set is not alive ?) !"); |
| if (!xColumns.is()) |
| return aRet; |
| |
| String sIdentifierMapping = pDatMan->GetIdentifierMapping(); |
| rtl::OUString sId = sIdentifierMapping; |
| Reference< sdb::XColumn > xColumn; |
| if (xColumns->hasByName(sId)) |
| xColumn = Reference< sdb::XColumn > (*(Reference< XInterface > *)xColumns->getByName(sId).getValue(), UNO_QUERY); |
| if (xColumn.is()) |
| { |
| do |
| { |
| if ((rName == xColumn->getString()) && !xColumn->wasNull()) |
| { |
| Sequence<PropertyValue> aPropSequ(COLUMN_COUNT); |
| PropertyValue* pValues = aPropSequ.getArray(); |
| BibConfig* pConfig = BibModul::GetConfig(); |
| BibDBDescriptor aBibDesc = BibModul::GetConfig()->GetBibliographyURL(); |
| const Mapping* pMapping = pConfig->GetMapping(aBibDesc); |
| for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++) |
| { |
| const String sColName = pConfig->GetDefColumnName( |
| nEntry); |
| pValues[nEntry].Name = sColName; |
| pValues[nEntry].Value <<= lcl_AddProperty(xColumns, pMapping, sColName); |
| } |
| aRet.setValue(&aPropSequ, ::getCppuType((Sequence<PropertyValue>*)0)); |
| |
| break; |
| } |
| } |
| while(xCursor->next()); |
| } |
| } |
| catch(const Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| return aRet; |
| } |
| /*-- 17.11.99 12:51:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| Sequence< rtl::OUString > BibliographyLoader::getElementNames(void) throw ( RuntimeException ) |
| { |
| Sequence< rtl::OUString > aRet(10); |
| int nRealNameCount = 0; |
| try |
| { |
| Reference< XResultSet > xCursor(GetDataCursor()); |
| Reference< sdb::XColumn > xIdColumn(GetIdentifierColumn()); |
| if (xIdColumn.is()) // implies xCursor.is() |
| { |
| do |
| { |
| rtl::OUString sTemp = xIdColumn->getString(); |
| if (sTemp.getLength() && !xIdColumn->wasNull()) |
| { |
| int nLen = aRet.getLength(); |
| if(nLen == nRealNameCount) |
| aRet.realloc(nLen + 10); |
| rtl::OUString* pArray = aRet.getArray(); |
| pArray[nRealNameCount] = sTemp; |
| nRealNameCount++; |
| } |
| } |
| while (xCursor->next()); |
| } |
| } |
| catch(const Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| aRet.realloc(nRealNameCount); |
| return aRet; |
| } |
| /*-- 17.11.99 12:51:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool BibliographyLoader::hasByName(const rtl::OUString& rName) throw ( RuntimeException ) |
| { |
| sal_Bool bRet = sal_False; |
| try |
| { |
| Reference< XResultSet > xCursor = GetDataCursor(); |
| Reference< sdb::XColumn > xIdColumn = GetIdentifierColumn(); |
| |
| if (xIdColumn.is()) // implies xCursor.is() |
| { |
| do |
| { |
| rtl::OUString sCurrentId = xIdColumn->getString(); |
| if (!xIdColumn->wasNull() && (rName.compareTo(sCurrentId) == COMPARE_EQUAL)) |
| { |
| bRet = sal_True; |
| break; |
| } |
| } |
| while(xCursor->next()); |
| } |
| } |
| catch(const Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| return bRet; |
| } |
| /*-- 17.11.99 12:51:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| Type BibliographyLoader::getElementType(void) throw ( RuntimeException ) |
| { |
| return ::getCppuType((Sequence<PropertyValue>*)0); |
| } |
| /*-- 17.11.99 12:51:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool BibliographyLoader::hasElements(void) throw ( RuntimeException ) |
| { |
| Reference< XResultSet > xCursor = GetDataCursor(); |
| Reference< XNameAccess > xColumns = GetDataColumns(); |
| return xColumns.is() && (xColumns->getElementNames().getLength() != 0); |
| } |
| |
| /*-- 07.12.99 14:28:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| Reference< XPropertySetInfo > BibliographyLoader::getPropertySetInfo(void) throw |
| ( RuntimeException ) |
| { |
| static SfxItemPropertyMapEntry aBibProps_Impl[] = |
| { |
| { MAP_CHAR_LEN("BibliographyDataFieldNames"), 0, &::getCppuType((Sequence<PropertyValue>*)0), PropertyAttribute::READONLY, 0}, |
| {0,0,0,0,0,0} |
| }; |
| static Reference< XPropertySetInfo > xRet = |
| SfxItemPropertySet(aBibProps_Impl).getPropertySetInfo(); |
| return xRet; |
| } |
| /*-- 07.12.99 14:28:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void BibliographyLoader::setPropertyValue(const rtl::OUString& /*PropertyName*/, |
| const Any& /*aValue*/) |
| throw( UnknownPropertyException, PropertyVetoException, |
| IllegalArgumentException, WrappedTargetException, RuntimeException) |
| { |
| throw UnknownPropertyException(); |
| //no changeable properties |
| } |
| /*-- 07.12.99 14:28:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| Any BibliographyLoader::getPropertyValue(const rtl::OUString& rPropertyName) |
| throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) |
| { |
| Any aRet; |
| static const sal_uInt16 aInternalMapping[] = |
| { |
| IDENTIFIER_POS , // BibliographyDataField_IDENTIFIER |
| AUTHORITYTYPE_POS , // BibliographyDataField_BIBILIOGRAPHIC_TYPE |
| ADDRESS_POS , // BibliographyDataField_ADDRESS |
| ANNOTE_POS , // BibliographyDataField_ANNOTE |
| AUTHOR_POS , // BibliographyDataField_AUTHOR |
| BOOKTITLE_POS , // BibliographyDataField_BOOKTITLE |
| CHAPTER_POS , // BibliographyDataField_CHAPTER |
| EDITION_POS , // BibliographyDataField_EDITION |
| EDITOR_POS , // BibliographyDataField_EDITOR |
| HOWPUBLISHED_POS , // BibliographyDataField_HOWPUBLISHED |
| INSTITUTION_POS , // BibliographyDataField_INSTITUTION |
| JOURNAL_POS , // BibliographyDataField_JOURNAL |
| MONTH_POS , // BibliographyDataField_MONTH |
| NOTE_POS , // BibliographyDataField_NOTE |
| NUMBER_POS , // BibliographyDataField_NUMBER |
| ORGANIZATIONS_POS , // BibliographyDataField_ORGANIZATIONS |
| PAGES_POS , // BibliographyDataField_PAGES |
| PUBLISHER_POS , // BibliographyDataField_PUBLISHER |
| SCHOOL_POS , // BibliographyDataField_SCHOOL |
| SERIES_POS , // BibliographyDataField_SERIES |
| TITLE_POS , // BibliographyDataField_TITLE |
| REPORTTYPE_POS , // BibliographyDataField_REPORT_TYPE |
| VOLUME_POS , // BibliographyDataField_VOLUME |
| YEAR_POS , // BibliographyDataField_YEAR |
| URL_POS , // BibliographyDataField_URL |
| CUSTOM1_POS , // BibliographyDataField_CUSTOM1 |
| CUSTOM2_POS , // BibliographyDataField_CUSTOM2 |
| CUSTOM3_POS , // BibliographyDataField_CUSTOM3 |
| CUSTOM4_POS , // BibliographyDataField_CUSTOM4 |
| CUSTOM5_POS , // BibliographyDataField_CUSTOM5 |
| ISBN_POS //BibliographyDataField_ISBN |
| }; |
| if(C2U("BibliographyDataFieldNames") == rPropertyName) |
| { |
| Sequence<PropertyValue> aSeq(COLUMN_COUNT); |
| PropertyValue* pArray = aSeq.getArray(); |
| BibConfig* pConfig = BibModul::GetConfig(); |
| for(sal_uInt16 i = 0; i <= text::BibliographyDataField::ISBN ; i++) |
| { |
| pArray[i].Name = pConfig->GetDefColumnName(aInternalMapping[i]); |
| pArray[i].Value <<= (sal_Int16) i; |
| } |
| aRet.setValue(&aSeq, ::getCppuType((Sequence<PropertyValue>*)0)); |
| } |
| else |
| throw UnknownPropertyException(); |
| return aRet; |
| } |
| /*-- 07.12.99 14:28:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void BibliographyLoader::addPropertyChangeListener( |
| const rtl::OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) |
| throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) |
| { |
| //no bound properties |
| } |
| /*-- 07.12.99 14:28:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void BibliographyLoader::removePropertyChangeListener( |
| const rtl::OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) |
| throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) |
| { |
| //no bound properties |
| } |
| /*-- 07.12.99 14:28:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void BibliographyLoader::addVetoableChangeListener( |
| const rtl::OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) |
| throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) |
| { |
| //no vetoable properties |
| } |
| /*-- 07.12.99 14:28:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void BibliographyLoader::removeVetoableChangeListener( |
| const rtl::OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) |
| throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) |
| { |
| //no vetoable properties |
| } |
| |
| |
| |