/************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * Copyright 2000, 2010 Oracle and/or its affiliates. * * OpenOffice.org - a multi-platform office productivity suite * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 3 * only, as published by the Free Software Foundation. * * OpenOffice.org is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License version 3 for more details * (a copy is included in the LICENSE file that accompanied this code). * * You should have received a copy of the GNU Lesser General Public License * version 3 along with OpenOffice.org. If not, see * * for a copy of the LGPLv3 License. * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_extensions.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef _SV_BUTTON_HXX #include #endif #include #include #include #include #include #include #include #include "datman.hxx" #include "bibresid.hxx" #include "bibmod.hxx" #include "bibview.hxx" // #100312# --------- #include "bibbeam.hxx" #include "bibprop.hrc" #include "toolbar.hxx" #include "toolbar.hrc" #include "bibconfig.hxx" #include "bibbeam.hxx" #include "bib.hrc" #include "datman.hrc" #include "bibliography.hrc" #include using namespace ::com::sun::star; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::container; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::sdb; using namespace ::com::sun::star::sdbc; using namespace ::com::sun::star::sdbcx; using namespace ::com::sun::star::form; using namespace ::com::sun::star::frame; using namespace ::com::sun::star::ucb; using namespace ::com::sun::star::lang; using namespace ::ucb; #define C2U(cChar) ::rtl::OUString::createFromAscii(cChar) #define C2S(cChar) String::CreateFromAscii(cChar) #define MAP_TOKEN ';' #define PAIR_TOKEN ':' /* -----------------17.01.00 14:38------------------- --------------------------------------------------*/ Reference< XConnection > getConnection(const ::rtl::OUString& _rURL) { // first get the sdb::DataSource corresponding to the url Reference< XDataSource > xDataSource; // is it a favorite title ? Reference< XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory(); Reference xNamingContextIfc = xMgr->createInstance(C2U("com.sun.star.sdb.DatabaseContext")); Reference< XNameAccess > xNamingContext(xNamingContextIfc, UNO_QUERY); if (xNamingContext.is() && xNamingContext->hasByName(_rURL)) { DBG_ASSERT(Reference< XNamingService > (xNamingContext, UNO_QUERY).is(), "::getDataSource : no NamingService interface on the sdb::DatabaseAccessContext !"); try { xDataSource = Reference< XDataSource > (Reference< XNamingService > (xNamingContext, UNO_QUERY)->getRegisteredObject(_rURL), UNO_QUERY); } catch(Exception eEx) { (void) eEx; // make compiler happy DBG_ERROR("Exception caught in ODatabaseContext::getRegisteredObject()"); } } // build the connection from the data source Reference< XConnection > xConn; if (xDataSource.is()) { // need user/pwd for this ::rtl::OUString sUser, sPwd; Reference< XPropertySet > xDataSourceProps(xDataSource, UNO_QUERY); Reference< XCompletedConnection > xComplConn(xDataSource, UNO_QUERY); /* Reference< XPropertySetInfo > xInfo = xDataSourceProps.is() ? xDataSourceProps->getPropertySetInfo() : Reference< XPropertySetInfo > (); if (xInfo.is() && xInfo->hasPropertyByName(C2U("User"))) xDataSourceProps->getPropertyValue(C2U("User")) >>= sUser; if (xInfo.is() && xInfo->hasPropertyByName(C2U("Password"))) xDataSourceProps->getPropertyValue(C2U("Password"))>>= sPwd; */ try { Reference xHdl = xMgr->createInstance(C2U("com.sun.star.task.InteractionHandler")); Reference xIHdl(xHdl, UNO_QUERY); xConn = xComplConn->connectWithCompletion(xIHdl); // xConn = xDataSource->getConnection(sUser, sPwd); } catch(SQLException&) { // TODO : a real error handling } catch(Exception& e ) { (void) e; // make compiler happy } } return xConn; } /* -----------------17.01.00 14:46------------------- --------------------------------------------------*/ Reference< XConnection > getConnection(const Reference< XInterface > & xRowSet) { Reference< XConnection > xConn; try { Reference< XPropertySet > xFormProps(xRowSet, UNO_QUERY); if (!xFormProps.is()) return xConn; xConn = Reference< XConnection > (*(Reference< XInterface > *)xFormProps->getPropertyValue(C2U("ActiveConnection")).getValue(), UNO_QUERY); if (!xConn.is()) { DBG_WARNING("no active connection"); } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("exception in getConnection"); } return xConn; } /* -----------------17.01.00 16:07------------------- --------------------------------------------------*/ Reference< XNameAccess > getColumns(const Reference< XForm > & _rxForm) { Reference< XNameAccess > xReturn; // check if the form is alive Reference< XColumnsSupplier > xSupplyCols( _rxForm, UNO_QUERY ); if (xSupplyCols.is()) xReturn = xSupplyCols->getColumns(); if (!xReturn.is() || (xReturn->getElementNames().getLength() == 0)) { // no .... xReturn = NULL; // -> get the table the form is bound to and ask it for their columns Reference< XTablesSupplier > xSupplyTables( getConnection( _rxForm ), UNO_QUERY ); Reference< XPropertySet > xFormProps( _rxForm, UNO_QUERY ); if (xFormProps.is() && xSupplyTables.is()) { try { DBG_ASSERT((*(sal_Int32*)xFormProps->getPropertyValue(C2U("CommandType")).getValue()) == CommandType::TABLE, "::getColumns : invalid form (has no table as data source) !"); ::rtl::OUString sTable; xFormProps->getPropertyValue(C2U("Command")) >>= sTable; Reference< XNameAccess > xTables = xSupplyTables->getTables(); if (xTables.is() && xTables->hasByName(sTable)) xSupplyCols = Reference< XColumnsSupplier > ( *(Reference< XInterface > *)xTables->getByName(sTable).getValue(), UNO_QUERY); if (xSupplyCols.is()) xReturn = xSupplyCols->getColumns(); } #ifdef DBG_UTIL catch(Exception& e ) #else catch(Exception&) #endif { #ifdef DBG_UTIL String sMsg(String::CreateFromAscii("::getColumns : catched an exception (")); sMsg += String(e.Message); sMsg.AppendAscii(") ..."); DBG_ERROR( ByteString(sMsg, RTL_TEXTENCODING_ASCII_US ).GetBuffer()); #endif } } } return xReturn; } /* -----------------11.11.99 15:54------------------- --------------------------------------------------*/ class MappingDialog_Impl : public ModalDialog { BibDataManager* pDatMan; OKButton aOKBT; CancelButton aCancelBT; HelpButton aHelpBT; FixedLine aMapGB; FixedText aIdentifierFT; ListBox aIdentifierLB; FixedText aAuthorityTypeFT; ListBox aAuthorityTypeLB; FixedText aAuthorFT; ListBox aAuthorLB; FixedText aTitleFT; ListBox aTitleLB; FixedText aMonthFT; ListBox aMonthLB; FixedText aYearFT; ListBox aYearLB; FixedText aISBNFT; ListBox aISBNLB; FixedText aBooktitleFT; ListBox aBooktitleLB; FixedText aChapterFT; ListBox aChapterLB; FixedText aEditionFT; ListBox aEditionLB; FixedText aEditorFT; ListBox aEditorLB; FixedText aHowpublishedFT; ListBox aHowpublishedLB; FixedText aInstitutionFT; ListBox aInstitutionLB; FixedText aJournalFT; ListBox aJournalLB; FixedText aNoteFT; ListBox aNoteLB; FixedText aAnnoteFT; ListBox aAnnoteLB; FixedText aNumberFT; ListBox aNumberLB; FixedText aOrganizationsFT; ListBox aOrganizationsLB; FixedText aPagesFT; ListBox aPagesLB; FixedText aPublisherFT; ListBox aPublisherLB; FixedText aAddressFT; ListBox aAddressLB; FixedText aSchoolFT; ListBox aSchoolLB; FixedText aSeriesFT; ListBox aSeriesLB; FixedText aReportTypeFT; ListBox aReportTypeLB; FixedText aVolumeFT; ListBox aVolumeLB; FixedText aURLFT; ListBox aURLLB; FixedText aCustom1FT; ListBox aCustom1LB; FixedText aCustom2FT; ListBox aCustom2LB; FixedText aCustom3FT; ListBox aCustom3LB; FixedText aCustom4FT; ListBox aCustom4LB; FixedText aCustom5FT; ListBox aCustom5LB; ListBox* aListBoxes[COLUMN_COUNT]; String sNone; sal_Bool bModified; DECL_LINK(OkHdl, OKButton*); DECL_LINK(ListBoxSelectHdl, ListBox*); public: MappingDialog_Impl(Window* pParent, BibDataManager* pDatMan); ~MappingDialog_Impl(); void SetModified() {bModified = TRUE;} }; /* -----------------11.11.99 16:42------------------- --------------------------------------------------*/ sal_uInt16 lcl_FindLogicalName(BibConfig* pConfig , const ::rtl::OUString& rLogicalColumnName) { for(sal_uInt16 i = 0; i < COLUMN_COUNT; i++) { if(rLogicalColumnName == pConfig->GetDefColumnName(i)) return i; } return USHRT_MAX; } //----------------------------------------------------------------------------- MappingDialog_Impl::MappingDialog_Impl(Window* pParent, BibDataManager* pMan) : ModalDialog(pParent, BibResId(RID_DLG_MAPPING) ), pDatMan(pMan), aOKBT(this, BibResId( BT_OK )), aCancelBT(this, BibResId( BT_CANCEL )), aHelpBT(this, BibResId( BT_HELP )), aMapGB(this, BibResId( GB_MAPPING )), aIdentifierFT(this, BibResId( FT_IDENTIFIER )), aIdentifierLB(this, BibResId( LB_IDENTIFIER )), aAuthorityTypeFT(this, BibResId( FT_AUTHORITYTYPE )), aAuthorityTypeLB(this, BibResId( LB_AUTHORITYTYPE )), aAuthorFT(this, BibResId( FT_AUTHOR )), aAuthorLB(this, BibResId( LB_AUTHOR )), aTitleFT(this, BibResId( FT_TITLE )), aTitleLB(this, BibResId( LB_TITLE )), aMonthFT(this, BibResId( FT_MONTH )), aMonthLB(this, BibResId( LB_MONTH )), aYearFT(this, BibResId( FT_YEAR )), aYearLB(this, BibResId( LB_YEAR )), aISBNFT(this, BibResId( FT_ISBN )), aISBNLB(this, BibResId( LB_ISBN )), aBooktitleFT(this, BibResId( FT_BOOKTITLE )), aBooktitleLB(this, BibResId( LB_BOOKTITLE )), aChapterFT(this, BibResId( FT_CHAPTER )), aChapterLB(this, BibResId( LB_CHAPTER )), aEditionFT(this, BibResId( FT_EDITION )), aEditionLB(this, BibResId( LB_EDITION )), aEditorFT(this, BibResId( FT_EDITOR )), aEditorLB(this, BibResId( LB_EDITOR )), aHowpublishedFT(this, BibResId( FT_HOWPUBLISHED )), aHowpublishedLB(this, BibResId( LB_HOWPUBLISHED )), aInstitutionFT(this, BibResId( FT_INSTITUTION )), aInstitutionLB(this, BibResId( LB_INSTITUTION )), aJournalFT(this, BibResId( FT_JOURNAL )), aJournalLB(this, BibResId( LB_JOURNAL )), aNoteFT(this, BibResId( FT_NOTE )), aNoteLB(this, BibResId( LB_NOTE )), aAnnoteFT(this, BibResId( FT_ANNOTE )), aAnnoteLB(this, BibResId( LB_ANNOTE )), aNumberFT(this, BibResId( FT_NUMBER )), aNumberLB(this, BibResId( LB_NUMBER )), aOrganizationsFT(this, BibResId( FT_ORGANIZATIONS )), aOrganizationsLB(this, BibResId( LB_ORGANIZATIONS )), aPagesFT(this, BibResId( FT_PAGES )), aPagesLB(this, BibResId( LB_PAGES )), aPublisherFT(this, BibResId( FT_PUBLISHER )), aPublisherLB(this, BibResId( LB_PUBLISHER )), aAddressFT(this, BibResId( FT_ADDRESS )), aAddressLB(this, BibResId( LB_ADDRESS )), aSchoolFT(this, BibResId( FT_SCHOOL )), aSchoolLB(this, BibResId( LB_SCHOOL )), aSeriesFT(this, BibResId( FT_SERIES )), aSeriesLB(this, BibResId( LB_SERIES )), aReportTypeFT(this, BibResId( FT_REPORTTYPE )), aReportTypeLB(this, BibResId( LB_REPORTTYPE )), aVolumeFT(this, BibResId( FT_VOLUME )), aVolumeLB(this, BibResId( LB_VOLUME )), aURLFT(this, BibResId( FT_URL )), aURLLB(this, BibResId( LB_URL )), aCustom1FT(this, BibResId( FT_CUSTOM1 )), aCustom1LB(this, BibResId( LB_CUSTOM1 )), aCustom2FT(this, BibResId( FT_CUSTOM2 )), aCustom2LB(this, BibResId( LB_CUSTOM2 )), aCustom3FT(this, BibResId( FT_CUSTOM3 )), aCustom3LB(this, BibResId( LB_CUSTOM3 )), aCustom4FT(this, BibResId( FT_CUSTOM4 )), aCustom4LB(this, BibResId( LB_CUSTOM4 )), aCustom5FT(this, BibResId( FT_CUSTOM5 )), aCustom5LB(this, BibResId( LB_CUSTOM5 )), sNone(BibResId(ST_NONE)), bModified(sal_False) { FreeResource(); aIdentifierFT.SetText(String( BibResId( ST_IDENTIFIER ))); aAuthorityTypeFT.SetText(String( BibResId( ST_AUTHTYPE ))); aAuthorFT.SetText(String( BibResId( ST_AUTHOR ))); aTitleFT.SetText(String( BibResId( ST_TITLE ))); aMonthFT.SetText(String( BibResId( ST_MONTH ))); aYearFT.SetText(String( BibResId( ST_YEAR ))); aISBNFT.SetText(String( BibResId( ST_ISBN ))); aBooktitleFT.SetText(String( BibResId( ST_BOOKTITLE ))); aChapterFT.SetText(String( BibResId( ST_CHAPTER ))); aEditionFT.SetText(String( BibResId( ST_EDITION ))); aEditorFT.SetText(String( BibResId( ST_EDITOR ))); aHowpublishedFT.SetText(String( BibResId( ST_HOWPUBLISHED ))); aInstitutionFT.SetText(String( BibResId( ST_INSTITUTION ))); aJournalFT.SetText(String( BibResId( ST_JOURNAL ))); aNoteFT.SetText(String( BibResId( ST_NOTE ))); aAnnoteFT.SetText(String( BibResId( ST_ANNOTE ))); aNumberFT.SetText(String( BibResId( ST_NUMBER ))); aOrganizationsFT.SetText(String( BibResId( ST_ORGANIZATION ))); aPagesFT.SetText(String( BibResId( ST_PAGE ))); aPublisherFT.SetText(String( BibResId( ST_PUBLISHER ))); aAddressFT.SetText(String( BibResId( ST_ADDRESS ))); aSchoolFT.SetText(String( BibResId( ST_SCHOOL ))); aSeriesFT.SetText(String( BibResId( ST_SERIES ))); aReportTypeFT.SetText(String( BibResId( ST_REPORT ))); aVolumeFT.SetText(String( BibResId( ST_VOLUME ))); aURLFT.SetText(String( BibResId( ST_URL ))); aCustom1FT.SetText(String( BibResId( ST_CUSTOM1 ))); aCustom2FT.SetText(String( BibResId( ST_CUSTOM2 ))); aCustom3FT.SetText(String( BibResId( ST_CUSTOM3 ))); aCustom4FT.SetText(String( BibResId( ST_CUSTOM4 ))); aCustom5FT.SetText(String( BibResId( ST_CUSTOM5 ))); aOKBT.SetClickHdl(LINK(this, MappingDialog_Impl, OkHdl)); String sTitle = GetText(); sTitle.SearchAndReplace(C2S("%1"), pDatMan->getActiveDataTable(), 0); SetText(sTitle); aListBoxes[0] = &aIdentifierLB; aListBoxes[1] = &aAuthorityTypeLB; aListBoxes[2] = &aAuthorLB; aListBoxes[3] = &aTitleLB; aListBoxes[4] = &aYearLB; aListBoxes[5] = &aISBNLB; aListBoxes[6] = &aBooktitleLB; aListBoxes[7] = &aChapterLB; aListBoxes[8] = &aEditionLB; aListBoxes[9] = &aEditorLB; aListBoxes[10] = &aHowpublishedLB; aListBoxes[11] = &aInstitutionLB; aListBoxes[12] = &aJournalLB; aListBoxes[13] = &aMonthLB; aListBoxes[14] = &aNoteLB; aListBoxes[15] = &aAnnoteLB; aListBoxes[16] = &aNumberLB; aListBoxes[17] = &aOrganizationsLB; aListBoxes[18] = &aPagesLB; aListBoxes[19] = &aPublisherLB; aListBoxes[20] = &aAddressLB; aListBoxes[21] = &aSchoolLB; aListBoxes[22] = &aSeriesLB; aListBoxes[23] = &aReportTypeLB; aListBoxes[24] = &aVolumeLB; aListBoxes[25] = &aURLLB; aListBoxes[26] = &aCustom1LB; aListBoxes[27] = &aCustom2LB; aListBoxes[28] = &aCustom3LB; aListBoxes[29] = &aCustom4LB; aListBoxes[30] = &aCustom5LB; aListBoxes[0]->InsertEntry(sNone); Reference< XNameAccess > xFields = getColumns( pDatMan->getForm() ); DBG_ASSERT(xFields.is(), "MappingDialog_Impl::MappingDialog_Impl : gave me an invalid form !"); if(xFields.is()) { Sequence< ::rtl::OUString > aNames = xFields->getElementNames(); sal_Int32 nFieldsCount = aNames.getLength(); const ::rtl::OUString* pNames = aNames.getConstArray(); for(sal_Int32 nField = 0; nField < nFieldsCount; nField++) aListBoxes[0]->InsertEntry(pNames[nField]); } Link aLnk = LINK(this, MappingDialog_Impl, ListBoxSelectHdl); aListBoxes[0]->SelectEntryPos(0); aListBoxes[0]->SetSelectHdl(aLnk); for(sal_uInt16 i = 1; i < COLUMN_COUNT; i++) { for(sal_uInt16 j = 0; j < aListBoxes[0]->GetEntryCount();j++) aListBoxes[i]->InsertEntry(aListBoxes[0]->GetEntry(j)); aListBoxes[i]->SelectEntryPos(0); aListBoxes[i]->SetSelectHdl(aLnk); } BibConfig* pConfig = BibModul::GetConfig(); BibDBDescriptor aDesc; aDesc.sDataSource = pDatMan->getActiveDataSource(); aDesc.sTableOrQuery = pDatMan->getActiveDataTable(); aDesc.nCommandType = CommandType::TABLE; const Mapping* pMapping = pConfig->GetMapping(aDesc); if(pMapping) { for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++) { sal_uInt16 nListBoxIndex = lcl_FindLogicalName( pConfig, pMapping->aColumnPairs[nEntry].sLogicalColumnName); if(nListBoxIndex < COLUMN_COUNT) { aListBoxes[nListBoxIndex]->SelectEntry(pMapping->aColumnPairs[nEntry].sRealColumnName); } } } } /* -----------------11.11.99 16:44------------------- --------------------------------------------------*/ MappingDialog_Impl::~MappingDialog_Impl() {} /* -----------------15.11.99 10:38------------------- --------------------------------------------------*/ IMPL_LINK(MappingDialog_Impl, ListBoxSelectHdl, ListBox*, pListBox) { sal_uInt16 nEntryPos = pListBox->GetSelectEntryPos(); if(0 < nEntryPos) { for(sal_uInt16 i = 0; i < COLUMN_COUNT; i++) { if(pListBox != aListBoxes[i] && aListBoxes[i]->GetSelectEntryPos() == nEntryPos) aListBoxes[i]->SelectEntryPos(0); } } SetModified(); return 0; } /* -----------------12.11.99 14:50------------------- --------------------------------------------------*/ IMPL_LINK(MappingDialog_Impl, OkHdl, OKButton*, EMPTYARG) { if(bModified) { Mapping aNew; aNew.sTableName = String(pDatMan->getActiveDataTable()); aNew.sURL = String(pDatMan->getActiveDataSource()); sal_uInt16 nWriteIndex = 0; BibConfig* pConfig = BibModul::GetConfig(); for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++) { String sSel = aListBoxes[nEntry]->GetSelectEntry(); if(sSel != sNone) { aNew.aColumnPairs[nWriteIndex].sRealColumnName = sSel; aNew.aColumnPairs[nWriteIndex].sLogicalColumnName = pConfig->GetDefColumnName(nEntry); nWriteIndex++; } } BibDBDescriptor aDesc; aDesc.sDataSource = pDatMan->getActiveDataSource(); aDesc.sTableOrQuery = pDatMan->getActiveDataTable(); aDesc.nCommandType = CommandType::TABLE; pDatMan->ResetIdentifierMapping(); pConfig->SetMapping(aDesc, &aNew); } EndDialog(bModified ? RET_OK : RET_CANCEL); return 0; } /* -----------------18.11.99 10:23------------------- --------------------------------------------------*/ class DBChangeDialog_Impl : public ModalDialog { OKButton aOKBT; CancelButton aCancelBT; HelpButton aHelpBT; FixedLine aSelectionGB; SvTabListBox aSelectionLB; HeaderBar aSelectionHB; DBChangeDialogConfig_Impl aConfig; String aEntryST; String aURLST; BibDataManager* pDatMan; // DECL_LINK(EndDragHdl, HeaderBar*); DECL_LINK(DoubleClickHdl, SvTabListBox*); public: DBChangeDialog_Impl(Window* pParent, BibDataManager* pMan ); ~DBChangeDialog_Impl(); String GetCurrentURL()const; }; /*-- 18.11.99 10:35:20--------------------------------------------------- -----------------------------------------------------------------------*/ DBChangeDialog_Impl::DBChangeDialog_Impl(Window* pParent, BibDataManager* pMan ) : ModalDialog(pParent, BibResId(RID_DLG_DBCHANGE) ), aOKBT(this, BibResId( BT_OK )), aCancelBT(this, BibResId( BT_CANCEL )), aHelpBT(this, BibResId( BT_HELP )), aSelectionGB(this, BibResId( GB_SELECTION )), aSelectionLB(this, BibResId( LB_SELECTION )), aSelectionHB(this, BibResId( HB_SELECTION )), aEntryST(BibResId(ST_ENTRY)), aURLST( BibResId(ST_URL)), pDatMan(pMan) { FreeResource(); aSelectionLB.SetDoubleClickHdl( LINK(this, DBChangeDialog_Impl, DoubleClickHdl)); try { Reference< XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory(); ::Size aSize = aSelectionHB.GetSizePixel(); long nTabs[2]; nTabs[0] = 1;// Number of Tabs nTabs[1] = aSize.Width() / 4; aSelectionHB.SetStyle(aSelectionHB.GetStyle()|WB_STDHEADERBAR); aSelectionHB.InsertItem( 1, aEntryST, aSize.Width()); aSelectionHB.SetSizePixel(aSelectionHB.CalcWindowSizePixel()); aSelectionHB.Show(); aSelectionLB.SetTabs( &nTabs[0], MAP_PIXEL ); aSelectionLB.SetWindowBits(WB_CLIPCHILDREN|WB_SORT); aSelectionLB.GetModel()->SetSortMode(SortAscending); ::rtl::OUString sActiveSource = pDatMan->getActiveDataSource(); const Sequence< ::rtl::OUString >& rSources = aConfig.GetDataSourceNames(); const ::rtl::OUString* pSourceNames = rSources.getConstArray(); for(int i = 0; i < rSources.getLength(); i++) { SvLBoxEntry* pEntry = aSelectionLB.InsertEntry(pSourceNames[i]); if(pSourceNames[i] == sActiveSource) { aSelectionLB.Select(pEntry); } } aSelectionLB.GetModel()->Resort(); } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("Exception in BibDataManager::DBChangeDialog_Impl::DBChangeDialog_Impl"); } } /* -----------------06.12.99 12:09------------------- --------------------------------------------------*/ IMPL_LINK(DBChangeDialog_Impl, DoubleClickHdl, SvTabListBox*, /*pLB*/) { EndDialog(RET_OK); return 0; } /* -----------------18.11.99 11:17------------------- --------------------------------------------------*/ /*IMPL_LINK(DBChangeDialog_Impl, EndDragHdl, HeaderBar*, pHB) { long nTabs[3]; nTabs[0] = 2;// Number of Tabs nTabs[1] = 0; nTabs[2] = pHB->GetItemSize( 1 ); aSelectionLB.SetTabs( &nTabs[0], MAP_PIXEL ); return 0; };*/ /*-- 18.11.99 10:35:20--------------------------------------------------- -----------------------------------------------------------------------*/ DBChangeDialog_Impl::~DBChangeDialog_Impl() { } /* -----------------18.11.99 12:36------------------- --------------------------------------------------*/ String DBChangeDialog_Impl::GetCurrentURL()const { String sRet; SvLBoxEntry* pEntry = aSelectionLB.FirstSelected(); if(pEntry) { sRet = aSelectionLB.GetEntryText(pEntry, 0); } return sRet; } // #100312# -------------------------------------------------------------------- // XDispatchProvider BibInterceptorHelper::BibInterceptorHelper( ::bib::BibBeamer* pBibBeamer, ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > xDispatch) { if( pBibBeamer ) { xInterception = pBibBeamer->getDispatchProviderInterception(); if( xInterception.is() ) xInterception->registerDispatchProviderInterceptor( this ); } if( xDispatch.is() ) xFormDispatch = xDispatch; } BibInterceptorHelper::~BibInterceptorHelper( ) { } void BibInterceptorHelper::ReleaseInterceptor() { if ( xInterception.is() ) xInterception->releaseDispatchProviderInterceptor( this ); xInterception.clear(); } ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > SAL_CALL BibInterceptorHelper::queryDispatch( const ::com::sun::star::util::URL& aURL, const ::rtl::OUString& aTargetFrameName, sal_Int32 nSearchFlags ) throw (::com::sun::star::uno::RuntimeException) { Reference< XDispatch > xReturn; String aCommand( aURL.Path ); if ( aCommand.EqualsAscii("FormSlots/ConfirmDeletion") ) xReturn = xFormDispatch; else if ( xSlaveDispatchProvider.is() ) xReturn = xSlaveDispatchProvider->queryDispatch( aURL, aTargetFrameName, nSearchFlags); return xReturn; } ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > > SAL_CALL BibInterceptorHelper::queryDispatches( const ::com::sun::star::uno::Sequence< ::com::sun::star::frame::DispatchDescriptor >& aDescripts ) throw (::com::sun::star::uno::RuntimeException) { Sequence< Reference< XDispatch> > aReturn( aDescripts.getLength() ); Reference< XDispatch >* pReturn = aReturn.getArray(); const DispatchDescriptor* pDescripts = aDescripts.getConstArray(); for ( sal_Int16 i=0; iFeatureURL, pDescripts->FrameName, pDescripts->SearchFlags ); } return aReturn; } // XDispatchProviderInterceptor ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > SAL_CALL BibInterceptorHelper::getSlaveDispatchProvider( ) throw (::com::sun::star::uno::RuntimeException) { return xSlaveDispatchProvider; } void SAL_CALL BibInterceptorHelper::setSlaveDispatchProvider( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider >& xNewSlaveDispatchProvider ) throw (::com::sun::star::uno::RuntimeException) { xSlaveDispatchProvider = xNewSlaveDispatchProvider; } ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider > SAL_CALL BibInterceptorHelper::getMasterDispatchProvider( ) throw (::com::sun::star::uno::RuntimeException) { return xMasterDispatchProvider; } void SAL_CALL BibInterceptorHelper::setMasterDispatchProvider( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider >& xNewMasterDispatchProvider ) throw (::com::sun::star::uno::RuntimeException) { xMasterDispatchProvider = xNewMasterDispatchProvider; } //----------------------------------------------------------------------------- #define STR_UID "uid" ::rtl::OUString gGridName(C2U("theGrid")); ::rtl::OUString gViewName(C2U("theView")); ::rtl::OUString gGlobalName(C2U("theGlobals")); ::rtl::OUString gBeamerSize(C2U("theBeamerSize")); ::rtl::OUString gViewSize(C2U("theViewSize")); BibDataManager::BibDataManager() :BibDataManager_Base( GetMutex() ) // #100312# -------------- ,m_pInterceptorHelper( NULL ) ,m_aLoadListeners(m_aMutex) ,pBibView( NULL ) ,pToolbar(0) { } /* -------------------------------------------------- --------------------------------------------------*/ BibDataManager::~BibDataManager() { Reference< XLoadable > xLoad( m_xForm, UNO_QUERY ); Reference< XPropertySet > xPrSet( m_xForm, UNO_QUERY ); Reference< XComponent > xComp( m_xForm, UNO_QUERY ); if ( m_xForm.is() ) { Reference< XComponent > xConnection; xPrSet->getPropertyValue(C2U("ActiveConnection")) >>= xConnection; RemoveMeAsUidListener(); if (xLoad.is()) xLoad->unload(); if (xComp.is()) xComp->dispose(); if(xConnection.is()) xConnection->dispose(); m_xForm = NULL; } // #100312# ---------------- if( m_pInterceptorHelper ) { m_pInterceptorHelper->ReleaseInterceptor(); m_pInterceptorHelper->release(); m_pInterceptorHelper = NULL; } } //------------------------------------------------------------------------ void BibDataManager::InsertFields(const Reference< XFormComponent > & _rxGrid) { if ( !_rxGrid.is() ) return; try { Reference< XNameContainer > xColContainer( _rxGrid, UNO_QUERY ); // remove the old fields if ( xColContainer->hasElements() ) { Sequence< ::rtl::OUString > aNames = xColContainer->getElementNames(); const ::rtl::OUString* pNames = aNames.getConstArray(); const ::rtl::OUString* pNamesEnd = pNames + aNames.getLength(); for ( ; pNames != pNamesEnd; ++pNames ) xColContainer->removeByName( *pNames ); } Reference< XNameAccess > xFields = getColumns( m_xForm ); if (!xFields.is()) return; Reference< XGridColumnFactory > xColFactory( _rxGrid, UNO_QUERY ); Reference< XPropertySet > xField; Sequence< ::rtl::OUString > aFields( xFields->getElementNames() ); const ::rtl::OUString* pFields = aFields.getConstArray(); const ::rtl::OUString* pFieldsEnd = pFields + aFields.getLength(); for ( ; pFields != pFieldsEnd; ++pFields ) { xFields->getByName( *pFields ) >>= xField; ::rtl::OUString sCurrentModelType; const ::rtl::OUString sType(C2U("Type")); sal_Int32 nType = 0; sal_Bool bIsFormatted = sal_False; sal_Bool bFormattedIsNumeric = sal_True; xField->getPropertyValue(sType) >>= nType; switch(nType) { case DataType::BIT: case DataType::BOOLEAN: sCurrentModelType = C2U("CheckBox"); break; case DataType::BINARY: case DataType::VARBINARY: case DataType::LONGVARBINARY: case DataType::BLOB: sCurrentModelType = C2U("TextField"); break; case DataType::VARCHAR: case DataType::LONGVARCHAR: case DataType::CHAR: case DataType::CLOB: bFormattedIsNumeric = sal_False; // _NO_ break ! default: sCurrentModelType = C2U("FormattedField"); bIsFormatted = sal_True; break; } Reference< XPropertySet > xCurrentCol = xColFactory->createColumn(sCurrentModelType); if (bIsFormatted) { ::rtl::OUString sFormatKey(C2U("FormatKey")); xCurrentCol->setPropertyValue(sFormatKey, xField->getPropertyValue(sFormatKey)); Any aFormatted(&bFormattedIsNumeric, ::getBooleanCppuType()); xCurrentCol->setPropertyValue(C2U("TreatAsNumber"), aFormatted); } Any aColName = makeAny( *pFields ); xCurrentCol->setPropertyValue(FM_PROP_CONTROLSOURCE, aColName); xCurrentCol->setPropertyValue(FM_PROP_LABEL, aColName); xColContainer->insertByName( *pFields, makeAny( xCurrentCol ) ); } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("Exception in BibDataManager::InsertFields"); } } /* -------------------------------------------------- --------------------------------------------------*/ Reference< awt::XControlModel > BibDataManager::updateGridModel() { return updateGridModel( m_xForm ); } /* -------------------------------------------------- --------------------------------------------------*/ Reference< awt::XControlModel > BibDataManager::updateGridModel(const Reference< XForm > & xDbForm) { try { Reference< XPropertySet > aFormPropSet( xDbForm, UNO_QUERY ); ::rtl::OUString sName; aFormPropSet->getPropertyValue(C2U("Command")) >>= sName; if ( !m_xGridModel.is() ) { m_xGridModel = createGridModel( gGridName ); Reference< XNameContainer > xNameCont(xDbForm, UNO_QUERY); // if (xNameCont->hasByName(sName)) // xNameCont->removeByName(sName); // xNameCont->insertByName( sName, makeAny( m_xGridModel ) ); } // insert the fields Reference< XFormComponent > xFormComp( m_xGridModel, UNO_QUERY ); InsertFields( xFormComp ); } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("::updateGridModel: something went wrong !"); } return m_xGridModel; } /* -------------------------------------------------- --------------------------------------------------*/ Reference< XForm > BibDataManager::createDatabaseForm(BibDBDescriptor& rDesc) { Reference< XForm > xResult; try { Reference< XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory(); m_xForm = Reference< XForm > ( xMgr->createInstance( C2U("com.sun.star.form.component.Form") ), UNO_QUERY ); Reference< XPropertySet > aPropertySet( m_xForm, UNO_QUERY ); aDataSourceURL = rDesc.sDataSource; if(aPropertySet.is()) { Any aVal; aVal <<= (sal_Int32)ResultSetType::SCROLL_INSENSITIVE; aPropertySet->setPropertyValue(C2U("ResultSetType"),aVal ); aVal <<= (sal_Int32)ResultSetConcurrency::READ_ONLY; aPropertySet->setPropertyValue(C2U("ResultSetConcurrency"), aVal); //Caching for Performance aVal <<= (sal_Int32)50; aPropertySet->setPropertyValue(C2U("FetchSize"), aVal); Reference< XConnection > xConnection = getConnection(rDesc.sDataSource); aVal <<= xConnection; aPropertySet->setPropertyValue(C2U("ActiveConnection"), aVal); Reference< XTablesSupplier > xSupplyTables(xConnection, UNO_QUERY); Reference< XNameAccess > xTables = xSupplyTables.is() ? xSupplyTables->getTables() : Reference< XNameAccess > (); Sequence< ::rtl::OUString > aTableNameSeq; if (xTables.is()) aTableNameSeq = xTables->getElementNames(); if(aTableNameSeq.getLength() > 0) { const ::rtl::OUString* pTableNames = aTableNameSeq.getConstArray(); if(rDesc.sTableOrQuery.getLength()) aActiveDataTable = rDesc.sTableOrQuery; else { rDesc.sTableOrQuery = aActiveDataTable = pTableNames[0]; rDesc.nCommandType = CommandType::TABLE; } aVal <<= aActiveDataTable; aPropertySet->setPropertyValue(C2U("Command"), aVal); aVal <<= rDesc.nCommandType; aPropertySet->setPropertyValue(C2U("CommandType"), aVal); Reference< XDatabaseMetaData > xMetaData = xConnection->getMetaData(); aQuoteChar = xMetaData->getIdentifierQuoteString(); Reference< XMultiServiceFactory > xFactory(xConnection, UNO_QUERY); if ( xFactory.is() ) m_xParser.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.SingleSelectQueryComposer" ) ) ), UNO_QUERY ); ::rtl::OUString aString(C2U("SELECT * FROM ")); ::rtl::OUString sCatalog, sSchema, sName; ::dbtools::qualifiedNameComponents( xMetaData, aActiveDataTable, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation ); aString += ::dbtools::composeTableNameForSelect( xConnection, sCatalog, sSchema, sName ); m_xParser->setElementaryQuery(aString); BibConfig* pConfig = BibModul::GetConfig(); pConfig->setQueryField(getQueryField()); startQueryWith(pConfig->getQueryText()); xResult = m_xForm; } } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("::createDatabaseForm: something went wrong !"); } return xResult; } //------------------------------------------------------------------------ Sequence< ::rtl::OUString > BibDataManager::getDataSources() { Sequence< ::rtl::OUString > aTableNameSeq; try { Reference< XTablesSupplier > xSupplyTables( getConnection( m_xForm ), UNO_QUERY ); Reference< XNameAccess > xTables; if (xSupplyTables.is()) xTables = xSupplyTables->getTables(); if (xTables.is()) aTableNameSeq = xTables->getElementNames(); } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("::getDataSources: something went wrong !"); } return aTableNameSeq; } //------------------------------------------------------------------------ ::rtl::OUString BibDataManager::getActiveDataTable() { return aActiveDataTable; } //------------------------------------------------------------------------ void BibDataManager::setFilter(const ::rtl::OUString& rQuery) { if(!m_xParser.is()) return; try { m_xParser->setFilter( rQuery ); ::rtl::OUString aQuery = m_xParser->getFilter(); Reference< XPropertySet > xFormProps( m_xForm, UNO_QUERY_THROW ); xFormProps->setPropertyValue( C2U( "Filter" ), makeAny( aQuery ) ); xFormProps->setPropertyValue( C2U( "ApplyFilter" ), makeAny( sal_True ) ); reload(); } catch(Exception& e ) { DBG_UNHANDLED_EXCEPTION(); } } //------------------------------------------------------------------------ ::rtl::OUString BibDataManager::getFilter() { ::rtl::OUString aQueryString; try { Reference< XPropertySet > xFormProps( m_xForm, UNO_QUERY_THROW ); OSL_VERIFY( xFormProps->getPropertyValue( C2U( "Filter" ) ) >>= aQueryString ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } return aQueryString; } //------------------------------------------------------------------------ Sequence< ::rtl::OUString > BibDataManager::getQueryFields() { Sequence< ::rtl::OUString > aFieldSeq; Reference< XNameAccess > xFields = getColumns( m_xForm ); if (xFields.is()) aFieldSeq = xFields->getElementNames(); return aFieldSeq; } //------------------------------------------------------------------------ ::rtl::OUString BibDataManager::getQueryField() { BibConfig* pConfig = BibModul::GetConfig(); ::rtl::OUString aFieldString = pConfig->getQueryField(); if(!aFieldString.getLength()) { Sequence< ::rtl::OUString > aSeq = getQueryFields(); const ::rtl::OUString* pFields = aSeq.getConstArray(); if(aSeq.getLength()>0) { aFieldString=pFields[0]; } } return aFieldString; } //------------------------------------------------------------------------ void BibDataManager::startQueryWith(const ::rtl::OUString& rQuery) { BibConfig* pConfig = BibModul::GetConfig(); pConfig->setQueryText( rQuery ); ::rtl::OUString aQueryString; if(rQuery.getLength()>0) { aQueryString=aQuoteChar; aQueryString+=getQueryField(); aQueryString+=aQuoteChar; aQueryString+=C2U(" like '"); String sQuery(rQuery); sQuery.SearchAndReplaceAll('?','_'); sQuery.SearchAndReplaceAll('*','%'); aQueryString += sQuery; aQueryString+=C2U("%'"); } setFilter(aQueryString); } /* -----------------03.12.99 15:05------------------- --------------------------------------------------*/ void BibDataManager::setActiveDataSource(const ::rtl::OUString& rURL) { ::rtl::OUString uTable; ::rtl::OUString sTmp(aDataSourceURL); aDataSourceURL = rURL; Reference< XPropertySet > aPropertySet( m_xForm, UNO_QUERY ); if(aPropertySet.is()) { unload(); Reference< XComponent > xOldConnection; aPropertySet->getPropertyValue(C2U("ActiveConnection")) >>= xOldConnection; Reference< XConnection > xConnection = getConnection(rURL); if(!xConnection.is()) { aDataSourceURL = sTmp; return; } Any aVal; aVal <<= xConnection; aPropertySet->setPropertyValue(C2U("ActiveConnection"), aVal); Reference< XMultiServiceFactory > xFactory(xConnection, UNO_QUERY); if ( xFactory.is() ) m_xParser.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.SingleSelectQueryComposer" ) ) ), UNO_QUERY ); if(xOldConnection.is()) xOldConnection->dispose(); Sequence< ::rtl::OUString > aTableNameSeq; Reference< XTablesSupplier > xSupplyTables(xConnection, UNO_QUERY); if(xSupplyTables.is()) { Reference< XNameAccess > xAccess = xSupplyTables->getTables(); aTableNameSeq = xAccess->getElementNames(); } if(aTableNameSeq.getLength() > 0) { const ::rtl::OUString* pTableNames = aTableNameSeq.getConstArray(); aActiveDataTable = pTableNames[0]; aVal <<= aActiveDataTable; aPropertySet->setPropertyValue(C2U("Command"), aVal); aPropertySet->setPropertyValue(C2U("CommandType"), makeAny(CommandType::TABLE)); //Caching for Performance aVal <<= (sal_Int32)50; aPropertySet->setPropertyValue(C2U("FetchSize"), aVal); ::rtl::OUString aString(C2U("SELECT * FROM ")); // quote the table name which may contain catalog.schema.table Reference xMetaData(xConnection->getMetaData(),UNO_QUERY); aQuoteChar = xMetaData->getIdentifierQuoteString(); ::rtl::OUString sCatalog, sSchema, sName; ::dbtools::qualifiedNameComponents( xMetaData, aActiveDataTable, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation ); aString += ::dbtools::composeTableNameForSelect( xConnection, sCatalog, sSchema, sName ); m_xParser->setElementaryQuery(aString); BibConfig* pConfig = BibModul::GetConfig(); pConfig->setQueryField(getQueryField()); startQueryWith(pConfig->getQueryText()); setActiveDataTable(aActiveDataTable); } FeatureStateEvent aEvent; util::URL aURL; aEvent.IsEnabled = sal_True; aEvent.Requery = sal_False; aEvent.FeatureDescriptor = getActiveDataTable(); aEvent.State = makeAny( getDataSources() ); if(pToolbar) { aURL.Complete =C2U(".uno:Bib/source"); aEvent.FeatureURL = aURL; pToolbar->statusChanged( aEvent ); } updateGridModel(); load(); } } /* -------------------------------------------------- --------------------------------------------------*/ void BibDataManager::setActiveDataTable(const ::rtl::OUString& rTable) { ResetIdentifierMapping(); try { Reference< XPropertySet > aPropertySet( m_xForm, UNO_QUERY ); if(aPropertySet.is()) { Reference< XConnection > xConnection = getConnection( m_xForm ); Reference< XTablesSupplier > xSupplyTables(xConnection, UNO_QUERY); Reference< XNameAccess > xAccess = xSupplyTables->getTables(); Sequence< ::rtl::OUString > aTableNameSeq = xAccess->getElementNames(); sal_uInt32 nCount = aTableNameSeq.getLength(); const ::rtl::OUString* pTableNames = aTableNameSeq.getConstArray(); const ::rtl::OUString* pTableNamesEnd = pTableNames + nCount; for ( ; pTableNames != pTableNamesEnd; ++pTableNames ) { if ( rTable == *pTableNames ) { aActiveDataTable = rTable; Any aVal; aVal <<= rTable; aPropertySet->setPropertyValue( C2U("Command"), aVal ); break; } } if (pTableNames != pTableNamesEnd) { Reference< XDatabaseMetaData > xMetaData = xConnection->getMetaData(); aQuoteChar = xMetaData->getIdentifierQuoteString(); Reference< XMultiServiceFactory > xFactory(xConnection, UNO_QUERY); if ( xFactory.is() ) m_xParser.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.SingleSelectQueryComposer" ) ) ), UNO_QUERY ); ::rtl::OUString aString(C2U("SELECT * FROM ")); ::rtl::OUString sCatalog, sSchema, sName; ::dbtools::qualifiedNameComponents( xMetaData, aActiveDataTable, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation ); aString += ::dbtools::composeTableNameForSelect( xConnection, sCatalog, sSchema, sName ); m_xParser->setElementaryQuery(aString); BibConfig* pConfig = BibModul::GetConfig(); pConfig->setQueryField(getQueryField()); startQueryWith(pConfig->getQueryText()); BibDBDescriptor aDesc; aDesc.sDataSource = aDataSourceURL; aDesc.sTableOrQuery = aActiveDataTable; aDesc.nCommandType = CommandType::TABLE; BibModul::GetConfig()->SetBibliographyURL(aDesc); } } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("::setActiveDataTable: something went wrong !"); } } //------------------------------------------------------------------------ void SAL_CALL BibDataManager::load( ) throw (RuntimeException) { if ( isLoaded() ) // nothing to do return; Reference< XLoadable > xFormAsLoadable( m_xForm, UNO_QUERY ); DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::load: invalid form!"); if ( xFormAsLoadable.is() ) { xFormAsLoadable->load(); SetMeAsUidListener(); EventObject aEvt( static_cast< XWeak* >( this ) ); m_aLoadListeners.notifyEach( &XLoadListener::loaded, aEvt ); } } //------------------------------------------------------------------------ void SAL_CALL BibDataManager::unload( ) throw (RuntimeException) { if ( !isLoaded() ) // nothing to do return; Reference< XLoadable >xFormAsLoadable( m_xForm, UNO_QUERY ); DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::unload: invalid form!"); if ( xFormAsLoadable.is() ) { EventObject aEvt( static_cast< XWeak* >( this ) ); { m_aLoadListeners.notifyEach( &XLoadListener::unloading, aEvt ); } RemoveMeAsUidListener(); xFormAsLoadable->unload(); { m_aLoadListeners.notifyEach( &XLoadListener::unloaded, aEvt ); } } } //------------------------------------------------------------------------ void SAL_CALL BibDataManager::reload( ) throw (RuntimeException) { if ( !isLoaded() ) // nothing to do return; Reference< XLoadable >xFormAsLoadable( m_xForm, UNO_QUERY ); DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::unload: invalid form!"); if ( xFormAsLoadable.is() ) { EventObject aEvt( static_cast< XWeak* >( this ) ); { m_aLoadListeners.notifyEach( &XLoadListener::reloading, aEvt ); } xFormAsLoadable->reload(); { m_aLoadListeners.notifyEach( &XLoadListener::reloaded, aEvt ); } } } //------------------------------------------------------------------------ sal_Bool SAL_CALL BibDataManager::isLoaded( ) throw (RuntimeException) { Reference< XLoadable >xFormAsLoadable( m_xForm, UNO_QUERY ); DBG_ASSERT( xFormAsLoadable.is() || !m_xForm.is(), "BibDataManager::isLoaded: invalid form!"); sal_Bool bLoaded = sal_False; if ( xFormAsLoadable.is() ) bLoaded = xFormAsLoadable->isLoaded(); return bLoaded; } //------------------------------------------------------------------------ void SAL_CALL BibDataManager::addLoadListener( const Reference< XLoadListener >& aListener ) throw (RuntimeException) { m_aLoadListeners.addInterface( aListener ); } //------------------------------------------------------------------------ void SAL_CALL BibDataManager::removeLoadListener( const Reference< XLoadListener >& aListener ) throw (RuntimeException) { m_aLoadListeners.removeInterface( aListener ); } //------------------------------------------------------------------------ Reference< awt::XControlModel > BibDataManager::createGridModel(const ::rtl::OUString& rName) { Reference< awt::XControlModel > xModel; try { // create the control model Reference< XMultiServiceFactory > xMgr = ::comphelper::getProcessServiceFactory(); Reference< XInterface > xObject = xMgr->createInstance(C2U("com.sun.star.form.component.GridControl")); xModel=Reference< awt::XControlModel > ( xObject, UNO_QUERY ); // set the Reference< XPropertySet > xPropSet( xModel, UNO_QUERY ); xPropSet->setPropertyValue( C2U("Name"), makeAny( rName ) ); // set the name of the to-be-created control ::rtl::OUString aControlName(C2U("com.sun.star.form.control.InteractionGridControl")); Any aAny; aAny <<= aControlName; xPropSet->setPropertyValue( C2U("DefaultControl"),aAny ); // the the helpURL ::rtl::OUString uProp(C2U("HelpURL")); Reference< XPropertySetInfo > xPropInfo = xPropSet->getPropertySetInfo(); if (xPropInfo->hasPropertyByName(uProp)) { ::rtl::OUString sId = ::rtl::OUString::createFromAscii( "HID:" ); sId += ::rtl::OUString::createFromAscii( HID_BIB_DB_GRIDCTRL ); xPropSet->setPropertyValue( uProp, makeAny( sId ) ); } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("::createGridModel: something went wrong !"); } return xModel; } //------------------------------------------------------------------------ ::rtl::OUString BibDataManager::getControlName(sal_Int32 nFormatKey ) { ::rtl::OUString aResStr; switch (nFormatKey) { case DataType::BIT: case DataType::BOOLEAN: aResStr=C2U("CheckBox"); break; case DataType::TINYINT: case DataType::SMALLINT: case DataType::INTEGER: aResStr=C2U("NumericField"); ; break; case DataType::REAL: case DataType::DOUBLE: case DataType::NUMERIC: case DataType::DECIMAL: aResStr=C2U("FormattedField"); break; case DataType::TIMESTAMP: aResStr=C2U("FormattedField"); break; case DataType::DATE: aResStr=C2U("DateField"); break; case DataType::TIME: aResStr=C2U("TimeField"); break; case DataType::CHAR: case DataType::VARCHAR: case DataType::LONGVARCHAR: default: aResStr=C2U("TextField"); break; } return aResStr; } //------------------------------------------------------------------------ Reference< awt::XControlModel > BibDataManager::loadControlModel( const ::rtl::OUString& rName, sal_Bool bForceListBox) { Reference< awt::XControlModel > xModel; ::rtl::OUString aName(C2U("View_")); aName += rName; try { Reference< XNameAccess > xFields = getColumns( m_xForm ); if (!xFields.is()) return xModel; Reference< XPropertySet > xField; Any aElement; if(xFields->hasByName(rName)) { aElement = xFields->getByName(rName); aElement >>= xField; Reference< XPropertySetInfo > xInfo = xField.is() ? xField->getPropertySetInfo() : Reference< XPropertySetInfo > (); ::rtl::OUString sCurrentModelType; const ::rtl::OUString sType(C2U("Type")); sal_Int32 nFormatKey = 0; xField->getPropertyValue(sType) >>= nFormatKey; ::rtl::OUString aInstanceName(C2U("com.sun.star.form.component.")); if (bForceListBox) aInstanceName += C2U("ListBox"); else aInstanceName += getControlName(nFormatKey); Reference< XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory(); Reference< XInterface > xObject = xMgr->createInstance(aInstanceName); xModel=Reference< awt::XControlModel > ( xObject, UNO_QUERY ); Reference< XPropertySet > xPropSet( xModel, UNO_QUERY ); Any aFieldName; aFieldName <<= aName; xPropSet->setPropertyValue( FM_PROP_NAME,aFieldName); xPropSet->setPropertyValue( FM_PROP_CONTROLSOURCE, makeAny( rName ) ); xPropSet->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "NativeWidgetLook" ) ), makeAny( (sal_Bool)sal_True ) ); Reference< XFormComponent > aFormComp(xModel,UNO_QUERY ); Reference< XNameContainer > xNameCont( m_xForm, UNO_QUERY ); xNameCont->insertByName(aName, makeAny( aFormComp ) ); // now if the form where we inserted the new model is already loaded, notify the model of this // Note that this implementation below is a HACK as it relies on the fact that the model adds itself // as load listener to it's parent, which is an implementation detail of the model. // // the better solution would be the following: // in the current scenario, we insert a control model into a form. This results in the control model // adding itself as load listener to the form. Now, the form should realize that it's already loaded // and notify the model (which it knows as XLoadListener only) immediately. This seems to make sense. // (as an anologon to the XStatusListener semantics). // // But this would be way too risky for this last-day fix here. // 97140 - 30.01.2002 - fs@openoffice.org Reference< XLoadable > xLoad( m_xForm, UNO_QUERY ); if ( xLoad.is() && xLoad->isLoaded() ) { Reference< XLoadListener > xListener( aFormComp, UNO_QUERY ); if ( xListener.is() ) { EventObject aLoadSource; aLoadSource.Source = xLoad; xListener->loaded( aLoadSource ); } } } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("::loadControlModel: something went wrong !"); } return xModel; } //------------------------------------------------------------------------ void SAL_CALL BibDataManager::disposing() { BibDataManager_Base::WeakComponentImplHelperBase::disposing(); } //------------------------------------------------------------------------ void BibDataManager::disposing( const EventObject& /*Source*/ ) throw( ::com::sun::star::uno::RuntimeException ) { // not interested in } //------------------------------------------------------------------------ void BibDataManager::propertyChange(const beans::PropertyChangeEvent& evt) throw( RuntimeException ) { try { sal_Bool bFlag=sal_False; if(evt.PropertyName == FM_PROP_VALUE) { if( evt.NewValue.getValueType() == ::getCppuType((Reference*)0) ) { Reference< io::XDataInputStream > xStream( *(const Reference< io::XInputStream > *)evt.NewValue.getValue(), UNO_QUERY ); aUID <<= xStream->readUTF(); } else aUID = evt.NewValue; Reference< XRowLocate > xLocate(xBibCursor, UNO_QUERY); DBG_ASSERT(xLocate.is(), "BibDataManager::propertyChange : invalid cursor !"); bFlag = xLocate->moveToBookmark(aUID); } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("::propertyChange: something went wrong !"); } } //------------------------------------------------------------------------ void BibDataManager::SetMeAsUidListener() { try { Reference< XNameAccess > xFields = getColumns( m_xForm ); if (!xFields.is()) return; Sequence< ::rtl::OUString > aFields(xFields->getElementNames()); const ::rtl::OUString* pFields = aFields.getConstArray(); sal_Int32 nCount=aFields.getLength(); String StrUID(C2S(STR_UID)); ::rtl::OUString theFieldName; for( sal_Int32 i=0; i0) { Reference< XPropertySet > xPropSet; Any aElement; aElement = xFields->getByName(theFieldName); xPropSet = *(Reference< XPropertySet > *)aElement.getValue(); xPropSet->addPropertyChangeListener(FM_PROP_VALUE, this); } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("Exception in BibDataManager::SetMeAsUidListener"); } } //------------------------------------------------------------------------ void BibDataManager::RemoveMeAsUidListener() { try { Reference< XNameAccess > xFields = getColumns( m_xForm ); if (!xFields.is()) return; Sequence< ::rtl::OUString > aFields(xFields->getElementNames()); const ::rtl::OUString* pFields = aFields.getConstArray(); sal_Int32 nCount=aFields.getLength(); String StrUID(C2S(STR_UID)); ::rtl::OUString theFieldName; for( sal_Int32 i=0; i0) { Reference< XPropertySet > xPropSet; Any aElement; aElement = xFields->getByName(theFieldName); xPropSet = *(Reference< XPropertySet > *)aElement.getValue(); xPropSet->removePropertyChangeListener(FM_PROP_VALUE, this); } } catch(Exception& e ) { (void) e; // make compiler happy DBG_ERROR("Exception in BibDataManager::RemoveMeAsUidListener"); } } /* -----------------11.11.99 15:51------------------- --------------------------------------------------*/ void BibDataManager::CreateMappingDialog(Window* pParent) { MappingDialog_Impl* pDlg = new MappingDialog_Impl(pParent, this); if(RET_OK == pDlg->Execute() && pBibView) { reload(); // unload(); // pBibView->UpdatePages(); // load(); } delete pDlg; } /* -------------------------------------------------- --------------------------------------------------*/ ::rtl::OUString BibDataManager::CreateDBChangeDialog(Window* pParent) { ::rtl::OUString uRet; DBChangeDialog_Impl * pDlg = new DBChangeDialog_Impl(pParent, this ); if(RET_OK == pDlg->Execute()) { String sNewURL = pDlg->GetCurrentURL(); if(sNewURL != String(getActiveDataSource())) { uRet = sNewURL; } } delete pDlg; return uRet; } /*-- 18.05.2004 15:20:15--------------------------------------------------- -----------------------------------------------------------------------*/ void BibDataManager::DispatchDBChangeDialog() { if(pToolbar) pToolbar->SendDispatch(TBC_BT_CHANGESOURCE, Sequence< PropertyValue >()); } /* -----------------06.12.99 15:11------------------- --------------------------------------------------*/ const ::rtl::OUString& BibDataManager::GetIdentifierMapping() { if(!sIdentifierMapping.getLength()) { BibConfig* pConfig = BibModul::GetConfig(); BibDBDescriptor aDesc; aDesc.sDataSource = getActiveDataSource(); aDesc.sTableOrQuery = getActiveDataTable(); aDesc.nCommandType = CommandType::TABLE; const Mapping* pMapping = pConfig->GetMapping(aDesc); sIdentifierMapping = pConfig->GetDefColumnName(IDENTIFIER_POS); if(pMapping) { for(sal_uInt16 nEntry = 0; nEntry < COLUMN_COUNT; nEntry++) { if(pMapping->aColumnPairs[nEntry].sLogicalColumnName == sIdentifierMapping) { sIdentifierMapping = pMapping->aColumnPairs[nEntry].sRealColumnName; break; } } } } return sIdentifierMapping; } /* -----------------------------20.11.00 10:31-------------------------------- ---------------------------------------------------------------------------*/ void BibDataManager::SetToolbar(BibToolBar* pSet) { pToolbar = pSet; if(pToolbar) pToolbar->SetDatMan(*this); } /* -----------------------------08.05.2002 09:26------------------------------ ---------------------------------------------------------------------------*/ uno::Reference< form::runtime::XFormController > BibDataManager::GetFormController() { if(!m_xFormCtrl.is()) { Reference< lang::XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory(); m_xFormCtrl = uno::Reference< form::runtime::XFormController > ( xMgr->createInstance(C2U("com.sun.star.form.runtime.FormController")), UNO_QUERY); m_xFormCtrl->setModel(uno::Reference< awt::XTabControllerModel > (getForm(), UNO_QUERY)); // #100312# ------------- m_xFormDispatch = uno::Reference< frame::XDispatch > ( m_xFormCtrl, UNO_QUERY); } return m_xFormCtrl; } // #100312# ---------- void BibDataManager::RegisterInterceptor( ::bib::BibBeamer* pBibBeamer) { DBG_ASSERT( !m_pInterceptorHelper, "BibDataManager::RegisterInterceptor: called twice!" ); if( pBibBeamer ) m_pInterceptorHelper = new BibInterceptorHelper( pBibBeamer, m_xFormDispatch); if( m_pInterceptorHelper ) m_pInterceptorHelper->acquire(); } /*-- 18.05.2004 17:04:20--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool BibDataManager::HasActiveConnection()const { sal_Bool bRet = sal_False; Reference< XPropertySet > xPrSet( m_xForm, UNO_QUERY ); if( xPrSet.is() ) { Reference< XComponent > xConnection; xPrSet->getPropertyValue(C2U("ActiveConnection")) >>= xConnection; bRet = xConnection.is(); } return bRet; } /*-- 04.06.2004 14:37:29--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool BibDataManager::HasActiveConnection() { return getConnection( m_xForm ).is(); }