| /************************************************************** | |
| * | |
| * 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_dbui.hxx" | |
| #include <iterator> | |
| #include "dbu_reghelper.hxx" | |
| #include <sfx2/sfxsids.hrc> | |
| #include "dbu_rel.hrc" | |
| #include <vcl/svapp.hxx> | |
| #include "browserids.hxx" | |
| #include <comphelper/types.hxx> | |
| #include "dbustrings.hrc" | |
| #include <connectivity/dbtools.hxx> | |
| #include <com/sun/star/frame/FrameSearchFlag.hpp> | |
| #include <comphelper/extract.hxx> | |
| #include <com/sun/star/container/XChild.hpp> | |
| #include <com/sun/star/container/XNameContainer.hpp> | |
| #include <com/sun/star/sdbcx/XDataDescriptorFactory.hpp> | |
| #include <com/sun/star/sdbcx/XTablesSupplier.hpp> | |
| #include <com/sun/star/sdbcx/KeyType.hpp> | |
| #include <com/sun/star/sdbcx/XDrop.hpp> | |
| #include <com/sun/star/sdbcx/XAlterTable.hpp> | |
| #include <com/sun/star/sdbcx/XAppend.hpp> | |
| #include <com/sun/star/sdbcx/XKeysSupplier.hpp> | |
| #include <com/sun/star/sdbcx/XColumnsSupplier.hpp> | |
| #include <com/sun/star/sdb/SQLContext.hpp> | |
| #include <com/sun/star/sdbc/SQLWarning.hpp> | |
| #include <com/sun/star/sdbc/ColumnValue.hpp> | |
| #include <com/sun/star/sdbc/XRow.hpp> | |
| #include <connectivity/dbexception.hxx> | |
| #include <connectivity/dbmetadata.hxx> | |
| #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> | |
| #include <comphelper/streamsection.hxx> | |
| #include <comphelper/basicio.hxx> | |
| #include <comphelper/seqstream.hxx> | |
| #include <com/sun/star/io/XActiveDataSource.hpp> | |
| #include <com/sun/star/io/XActiveDataSink.hpp> | |
| #include "sqlmessage.hxx" | |
| #include "RelationController.hxx" | |
| #include <vcl/msgbox.hxx> | |
| #include "TableWindowData.hxx" | |
| #include "dbustrings.hrc" | |
| #include "UITools.hxx" | |
| #include "RTableConnectionData.hxx" | |
| #include "RelationTableView.hxx" | |
| #include "RelationDesignView.hxx" | |
| #include <tools/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <vcl/waitobj.hxx> | |
| #include <osl/thread.hxx> | |
| #include <vos/mutex.hxx> | |
| #define MAX_THREADS 10 | |
| extern "C" void SAL_CALL createRegistryInfo_ORelationControl() | |
| { | |
| static ::dbaui::OMultiInstanceAutoRegistration< ::dbaui::ORelationController > aAutoRegistration; | |
| } | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::io; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::frame; | |
| using namespace ::com::sun::star::util; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::sdbcx; | |
| using namespace ::com::sun::star::sdbc; | |
| using namespace ::com::sun::star::sdb; | |
| using namespace ::com::sun::star::ui::dialogs; | |
| using namespace ::com::sun::star::util; | |
| // using namespace ::com::sun::star::sdbcx; | |
| // using namespace ::connectivity; | |
| using namespace ::dbtools; | |
| using namespace ::dbaui; | |
| using namespace ::comphelper; | |
| using namespace ::osl; | |
| //------------------------------------------------------------------------------ | |
| ::rtl::OUString SAL_CALL ORelationController::getImplementationName() | |
| { | |
| return getImplementationName_Static(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| ::rtl::OUString ORelationController::getImplementationName_Static() | |
| { | |
| return ::rtl::OUString::createFromAscii("org.openoffice.comp.dbu.ORelationDesign"); | |
| } | |
| //------------------------------------------------------------------------------ | |
| Sequence< ::rtl::OUString> ORelationController::getSupportedServiceNames_Static(void) | |
| { | |
| Sequence< ::rtl::OUString> aSupported(1); | |
| aSupported.getArray()[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdb.RelationDesign"); | |
| return aSupported; | |
| } | |
| //------------------------------------------------------------------------- | |
| Sequence< ::rtl::OUString> SAL_CALL ORelationController::getSupportedServiceNames() | |
| { | |
| return getSupportedServiceNames_Static(); | |
| } | |
| // ------------------------------------------------------------------------- | |
| Reference< XInterface > SAL_CALL ORelationController::Create(const Reference<XMultiServiceFactory >& _rxFactory) | |
| { | |
| return *(new ORelationController(_rxFactory)); | |
| } | |
| DBG_NAME(ORelationController); | |
| // ----------------------------------------------------------------------------- | |
| ORelationController::ORelationController(const Reference< XMultiServiceFactory >& _rM) | |
| : OJoinController(_rM) | |
| ,m_nThreadEvent(0) | |
| ,m_bRelationsPossible(sal_True) | |
| { | |
| DBG_CTOR(ORelationController,NULL); | |
| InvalidateAll(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| ORelationController::~ORelationController() | |
| { | |
| DBG_DTOR(ORelationController,NULL); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| FeatureState ORelationController::GetState(sal_uInt16 _nId) const | |
| { | |
| FeatureState aReturn; | |
| aReturn.bEnabled = m_bRelationsPossible; | |
| switch (_nId) | |
| { | |
| case SID_RELATION_ADD_RELATION: | |
| aReturn.bEnabled = !m_vTableData.empty() && isConnected() && isEditable(); | |
| aReturn.bChecked = false; | |
| break; | |
| case ID_BROWSER_SAVEDOC: | |
| aReturn.bEnabled = haveDataSource() && impl_isModified(); | |
| break; | |
| default: | |
| aReturn = OJoinController::GetState(_nId); | |
| break; | |
| } | |
| return aReturn; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void ORelationController::Execute(sal_uInt16 _nId, const Sequence< PropertyValue >& aArgs) | |
| { | |
| switch(_nId) | |
| { | |
| case ID_BROWSER_SAVEDOC: | |
| { | |
| OSL_ENSURE(isEditable(),"Slot ID_BROWSER_SAVEDOC should not be enabled!"); | |
| if(!::dbaui::checkDataSourceAvailable(::comphelper::getString(getDataSource()->getPropertyValue(PROPERTY_NAME)),getORB())) | |
| { | |
| String aMessage(ModuleRes(STR_DATASOURCE_DELETED)); | |
| OSQLWarningBox( getView(), aMessage ).Execute(); | |
| } | |
| else | |
| { | |
| // now we save the layout information | |
| // create the output stream | |
| try | |
| { | |
| if ( haveDataSource() && getDataSource()->getPropertySetInfo()->hasPropertyByName(PROPERTY_LAYOUTINFORMATION) ) | |
| { | |
| ::comphelper::NamedValueCollection aWindowsData; | |
| saveTableWindows( aWindowsData ); | |
| getDataSource()->setPropertyValue( PROPERTY_LAYOUTINFORMATION, makeAny( aWindowsData.getPropertyValues() ) ); | |
| setModified(sal_False); | |
| } | |
| } | |
| catch ( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| } | |
| break; | |
| case SID_RELATION_ADD_RELATION: | |
| static_cast<ORelationTableView*>(static_cast<ORelationDesignView*>( getView() )->getTableView())->AddNewRelation(); | |
| break; | |
| default: | |
| OJoinController::Execute(_nId,aArgs); | |
| return; | |
| } | |
| InvalidateFeature(_nId); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void ORelationController::impl_initialize() | |
| { | |
| OJoinController::impl_initialize(); | |
| if( !getSdbMetaData().supportsRelations() ) | |
| {// check if this database supports relations | |
| setEditable(sal_False); | |
| m_bRelationsPossible = sal_False; | |
| { | |
| String sTitle(ModuleRes(STR_RELATIONDESIGN)); | |
| sTitle.Erase(0,3); | |
| OSQLMessageBox aDlg(NULL,sTitle,ModuleRes(STR_RELATIONDESIGN_NOT_AVAILABLE)); | |
| aDlg.Execute(); | |
| } | |
| disconnect(); | |
| throw SQLException(); | |
| } | |
| if(!m_bRelationsPossible) | |
| InvalidateAll(); | |
| // we need a datasource | |
| OSL_ENSURE(haveDataSource(),"ORelationController::initialize: need a datasource!"); | |
| Reference<XTablesSupplier> xSup(getConnection(),UNO_QUERY); | |
| OSL_ENSURE(xSup.is(),"Connection isn't a XTablesSupplier!"); | |
| if(xSup.is()) | |
| m_xTables = xSup->getTables(); | |
| // load the layoutInformation | |
| loadLayoutInformation(); | |
| try | |
| { | |
| loadData(); | |
| if ( !m_nThreadEvent ) | |
| Application::PostUserEvent(LINK(this, ORelationController, OnThreadFinished)); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| ::rtl::OUString ORelationController::getPrivateTitle( ) const | |
| { | |
| ::rtl::OUString sName = getDataSourceName(); | |
| return ::dbaui::getStrippedDatabaseName(getDataSource(),sName); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool ORelationController::Construct(Window* pParent) | |
| { | |
| setView( * new ORelationDesignView( pParent, *this, getORB() ) ); | |
| OJoinController::Construct(pParent); | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| short ORelationController::saveModified() | |
| { | |
| short nSaved = RET_YES; | |
| if(haveDataSource() && isModified()) | |
| { | |
| QueryBox aQry(getView(), ModuleRes(RELATION_DESIGN_SAVEMODIFIED)); | |
| nSaved = aQry.Execute(); | |
| if(nSaved == RET_YES) | |
| Execute(ID_BROWSER_SAVEDOC,Sequence<PropertyValue>()); | |
| } | |
| return nSaved; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void ORelationController::describeSupportedFeatures() | |
| { | |
| OJoinController::describeSupportedFeatures(); | |
| implDescribeSupportedFeature( ".uno:DBAddRelation", SID_RELATION_ADD_RELATION, CommandGroup::EDIT ); | |
| } | |
| namespace | |
| { | |
| class RelationLoader : public ::osl::Thread | |
| { | |
| DECLARE_STL_MAP(::rtl::OUString,::boost::shared_ptr<OTableWindowData>,::comphelper::UStringMixLess,TTableDataHelper); | |
| TTableDataHelper m_aTableData; | |
| TTableConnectionData m_vTableConnectionData; | |
| const Sequence< ::rtl::OUString> m_aTableList; | |
| ORelationController* m_pParent; | |
| const Reference< XDatabaseMetaData> m_xMetaData; | |
| const Reference< XNameAccess > m_xTables; | |
| const sal_Int32 m_nStartIndex; | |
| const sal_Int32 m_nEndIndex; | |
| public: | |
| RelationLoader(ORelationController* _pParent | |
| ,const Reference< XDatabaseMetaData>& _xMetaData | |
| ,const Reference< XNameAccess >& _xTables | |
| ,const Sequence< ::rtl::OUString>& _aTableList | |
| ,const sal_Int32 _nStartIndex | |
| ,const sal_Int32 _nEndIndex) | |
| :m_aTableData(_xMetaData.is() && _xMetaData->supportsMixedCaseQuotedIdentifiers()) | |
| ,m_aTableList(_aTableList) | |
| ,m_pParent(_pParent) | |
| ,m_xMetaData(_xMetaData) | |
| ,m_xTables(_xTables) | |
| ,m_nStartIndex(_nStartIndex) | |
| ,m_nEndIndex(_nEndIndex) | |
| { | |
| } | |
| /// Working method which should be overridden. | |
| virtual void SAL_CALL run(); | |
| virtual void SAL_CALL onTerminated(); | |
| protected: | |
| virtual ~RelationLoader(){} | |
| void loadTableData(const Any& _aTable); | |
| }; | |
| void SAL_CALL RelationLoader::run() | |
| { | |
| const ::rtl::OUString* pIter = m_aTableList.getConstArray() + m_nStartIndex; | |
| for(sal_Int32 i = m_nStartIndex; i < m_nEndIndex;++i,++pIter) | |
| { | |
| ::rtl::OUString sCatalog,sSchema,sTable; | |
| ::dbtools::qualifiedNameComponents(m_xMetaData, | |
| *pIter, | |
| sCatalog, | |
| sSchema, | |
| sTable, | |
| ::dbtools::eInDataManipulation); | |
| Any aCatalog; | |
| if ( sCatalog.getLength() ) | |
| aCatalog <<= sCatalog; | |
| try | |
| { | |
| Reference< XResultSet > xResult = m_xMetaData->getImportedKeys(aCatalog, sSchema,sTable); | |
| if ( xResult.is() && xResult->next() ) | |
| { | |
| ::comphelper::disposeComponent(xResult); | |
| loadTableData(m_xTables->getByName(*pIter)); | |
| } // if ( xResult.is() && xResult->next() ) | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| } | |
| void SAL_CALL RelationLoader::onTerminated() | |
| { | |
| m_pParent->mergeData(m_vTableConnectionData); | |
| delete this; | |
| } | |
| void RelationLoader::loadTableData(const Any& _aTable) | |
| { | |
| Reference<XPropertySet> xTableProp(_aTable,UNO_QUERY); | |
| const ::rtl::OUString sSourceName = ::dbtools::composeTableName( m_xMetaData, xTableProp, ::dbtools::eInTableDefinitions, false, false, false ); | |
| TTableDataHelper::iterator aFind = m_aTableData.find(sSourceName); | |
| bool bNotFound = true, bAdded = false; | |
| if ( aFind == m_aTableData.end() ) | |
| { | |
| aFind = m_aTableData.insert(TTableDataHelper::value_type(sSourceName,::boost::shared_ptr<OTableWindowData>(new OTableWindowData(xTableProp,sSourceName, sSourceName)))).first; | |
| aFind->second->ShowAll(sal_False); | |
| bAdded = true; | |
| } | |
| TTableWindowData::value_type pReferencingTable = aFind->second; | |
| Reference<XIndexAccess> xKeys = pReferencingTable->getKeys(); | |
| const Reference<XKeysSupplier> xKeySup(xTableProp,UNO_QUERY); | |
| if ( !xKeys.is() && xKeySup.is() ) | |
| { | |
| xKeys = xKeySup->getKeys(); | |
| } | |
| if ( xKeys.is() ) | |
| { | |
| Reference<XPropertySet> xKey; | |
| const sal_Int32 nCount = xKeys->getCount(); | |
| for(sal_Int32 i = 0 ; i < nCount ; ++i) | |
| { | |
| xKeys->getByIndex(i) >>= xKey; | |
| sal_Int32 nKeyType = 0; | |
| xKey->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; | |
| if ( KeyType::FOREIGN == nKeyType ) | |
| { | |
| bNotFound = false; | |
| ::rtl::OUString sReferencedTable; | |
| xKey->getPropertyValue(PROPERTY_REFERENCEDTABLE) >>= sReferencedTable; | |
| ////////////////////////////////////////////////////////////////////// | |
| // insert windows | |
| TTableDataHelper::iterator aRefFind = m_aTableData.find(sReferencedTable); | |
| if ( aRefFind == m_aTableData.end() ) | |
| { | |
| if ( m_xTables->hasByName(sReferencedTable) ) | |
| { | |
| Reference<XPropertySet> xReferencedTable(m_xTables->getByName(sReferencedTable),UNO_QUERY); | |
| aRefFind = m_aTableData.insert(TTableDataHelper::value_type(sReferencedTable,::boost::shared_ptr<OTableWindowData>(new OTableWindowData(xReferencedTable,sReferencedTable, sReferencedTable)))).first; | |
| aRefFind->second->ShowAll(sal_False); | |
| } | |
| else | |
| continue; // table name could not be found so we do not show this table releation | |
| } // if ( aFind == m_aTableData.end() ) | |
| TTableWindowData::value_type pReferencedTable = aRefFind->second; | |
| ::rtl::OUString sKeyName; | |
| xKey->getPropertyValue(PROPERTY_NAME) >>= sKeyName; | |
| ////////////////////////////////////////////////////////////////////// | |
| // insert connection | |
| ORelationTableConnectionData* pTabConnData = new ORelationTableConnectionData( pReferencingTable, pReferencedTable, sKeyName ); | |
| m_vTableConnectionData.push_back(TTableConnectionData::value_type(pTabConnData)); | |
| ////////////////////////////////////////////////////////////////////// | |
| // insert columns | |
| const Reference<XColumnsSupplier> xColsSup(xKey,UNO_QUERY); | |
| OSL_ENSURE(xColsSup.is(),"Key is no XColumnsSupplier!"); | |
| const Reference<XNameAccess> xColumns = xColsSup->getColumns(); | |
| const Sequence< ::rtl::OUString> aNames = xColumns->getElementNames(); | |
| const ::rtl::OUString* pIter = aNames.getConstArray(); | |
| const ::rtl::OUString* pEnd = pIter + aNames.getLength(); | |
| ::rtl::OUString sColumnName,sRelatedName; | |
| for(sal_uInt16 j=0;pIter != pEnd;++pIter,++j) | |
| { | |
| const Reference<XPropertySet> xPropSet(xColumns->getByName(*pIter),UNO_QUERY); | |
| OSL_ENSURE(xPropSet.is(),"Invalid column found in KeyColumns!"); | |
| if ( xPropSet.is() ) | |
| { | |
| xPropSet->getPropertyValue(PROPERTY_NAME) >>= sColumnName; | |
| xPropSet->getPropertyValue(PROPERTY_RELATEDCOLUMN) >>= sRelatedName; | |
| } | |
| pTabConnData->SetConnLine( j, sColumnName, sRelatedName ); | |
| } | |
| ////////////////////////////////////////////////////////////////////// | |
| // Update/Del-Flags setzen | |
| sal_Int32 nUpdateRule = 0; | |
| sal_Int32 nDeleteRule = 0; | |
| xKey->getPropertyValue(PROPERTY_UPDATERULE) >>= nUpdateRule; | |
| xKey->getPropertyValue(PROPERTY_DELETERULE) >>= nDeleteRule; | |
| pTabConnData->SetUpdateRules( nUpdateRule ); | |
| pTabConnData->SetDeleteRules( nDeleteRule ); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Kardinalitaet setzen | |
| pTabConnData->SetCardinality(); | |
| } | |
| } | |
| } // if ( xKeys.is() ) | |
| } | |
| } | |
| void ORelationController::mergeData(const TTableConnectionData& _aConnectionData) | |
| { | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| ::std::copy( _aConnectionData.begin(), _aConnectionData.end(), ::std::back_inserter( m_vTableConnectionData )); | |
| //const Reference< XDatabaseMetaData> xMetaData = getConnection()->getMetaData(); | |
| const sal_Bool bCase = sal_True;//xMetaData.is() && xMetaData->supportsMixedCaseQuotedIdentifiers(); | |
| // here we are finished, so we can collect the table from connection data | |
| TTableConnectionData::iterator aConnDataIter = m_vTableConnectionData.begin(); | |
| TTableConnectionData::iterator aConnDataEnd = m_vTableConnectionData.end(); | |
| for(;aConnDataIter != aConnDataEnd;++aConnDataIter) | |
| { | |
| if ( !existsTable((*aConnDataIter)->getReferencingTable()->GetComposedName(),bCase) ) | |
| { | |
| m_vTableData.push_back((*aConnDataIter)->getReferencingTable()); | |
| } | |
| if ( !existsTable((*aConnDataIter)->getReferencedTable()->GetComposedName(),bCase) ) | |
| { | |
| m_vTableData.push_back((*aConnDataIter)->getReferencedTable()); | |
| } | |
| } // for(;aConnDataIter != aConnDataEnd;++aConnDataIter) | |
| if ( m_nThreadEvent ) | |
| { | |
| --m_nThreadEvent; | |
| if ( !m_nThreadEvent ) | |
| Application::PostUserEvent(LINK(this, ORelationController, OnThreadFinished)); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| IMPL_LINK( ORelationController, OnThreadFinished, void*, /*NOTINTERESTEDIN*/ ) | |
| { | |
| vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| try | |
| { | |
| getView()->initialize(); // show the windows and fill with our informations | |
| getView()->Invalidate(INVALIDATE_NOERASE); | |
| ClearUndoManager(); | |
| setModified(sal_False); // and we are not modified yet | |
| if(m_vTableData.empty()) | |
| Execute(ID_BROWSER_ADDTABLE,Sequence<PropertyValue>()); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| m_pWaitObject.reset(); | |
| return 0L; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void ORelationController::loadData() | |
| { | |
| m_pWaitObject.reset( new WaitObject(getView()) ); | |
| try | |
| { | |
| if ( !m_xTables.is() ) | |
| return; | |
| DatabaseMetaData aMeta(getConnection()); | |
| // this may take some time | |
| const Reference< XDatabaseMetaData> xMetaData = getConnection()->getMetaData(); | |
| const Sequence< ::rtl::OUString> aNames = m_xTables->getElementNames(); | |
| const sal_Int32 nCount = aNames.getLength(); | |
| if ( aMeta.supportsThreads() ) | |
| { | |
| const sal_Int32 nMaxElements = (nCount / MAX_THREADS) +1; | |
| sal_Int32 nStart = 0,nEnd = ::std::min(nMaxElements,nCount); | |
| while(nStart != nEnd) | |
| { | |
| ++m_nThreadEvent; | |
| RelationLoader* pThread = new RelationLoader(this,xMetaData,m_xTables,aNames,nStart,nEnd); | |
| pThread->createSuspended(); | |
| pThread->setPriority(osl_Thread_PriorityBelowNormal); | |
| pThread->resume(); | |
| nStart = nEnd; | |
| nEnd += nMaxElements; | |
| nEnd = ::std::min(nEnd,nCount); | |
| } // for(;pIter != pEnd;++pIter) | |
| } // if ( aMeta.supportsThreads() ) | |
| else | |
| { | |
| RelationLoader* pThread = new RelationLoader(this,xMetaData,m_xTables,aNames,0,nCount); | |
| pThread->run(); | |
| pThread->onTerminated(); | |
| } | |
| } | |
| catch(SQLException& e) | |
| { | |
| showError(SQLExceptionInfo(e)); | |
| } | |
| catch(const Exception&) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| TTableWindowData::value_type ORelationController::existsTable(const ::rtl::OUString& _rComposedTableName,sal_Bool _bCase) const | |
| { | |
| ::comphelper::UStringMixEqual bCase(_bCase); | |
| TTableWindowData::const_iterator aIter = m_vTableData.begin(); | |
| TTableWindowData::const_iterator aEnd = m_vTableData.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| if(bCase((*aIter)->GetComposedName(),_rComposedTableName)) | |
| break; | |
| } | |
| return ( aIter != aEnd) ? *aIter : TTableWindowData::value_type(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void ORelationController::loadLayoutInformation() | |
| { | |
| try | |
| { | |
| OSL_ENSURE(haveDataSource(),"We need a datasource from our connection!"); | |
| if ( haveDataSource() ) | |
| { | |
| if ( getDataSource()->getPropertySetInfo()->hasPropertyByName(PROPERTY_LAYOUTINFORMATION) ) | |
| { | |
| Sequence<PropertyValue> aWindows; | |
| getDataSource()->getPropertyValue(PROPERTY_LAYOUTINFORMATION) >>= aWindows; | |
| loadTableWindows(aWindows); | |
| } | |
| } | |
| } | |
| catch(Exception&) | |
| { | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void ORelationController::reset() | |
| { | |
| loadLayoutInformation(); | |
| ODataView* pView = getView(); | |
| OSL_ENSURE(pView,"No current view!"); | |
| if(pView) | |
| { | |
| pView->initialize(); | |
| pView->Invalidate(INVALIDATE_NOERASE); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| bool ORelationController::allowViews() const | |
| { | |
| return false; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| bool ORelationController::allowQueries() const | |
| { | |
| return false; | |
| } | |
| // ----------------------------------------------------------------------------- |