| /************************************************************** | |
| * | |
| * 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 "AppController.hxx" | |
| #include "dbustrings.hrc" | |
| #include "advancedsettingsdlg.hxx" | |
| #include "subcomponentmanager.hxx" | |
| #include "closeveto.hxx" | |
| /** === begin UNO includes === **/ | |
| #include <com/sun/star/beans/NamedValue.hpp> | |
| #include <com/sun/star/container/XChild.hpp> | |
| #include <com/sun/star/container/XContainer.hpp> | |
| #include <com/sun/star/container/XContentEnumerationAccess.hpp> | |
| #include <com/sun/star/container/XHierarchicalNameAccess.hpp> | |
| #include <com/sun/star/container/XHierarchicalNameContainer.hpp> | |
| #include <com/sun/star/container/XNameContainer.hpp> | |
| #include <com/sun/star/frame/FrameSearchFlag.hpp> | |
| #include <com/sun/star/frame/XStorable.hpp> | |
| #include <com/sun/star/sdb/CommandType.hpp> | |
| #include <com/sun/star/sdb/SQLContext.hpp> | |
| #include <com/sun/star/sdb/XBookmarksSupplier.hpp> | |
| #include <com/sun/star/sdb/XOfficeDatabaseDocument.hpp> | |
| #include <com/sun/star/sdb/XQueryDefinitionsSupplier.hpp> | |
| #include <com/sun/star/sdbc/XDataSource.hpp> | |
| #include <com/sun/star/sdbcx/XAlterView.hpp> | |
| #include <com/sun/star/sdbcx/XAppend.hpp> | |
| #include <com/sun/star/sdbcx/XRename.hpp> | |
| #include <com/sun/star/sdbcx/XTablesSupplier.hpp> | |
| #include <com/sun/star/sdbcx/XViewsSupplier.hpp> | |
| #include <com/sun/star/ui/dialogs/TemplateDescription.hpp> | |
| #include <com/sun/star/uno/XNamingService.hpp> | |
| #include <com/sun/star/util/XFlushable.hpp> | |
| #include <com/sun/star/util/XModifiable.hpp> | |
| #include <com/sun/star/util/XModifyBroadcaster.hpp> | |
| #include <com/sun/star/util/XNumberFormatter.hpp> | |
| #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> | |
| #include <com/sun/star/document/XEmbeddedScripts.hpp> | |
| #include <com/sun/star/frame/XModel2.hpp> | |
| #include <com/sun/star/container/XHierarchicalNameContainer.hpp> | |
| #include <com/sun/star/util/XModifyBroadcaster.hpp> | |
| #include <com/sun/star/util/XModifiable.hpp> | |
| #include <com/sun/star/frame/FrameSearchFlag.hpp> | |
| #include <com/sun/star/util/XFlushable.hpp> | |
| #include "com/sun/star/ui/dialogs/TemplateDescription.hpp" | |
| #include "com/sun/star/beans/NamedValue.hpp" | |
| #include <com/sun/star/awt/XTopWindow.hpp> | |
| #include <com/sun/star/task/XInteractionHandler.hpp> | |
| #include <com/sun/star/sdb/application/DatabaseObject.hpp> | |
| #include <com/sun/star/sdb/application/DatabaseObjectContainer.hpp> | |
| #include <com/sun/star/document/XDocumentEventBroadcaster.hpp> | |
| #include <com/sun/star/container/XHierarchicalName.hpp> | |
| /** === end UNO includes === **/ | |
| #include <tools/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <tools/string.hxx> | |
| #include <svl/urihelper.hxx> | |
| #include <svl/filenotation.hxx> | |
| #include <svtools/svtreebx.hxx> | |
| #include <svtools/transfer.hxx> | |
| #include <svtools/cliplistener.hxx> | |
| #include <svtools/svlbitm.hxx> | |
| #include <svtools/insdlg.hxx> | |
| #include <comphelper/sequence.hxx> | |
| #include <comphelper/uno3.hxx> | |
| #include <comphelper/string.hxx> | |
| #include <comphelper/types.hxx> | |
| #include <comphelper/interaction.hxx> | |
| #include <comphelper/componentcontext.hxx> | |
| #include <vcl/msgbox.hxx> | |
| #include <vcl/stdtext.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <vcl/menu.hxx> | |
| #include <vcl/lstbox.hxx> | |
| #include <unotools/pathoptions.hxx> | |
| #include <unotools/tempfile.hxx> | |
| #include <unotools/internaloptions.hxx> | |
| #include <unotools/moduleoptions.hxx> | |
| #include <unotools/historyoptions.hxx> | |
| #include <sfx2/mailmodelapi.hxx> | |
| #include <sfx2/filedlghelper.hxx> | |
| #include <sfx2/docfilt.hxx> | |
| #include <sfx2/QuerySaveDocument.hxx> | |
| #include <cppuhelper/typeprovider.hxx> | |
| #include <cppuhelper/exc_hlp.hxx> | |
| #include <connectivity/dbtools.hxx> | |
| #include <connectivity/dbexception.hxx> | |
| #include <svx/dbaexchange.hxx> | |
| #include <svx/dbaobjectex.hxx> | |
| #include <svx/svxdlg.hxx> | |
| #include <vos/mutex.hxx> | |
| #include "AppView.hxx" | |
| #include "browserids.hxx" | |
| #include "dbu_reghelper.hxx" | |
| #include "dbu_app.hrc" | |
| #include "defaultobjectnamecheck.hxx" | |
| #include "databaseobjectview.hxx" | |
| #include "listviewitems.hxx" | |
| #include "AppDetailView.hxx" | |
| #include "linkeddocuments.hxx" | |
| #include "sqlmessage.hxx" | |
| #include "UITools.hxx" | |
| #include "dsntypes.hxx" | |
| #include "dbaccess_helpid.hrc" | |
| #include "dlgsave.hxx" | |
| #include "dbaccess_slotid.hrc" | |
| #include <algorithm> | |
| #include <functional> | |
| #include <boost/noncopyable.hpp> | |
| extern "C" void SAL_CALL createRegistryInfo_ODBApplication() | |
| { | |
| static ::dbaui::OMultiInstanceAutoRegistration< ::dbaui::OApplicationController > aAutoRegistration; | |
| } | |
| //........................................................................ | |
| namespace dbaui | |
| { | |
| //........................................................................ | |
| using namespace ::dbtools; | |
| using namespace ::svx; | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::ucb; | |
| using namespace ::com::sun::star::view; | |
| using namespace ::com::sun::star::util; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::frame; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::sdb; | |
| using namespace ::com::sun::star::sdbc; | |
| using namespace ::com::sun::star::sdbcx; | |
| using namespace ::com::sun::star::datatransfer; | |
| using namespace ::com::sun::star::ui::dialogs; | |
| using namespace ::com::sun::star::task; | |
| using ::com::sun::star::document::XEmbeddedScripts; | |
| using ::com::sun::star::document::XDocumentEventBroadcaster; | |
| using ::com::sun::star::document::DocumentEvent; | |
| using ::com::sun::star::sdb::application::NamedDatabaseObject; | |
| namespace DatabaseObject = ::com::sun::star::sdb::application::DatabaseObject; | |
| namespace DatabaseObjectContainer = ::com::sun::star::sdb::application::DatabaseObjectContainer; | |
| //------------------------------------------------------------------------------ | |
| ::rtl::OUString SAL_CALL OApplicationController::getImplementationName() | |
| { | |
| return getImplementationName_Static(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| ::rtl::OUString OApplicationController::getImplementationName_Static() | |
| { | |
| return ::rtl::OUString(SERVICE_SDB_APPLICATIONCONTROLLER); | |
| } | |
| //------------------------------------------------------------------------------ | |
| Sequence< ::rtl::OUString> OApplicationController::getSupportedServiceNames_Static(void) | |
| { | |
| Sequence< ::rtl::OUString> aSupported(1); | |
| aSupported.getArray()[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdb.application.DefaultViewController"); | |
| return aSupported; | |
| } | |
| //------------------------------------------------------------------------- | |
| Sequence< ::rtl::OUString> SAL_CALL OApplicationController::getSupportedServiceNames() | |
| { | |
| return getSupportedServiceNames_Static(); | |
| } | |
| // ------------------------------------------------------------------------- | |
| Reference< XInterface > SAL_CALL OApplicationController::Create(const Reference<XMultiServiceFactory >& _rxFactory) | |
| { | |
| return *(new OApplicationController(_rxFactory)); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| struct XContainerFunctor : public ::std::unary_function< OApplicationController::TContainerVector::value_type , bool> | |
| { | |
| Reference<XContainerListener> m_xContainerListener; | |
| XContainerFunctor( const Reference<XContainerListener>& _xContainerListener) | |
| : m_xContainerListener(_xContainerListener){} | |
| bool operator() (const OApplicationController::TContainerVector::value_type& lhs) const | |
| { | |
| if ( lhs.is() ) | |
| lhs->removeContainerListener(m_xContainerListener); | |
| return true; | |
| } | |
| }; | |
| //==================================================================== | |
| //= OApplicationController | |
| //==================================================================== | |
| class SelectionNotifier : public ::boost::noncopyable | |
| { | |
| private: | |
| ::cppu::OInterfaceContainerHelper m_aSelectionListeners; | |
| ::cppu::OWeakObject& m_rContext; | |
| sal_Int32 m_nSelectionNestingLevel; | |
| public: | |
| SelectionNotifier( ::osl::Mutex& _rMutex, ::cppu::OWeakObject& _rContext ) | |
| :m_aSelectionListeners( _rMutex ) | |
| ,m_rContext( _rContext ) | |
| ,m_nSelectionNestingLevel( 0 ) | |
| { | |
| } | |
| void addListener( const Reference< XSelectionChangeListener >& _Listener ) | |
| { | |
| m_aSelectionListeners.addInterface( _Listener ); | |
| } | |
| void removeListener( const Reference< XSelectionChangeListener >& _Listener ) | |
| { | |
| m_aSelectionListeners.removeInterface( _Listener ); | |
| } | |
| void disposing() | |
| { | |
| EventObject aEvent( m_rContext ); | |
| m_aSelectionListeners.disposeAndClear( aEvent ); | |
| } | |
| ~SelectionNotifier() | |
| { | |
| } | |
| struct SelectionGuardAccess { friend class SelectionGuard; private: SelectionGuardAccess() { } }; | |
| /** enters a block which modifies the selection of our owner. | |
| Can be called multiple times, the only important thing is to call leaveSelection | |
| equally often. | |
| */ | |
| void enterSelection( SelectionGuardAccess ) | |
| { | |
| ++m_nSelectionNestingLevel; | |
| } | |
| /** leaves a block which modifies the selection of our owner | |
| Must be paired with enterSelection calls. | |
| When the last block is left, i.e. the last leaveSelection call is made on the current stack, | |
| then our SelectionChangeListeners are notified | |
| */ | |
| void leaveSelection( SelectionGuardAccess ) | |
| { | |
| if ( --m_nSelectionNestingLevel == 0 ) | |
| { | |
| EventObject aEvent( m_rContext ); | |
| m_aSelectionListeners.notifyEach( &XSelectionChangeListener::selectionChanged, aEvent ); | |
| } | |
| } | |
| }; | |
| class SelectionGuard : public ::boost::noncopyable | |
| { | |
| public: | |
| SelectionGuard( SelectionNotifier& _rNotifier ) | |
| :m_rNotifier( _rNotifier ) | |
| { | |
| m_rNotifier.enterSelection( SelectionNotifier::SelectionGuardAccess() ); | |
| } | |
| ~SelectionGuard() | |
| { | |
| m_rNotifier.leaveSelection( SelectionNotifier::SelectionGuardAccess() ); | |
| } | |
| private: | |
| SelectionNotifier& m_rNotifier; | |
| }; | |
| //==================================================================== | |
| //= OApplicationController | |
| //==================================================================== | |
| DBG_NAME(OApplicationController) | |
| //-------------------------------------------------------------------- | |
| OApplicationController::OApplicationController(const Reference< XMultiServiceFactory >& _rxORB) | |
| :OApplicationController_CBASE( _rxORB ) | |
| ,m_aContextMenuInterceptors( getMutex() ) | |
| ,m_pSubComponentManager( new SubComponentManager( *this, getSharedMutex() ) ) | |
| ,m_aTypeCollection(_rxORB) | |
| ,m_aTableCopyHelper(this) | |
| ,m_pClipbordNotifier(NULL) | |
| ,m_nAsyncDrop(0) | |
| ,m_aControllerConnectedEvent( LINK( this, OApplicationController, OnFirstControllerConnected ) ) | |
| ,m_aSelectContainerEvent( LINK( this, OApplicationController, OnSelectContainer ) ) | |
| ,m_ePreviewMode(E_PREVIEWNONE) | |
| ,m_eCurrentType(E_NONE) | |
| ,m_bNeedToReconnect(sal_False) | |
| ,m_bSuspended( sal_False ) | |
| ,m_pSelectionNotifier( new SelectionNotifier( getMutex(), *this ) ) | |
| { | |
| DBG_CTOR(OApplicationController,NULL); | |
| } | |
| //------------------------------------------------------------------------------ | |
| OApplicationController::~OApplicationController() | |
| { | |
| if ( !rBHelper.bDisposed && !rBHelper.bInDispose ) | |
| { | |
| OSL_ENSURE(0,"Please check who doesn't dispose this component!"); | |
| // increment ref count to prevent double call of Dtor | |
| osl_incrementInterlockedCount( &m_refCount ); | |
| dispose(); | |
| } | |
| ::std::auto_ptr< Window> aTemp( getView() ); | |
| clearView(); | |
| DBG_DTOR(OApplicationController,NULL); | |
| } | |
| //-------------------------------------------------------------------- | |
| IMPLEMENT_FORWARD_XTYPEPROVIDER2(OApplicationController,OApplicationController_CBASE,OApplicationController_Base) | |
| IMPLEMENT_FORWARD_XINTERFACE2(OApplicationController,OApplicationController_CBASE,OApplicationController_Base) | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::disconnect() | |
| { | |
| if ( m_xDataSourceConnection.is() ) | |
| stopConnectionListening( m_xDataSourceConnection ); | |
| try | |
| { | |
| // temporary (hopefully!) hack for #i55274# | |
| Reference< XFlushable > xFlush( m_xDataSourceConnection, UNO_QUERY ); | |
| if ( xFlush.is() && m_xMetaData.is() && !m_xMetaData->isReadOnly() ) | |
| xFlush->flush(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| m_xDataSourceConnection.clear(); | |
| m_xMetaData.clear(); | |
| InvalidateAll(); | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OApplicationController::disposing() | |
| { | |
| m_aControllerConnectedEvent.CancelCall(); | |
| ::std::for_each(m_aCurrentContainers.begin(),m_aCurrentContainers.end(),XContainerFunctor(this)); | |
| m_aCurrentContainers.clear(); | |
| m_pSubComponentManager->disposing(); | |
| m_pSelectionNotifier->disposing(); | |
| if ( getView() ) | |
| { | |
| getContainer()->showPreview(NULL); | |
| m_pClipbordNotifier->ClearCallbackLink(); | |
| m_pClipbordNotifier->AddRemoveListener( getView(), sal_False ); | |
| m_pClipbordNotifier->release(); | |
| m_pClipbordNotifier = NULL; | |
| } | |
| disconnect(); | |
| try | |
| { | |
| Reference < XFrame > xFrame; | |
| attachFrame( xFrame ); | |
| if ( m_xDataSource.is() ) | |
| { | |
| m_xDataSource->removePropertyChangeListener(::rtl::OUString(), this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_INFO, this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_URL, this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_ISPASSWORDREQUIRED, this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_LAYOUTINFORMATION, this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_SUPPRESSVERSIONCL, this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_TABLEFILTER, this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_TABLETYPEFILTER, this); | |
| m_xDataSource->removePropertyChangeListener(PROPERTY_USER, this); | |
| // otherwise we may delete our datasource twice | |
| Reference<XPropertySet> xProp = m_xDataSource; | |
| m_xDataSource = NULL; | |
| } | |
| Reference< XModifyBroadcaster > xBroadcaster( m_xModel, UNO_QUERY ); | |
| if ( xBroadcaster.is() ) | |
| xBroadcaster->removeModifyListener(static_cast<XModifyListener*>(this)); | |
| if ( m_xModel.is() ) | |
| { | |
| ::rtl::OUString sUrl = m_xModel->getURL(); | |
| if ( sUrl.getLength() ) | |
| { | |
| ::comphelper::NamedValueCollection aArgs( m_xModel->getArgs() ); | |
| if ( true == aArgs.getOrDefault( "PickListEntry", true ) ) | |
| { | |
| ::rtl::OUString aFilter; | |
| INetURLObject aURL( m_xModel->getURL() ); | |
| const SfxFilter* pFilter = getStandardDatabaseFilter(); | |
| if ( pFilter ) | |
| aFilter = pFilter->GetFilterName(); | |
| // add to svtool history options | |
| SvtHistoryOptions().AppendItem( ePICKLIST, | |
| aURL.GetURLNoPass( INetURLObject::NO_DECODE ), | |
| aFilter, | |
| getStrippedDatabaseName(), | |
| ::rtl::OUString() ); | |
| } | |
| } | |
| m_xModel->disconnectController( this ); | |
| m_xModel.clear(); | |
| } | |
| } | |
| catch(Exception) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| clearView(); | |
| OApplicationController_CBASE::disposing(); // here the m_refCount must be equal 5 | |
| } | |
| //-------------------------------------------------------------------- | |
| sal_Bool OApplicationController::Construct(Window* _pParent) | |
| { | |
| setView( * new OApplicationView( _pParent, getORB(), *this, m_ePreviewMode ) ); | |
| getView()->SetUniqueId(UID_APP_VIEW); | |
| // late construction | |
| sal_Bool bSuccess = sal_False; | |
| try | |
| { | |
| getContainer()->Construct(); | |
| bSuccess = sal_True; | |
| } | |
| catch(SQLException&) | |
| { | |
| } | |
| catch(Exception&) | |
| { | |
| DBG_ERROR("OApplicationController::Construct : the construction of UnoDataBrowserView failed !"); | |
| } | |
| if ( !bSuccess ) | |
| { | |
| ::std::auto_ptr< Window> aTemp( getView() ); | |
| clearView(); | |
| return sal_False; | |
| } | |
| // now that we have a view we can create the clipboard listener | |
| m_aSystemClipboard = TransferableDataHelper::CreateFromSystemClipboard( getView() ); | |
| m_aSystemClipboard.StartClipboardListening( ); | |
| m_pClipbordNotifier = new TransferableClipboardListener( LINK( this, OApplicationController, OnClipboardChanged ) ); | |
| m_pClipbordNotifier->acquire(); | |
| m_pClipbordNotifier->AddRemoveListener( getView(), sal_True ); | |
| OApplicationController_CBASE::Construct( _pParent ); | |
| getView()->Show(); | |
| return sal_True; | |
| } | |
| //-------------------------------------------------------------------- | |
| void SAL_CALL OApplicationController::disposing(const EventObject& _rSource) | |
| { | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| Reference<XConnection> xCon(_rSource.Source, UNO_QUERY); | |
| if ( xCon.is() ) | |
| { | |
| DBG_ASSERT( m_xDataSourceConnection == xCon, | |
| "OApplicationController::disposing: which connection does this come from?" ); | |
| if ( getContainer() && getContainer()->getElementType() == E_TABLE ) | |
| getContainer()->clearPages(); | |
| if ( m_xDataSourceConnection == xCon ) | |
| { | |
| m_xMetaData.clear(); | |
| m_xDataSourceConnection.clear(); | |
| } | |
| } | |
| else if ( _rSource.Source == m_xModel ) | |
| { | |
| m_xModel.clear(); | |
| } | |
| else if ( _rSource.Source == m_xDataSource ) | |
| { | |
| m_xDataSource = NULL; | |
| } | |
| else | |
| { | |
| Reference<XContainer> xContainer( _rSource.Source, UNO_QUERY ); | |
| if ( xContainer.is() ) | |
| { | |
| TContainerVector::iterator aFind = ::std::find(m_aCurrentContainers.begin(),m_aCurrentContainers.end(),xContainer); | |
| if ( aFind != m_aCurrentContainers.end() ) | |
| m_aCurrentContainers.erase(aFind); | |
| } | |
| OApplicationController_CBASE::disposing( _rSource ); | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| sal_Bool SAL_CALL OApplicationController::suspend(sal_Bool bSuspend) | |
| { | |
| // notify the OnPrepareViewClosing event (before locking any mutex) | |
| Reference< XDocumentEventBroadcaster > xBroadcaster( m_xModel, UNO_QUERY ); | |
| if ( xBroadcaster.is() ) | |
| { | |
| xBroadcaster->notifyDocumentEvent( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OnPrepareViewClosing" ) ), | |
| this, | |
| Any() | |
| ); | |
| } | |
| ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| if ( getView() && getView()->IsInModalMode() ) | |
| return sal_False; | |
| sal_Bool bCanSuspend = sal_True; | |
| if ( m_bSuspended != bSuspend ) | |
| { | |
| if ( bSuspend && !closeSubComponents() ) | |
| return sal_False; | |
| Reference<XModifiable> xModi(m_xModel,UNO_QUERY); | |
| Reference<XStorable> xStor(getModel(),UNO_QUERY); | |
| if ( bSuspend | |
| && xStor.is() | |
| && !xStor->isReadonly() | |
| && ( xModi.is() | |
| && xModi->isModified() | |
| ) | |
| ) | |
| { | |
| switch (ExecuteQuerySaveDocument(getView(),getStrippedDatabaseName())) | |
| { | |
| case RET_YES: | |
| Execute(ID_BROWSER_SAVEDOC,Sequence<PropertyValue>()); | |
| bCanSuspend = !xModi->isModified(); | |
| // when we save the document this must be false else some press cancel | |
| break; | |
| case RET_CANCEL: | |
| bCanSuspend = sal_False; | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| if ( bCanSuspend ) | |
| m_bSuspended = bSuspend; | |
| return bCanSuspend; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| FeatureState OApplicationController::GetState(sal_uInt16 _nId) const | |
| { | |
| FeatureState aReturn; | |
| aReturn.bEnabled = sal_False; | |
| // check this first | |
| if ( !getContainer() || m_bReadOnly ) | |
| return aReturn; | |
| try | |
| { | |
| switch (_nId) | |
| { | |
| case SID_OPENURL: | |
| aReturn.bEnabled = sal_True; | |
| if ( m_xModel.is() ) | |
| aReturn.sTitle = m_xModel->getURL(); | |
| break; | |
| case ID_BROWSER_COPY: | |
| { | |
| sal_Int32 nCount = getContainer()->getSelectionCount(); | |
| aReturn.bEnabled = nCount >= 1; | |
| if ( aReturn.bEnabled && nCount == 1 && getContainer()->getElementType() == E_TABLE ) | |
| aReturn.bEnabled = getContainer()->isALeafSelected(); | |
| } | |
| break; | |
| case ID_BROWSER_CUT: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && getContainer()->getSelectionCount() >= 1; | |
| aReturn.bEnabled = aReturn.bEnabled && ( (ID_BROWSER_CUT == _nId && getContainer()->getElementType() == E_TABLE) ? getContainer()->isCutAllowed() : sal_True); | |
| break; | |
| case ID_BROWSER_PASTE: | |
| switch( getContainer()->getElementType() ) | |
| { | |
| case E_TABLE: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && !isConnectionReadOnly() && isTableFormat(); | |
| break; | |
| case E_QUERY: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && getViewClipboard().HasFormat(SOT_FORMATSTR_ID_DBACCESS_QUERY); | |
| break; | |
| default: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && OComponentTransferable::canExtractComponentDescriptor(getViewClipboard().GetDataFlavorExVector(),getContainer()->getElementType() == E_FORM); | |
| } | |
| break; | |
| case SID_DB_APP_PASTE_SPECIAL: | |
| aReturn.bEnabled = getContainer()->getElementType() == E_TABLE && !isDataSourceReadOnly() && !isConnectionReadOnly() && isTableFormat(); | |
| break; | |
| case SID_OPENDOC: | |
| case SID_HELP_INDEX: | |
| aReturn.bEnabled = sal_True; | |
| break; | |
| case ID_BROWSER_SAVEDOC: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && m_xDocumentModify.is() && m_xDocumentModify->isModified(); | |
| break; | |
| case ID_BROWSER_SAVEASDOC: | |
| aReturn.bEnabled = sal_True; | |
| break; | |
| case ID_BROWSER_SORTUP: | |
| aReturn.bEnabled = getContainer()->isFilled() && getContainer()->getElementCount(); | |
| aReturn.bChecked = aReturn.bEnabled && getContainer()->isSortUp(); | |
| break; | |
| case ID_BROWSER_SORTDOWN: | |
| aReturn.bEnabled = getContainer()->isFilled() && getContainer()->getElementCount(); | |
| aReturn.bChecked = aReturn.bEnabled && !getContainer()->isSortUp(); | |
| break; | |
| case SID_NEWDOC: | |
| case SID_APP_NEW_FORM: | |
| case ID_DOCUMENT_CREATE_REPWIZ: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::E_SWRITER); | |
| break; | |
| case SID_APP_NEW_REPORT: | |
| aReturn.bEnabled = !isDataSourceReadOnly() | |
| && SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::E_SWRITER); | |
| if ( aReturn.bEnabled ) | |
| { | |
| Reference< XContentEnumerationAccess > xEnumAccess(m_xServiceFactory, UNO_QUERY); | |
| aReturn.bEnabled = xEnumAccess.is(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| const ::rtl::OUString sReportEngineServiceName = ::dbtools::getDefaultReportEngineServiceName(m_xServiceFactory); | |
| aReturn.bEnabled = sReportEngineServiceName.getLength() != 0; | |
| if ( aReturn.bEnabled ) | |
| { | |
| const Reference< XEnumeration > xEnumDrivers = xEnumAccess->createContentEnumeration(sReportEngineServiceName); | |
| aReturn.bEnabled = xEnumDrivers.is() && xEnumDrivers->hasMoreElements(); | |
| } | |
| } | |
| } | |
| break; | |
| case SID_DB_APP_VIEW_TABLES: | |
| aReturn.bEnabled = sal_True; | |
| aReturn.bChecked = getContainer()->getElementType() == E_TABLE; | |
| break; | |
| case SID_DB_APP_VIEW_QUERIES: | |
| aReturn.bEnabled = sal_True; | |
| aReturn.bChecked = getContainer()->getElementType() == E_QUERY; | |
| break; | |
| case SID_DB_APP_VIEW_FORMS: | |
| aReturn.bEnabled = sal_True; | |
| aReturn.bChecked = getContainer()->getElementType() == E_FORM; | |
| break; | |
| case SID_DB_APP_VIEW_REPORTS: | |
| aReturn.bEnabled = sal_True; | |
| aReturn.bChecked = getContainer()->getElementType() == E_REPORT; | |
| break; | |
| case ID_NEW_QUERY_DESIGN: | |
| case ID_NEW_QUERY_SQL: | |
| case ID_APP_NEW_QUERY_AUTO_PILOT: | |
| case SID_DB_FORM_NEW_PILOT: | |
| aReturn.bEnabled = !isDataSourceReadOnly(); | |
| break; | |
| case ID_NEW_VIEW_DESIGN: | |
| case SID_DB_NEW_VIEW_SQL: | |
| case ID_NEW_VIEW_DESIGN_AUTO_PILOT: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && !isConnectionReadOnly(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| Reference<XViewsSupplier> xViewsSup( getConnection(), UNO_QUERY ); | |
| aReturn.bEnabled = xViewsSup.is(); | |
| } | |
| break; | |
| case ID_NEW_TABLE_DESIGN: | |
| case ID_NEW_TABLE_DESIGN_AUTO_PILOT: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && !isConnectionReadOnly(); | |
| break; | |
| case ID_DIRECT_SQL: | |
| aReturn.bEnabled = sal_True; | |
| break; | |
| case ID_MIGRATE_SCRIPTS: | |
| { | |
| // Our document supports embedding scripts into it, if and only if there are no | |
| // forms/reports with macros/scripts into them. So, we need to enable migration | |
| // if and only if the database document does *not* support embedding scripts. | |
| bool bAvailable = | |
| !Reference< XEmbeddedScripts >( m_xModel, UNO_QUERY ).is() | |
| && !Reference< XStorable >( m_xModel, UNO_QUERY_THROW )->isReadonly(); | |
| aReturn.bEnabled = bAvailable; | |
| if ( !bAvailable ) | |
| aReturn.bInvisible = true; | |
| } | |
| break; | |
| case SID_APP_NEW_FOLDER: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && getContainer()->getSelectionCount() <= 1; | |
| if ( aReturn.bEnabled ) | |
| { | |
| const ElementType eType = getContainer()->getElementType(); | |
| aReturn.bEnabled = eType == E_REPORT || eType == E_FORM; | |
| } | |
| break; | |
| case SID_FORM_CREATE_REPWIZ_PRE_SEL: | |
| case SID_REPORT_CREATE_REPWIZ_PRE_SEL: | |
| case SID_APP_NEW_REPORT_PRE_SEL: | |
| aReturn.bEnabled = !isDataSourceReadOnly() | |
| && SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::E_SWRITER) | |
| && getContainer()->isALeafSelected(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| ElementType eType = getContainer()->getElementType(); | |
| aReturn.bEnabled = eType == E_QUERY || eType == E_TABLE; | |
| if ( aReturn.bEnabled && SID_APP_NEW_REPORT_PRE_SEL == _nId ) | |
| { | |
| Reference< XContentEnumerationAccess > xEnumAccess(m_xServiceFactory, UNO_QUERY); | |
| aReturn.bEnabled = xEnumAccess.is(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| static ::rtl::OUString s_sReportDesign(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.report.pentaho.SOReportJobFactory")); | |
| Reference< XEnumeration > xEnumDrivers = xEnumAccess->createContentEnumeration(s_sReportDesign); | |
| aReturn.bEnabled = xEnumDrivers.is() && xEnumDrivers->hasMoreElements(); | |
| } | |
| } | |
| } | |
| break; | |
| case SID_DB_APP_DELETE: | |
| case SID_DB_APP_RENAME: | |
| aReturn.bEnabled = isRenameDeleteAllowed(getContainer()->getElementType(), _nId == SID_DB_APP_DELETE); | |
| break; | |
| case SID_DB_APP_TABLE_DELETE: | |
| case SID_DB_APP_TABLE_RENAME: | |
| aReturn.bEnabled = isRenameDeleteAllowed(E_TABLE, _nId == SID_DB_APP_TABLE_DELETE); | |
| break; | |
| case SID_DB_APP_QUERY_DELETE: | |
| case SID_DB_APP_QUERY_RENAME: | |
| aReturn.bEnabled = isRenameDeleteAllowed(E_QUERY, _nId == SID_DB_APP_QUERY_DELETE); | |
| break; | |
| case SID_DB_APP_FORM_DELETE: | |
| case SID_DB_APP_FORM_RENAME: | |
| aReturn.bEnabled = isRenameDeleteAllowed(E_FORM, _nId == SID_DB_APP_FORM_DELETE); | |
| break; | |
| case SID_DB_APP_REPORT_DELETE: | |
| case SID_DB_APP_REPORT_RENAME: | |
| aReturn.bEnabled = isRenameDeleteAllowed(E_REPORT, _nId == SID_DB_APP_REPORT_DELETE); | |
| break; | |
| case SID_SELECTALL: | |
| aReturn.bEnabled = getContainer()->getElementCount() > 0 && getContainer()->getSelectionCount() != getContainer()->getElementCount(); | |
| break; | |
| case SID_DB_APP_EDIT: | |
| case SID_DB_APP_TABLE_EDIT: | |
| case SID_DB_APP_QUERY_EDIT: | |
| case SID_DB_APP_FORM_EDIT: | |
| case SID_DB_APP_REPORT_EDIT: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && getContainer()->getSelectionCount() > 0 | |
| && getContainer()->isALeafSelected(); | |
| break; | |
| case SID_DB_APP_EDIT_SQL_VIEW: | |
| if ( isDataSourceReadOnly() ) | |
| aReturn.bEnabled = sal_False; | |
| else | |
| { | |
| switch ( getContainer()->getElementType() ) | |
| { | |
| case E_QUERY: | |
| aReturn.bEnabled = ( getContainer()->getSelectionCount() > 0 ) | |
| && ( getContainer()->isALeafSelected() ); | |
| break; | |
| case E_TABLE: | |
| aReturn.bEnabled = sal_False; | |
| // there's one exception: views which support altering their underlying | |
| // command can be edited in SQL view, too | |
| if ( ( getContainer()->getSelectionCount() > 0 ) | |
| && ( getContainer()->isALeafSelected() ) | |
| ) | |
| { | |
| ::std::vector< ::rtl::OUString > aSelected; | |
| getSelectionElementNames( aSelected ); | |
| bool bAlterableViews = true; | |
| for ( ::std::vector< ::rtl::OUString >::const_iterator selectedName = aSelected.begin(); | |
| bAlterableViews && ( selectedName != aSelected.end() ) ; | |
| ++selectedName | |
| ) | |
| { | |
| bAlterableViews &= impl_isAlterableView_nothrow( *selectedName ); | |
| } | |
| aReturn.bEnabled = bAlterableViews; | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| break; | |
| case SID_DB_APP_OPEN: | |
| case SID_DB_APP_TABLE_OPEN: | |
| case SID_DB_APP_QUERY_OPEN: | |
| case SID_DB_APP_FORM_OPEN: | |
| case SID_DB_APP_REPORT_OPEN: | |
| aReturn.bEnabled = getContainer()->getSelectionCount() > 0 && getContainer()->isALeafSelected(); | |
| break; | |
| case SID_DB_APP_DSUSERADMIN: | |
| aReturn.bEnabled = !m_aTypeCollection.isEmbeddedDatabase(::comphelper::getString(m_xDataSource->getPropertyValue(PROPERTY_URL))); | |
| break; | |
| case SID_DB_APP_DSRELDESIGN: | |
| aReturn.bEnabled = sal_True; | |
| break; | |
| case SID_DB_APP_TABLEFILTER: | |
| aReturn.bEnabled = !isDataSourceReadOnly(); | |
| break; | |
| case SID_DB_APP_REFRESH_TABLES: | |
| aReturn.bEnabled = getContainer()->getElementType() == E_TABLE && isConnected(); | |
| break; | |
| case SID_DB_APP_DSPROPS: | |
| aReturn.bEnabled = m_xDataSource.is() && m_aTypeCollection.isShowPropertiesEnabled(::comphelper::getString(m_xDataSource->getPropertyValue(PROPERTY_URL))); | |
| break; | |
| case SID_DB_APP_DSCONNECTION_TYPE: | |
| aReturn.bEnabled = !isDataSourceReadOnly() && m_xDataSource.is() && !m_aTypeCollection.isEmbeddedDatabase(::comphelper::getString(m_xDataSource->getPropertyValue(PROPERTY_URL))); | |
| break; | |
| case SID_DB_APP_DSADVANCED_SETTINGS: | |
| aReturn.bEnabled = m_xDataSource.is() && AdvancedSettingsDialog::doesHaveAnyAdvancedSettings( m_aTypeCollection.getType(::comphelper::getString( m_xDataSource->getPropertyValue( PROPERTY_URL ) )) ); | |
| break; | |
| case SID_DB_APP_CONVERTTOVIEW: | |
| aReturn.bEnabled = !isDataSourceReadOnly(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| ElementType eType = getContainer()->getElementType(); | |
| aReturn.bEnabled = eType == E_QUERY && getContainer()->getSelectionCount() > 0; | |
| if ( aReturn.bEnabled ) | |
| { | |
| Reference<XViewsSupplier> xViewSup( getConnection(), UNO_QUERY ); | |
| aReturn.bEnabled = xViewSup.is() && Reference<XAppend>(xViewSup->getViews(),UNO_QUERY).is(); | |
| } | |
| } | |
| break; | |
| case SID_DB_APP_DISABLE_PREVIEW: | |
| aReturn.bEnabled = sal_True; | |
| aReturn.bChecked = getContainer()->getPreviewMode() == E_PREVIEWNONE; | |
| break; | |
| case SID_DB_APP_VIEW_DOCINFO_PREVIEW: | |
| { | |
| ElementType eType = getContainer()->getElementType(); | |
| aReturn.bEnabled = (E_REPORT == eType || E_FORM == eType); | |
| aReturn.bChecked = getContainer()->getPreviewMode() == E_DOCUMENTINFO; | |
| } | |
| break; | |
| case SID_DB_APP_VIEW_DOC_PREVIEW: | |
| aReturn.bEnabled = sal_True; | |
| aReturn.bChecked = getContainer()->getPreviewMode() == E_DOCUMENT; | |
| break; | |
| case ID_BROWSER_UNDO: | |
| aReturn.bEnabled = sal_False; | |
| break; | |
| case SID_MAIL_SENDDOC: | |
| aReturn.bEnabled = sal_True; | |
| break; | |
| case SID_DB_APP_SENDREPORTASMAIL: | |
| { | |
| ElementType eType = getContainer()->getElementType(); | |
| aReturn.bEnabled = E_REPORT == eType && getContainer()->getSelectionCount() > 0 && getContainer()->isALeafSelected(); | |
| } | |
| break; | |
| case SID_DB_APP_SENDREPORTTOWRITER: | |
| case SID_DB_APP_DBADMIN: | |
| aReturn.bEnabled = sal_False; | |
| break; | |
| case SID_DB_APP_STATUS_TYPE: | |
| aReturn.bEnabled = m_xDataSource.is(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| ::rtl::OUString sURL; | |
| m_xDataSource->getPropertyValue(PROPERTY_URL) >>= sURL; | |
| ::rtl::OUString sDSTypeName; | |
| if ( m_aTypeCollection.isEmbeddedDatabase( sURL ) ) | |
| { | |
| sDSTypeName = String( ModuleRes( RID_STR_EMBEDDED_DATABASE ) ); | |
| } | |
| else | |
| { | |
| sDSTypeName = m_aTypeCollection.getTypeDisplayName(sURL); | |
| } | |
| aReturn.sTitle = sDSTypeName; | |
| } | |
| break; | |
| case SID_DB_APP_STATUS_DBNAME: | |
| aReturn.bEnabled = m_xDataSource.is(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| ::rtl::OUString sURL; | |
| m_xDataSource->getPropertyValue(PROPERTY_URL) >>= sURL; | |
| String sDatabaseName; | |
| String sHostName; | |
| sal_Int32 nPortNumber( -1 ); | |
| m_aTypeCollection.extractHostNamePort( sURL, sDatabaseName, sHostName, nPortNumber ); | |
| if ( !sDatabaseName.Len() ) | |
| sDatabaseName = m_aTypeCollection.cutPrefix( sURL ); | |
| if ( m_aTypeCollection.isFileSystemBased(sURL) ) | |
| { | |
| sDatabaseName = SvtPathOptions().SubstituteVariable( sDatabaseName ); | |
| if ( sDatabaseName.Len() ) | |
| { | |
| ::svt::OFileNotation aFileNotation(sDatabaseName); | |
| // set this decoded URL as text | |
| sDatabaseName = aFileNotation.get(::svt::OFileNotation::N_SYSTEM); | |
| } | |
| } | |
| if ( sDatabaseName.Len() == 0 ) | |
| sDatabaseName = m_aTypeCollection.getTypeDisplayName( sURL ); | |
| aReturn.sTitle = sDatabaseName; | |
| } | |
| break; | |
| case SID_DB_APP_STATUS_USERNAME: | |
| aReturn.bEnabled = m_xDataSource.is(); | |
| if ( aReturn.bEnabled ) | |
| m_xDataSource->getPropertyValue( PROPERTY_USER ) >>= aReturn.sTitle; | |
| break; | |
| case SID_DB_APP_STATUS_HOSTNAME: | |
| aReturn.bEnabled = m_xDataSource.is(); | |
| if ( aReturn.bEnabled ) | |
| { | |
| ::rtl::OUString sURL; | |
| m_xDataSource->getPropertyValue( PROPERTY_URL ) >>= sURL; | |
| String sHostName, sDatabaseName; | |
| sal_Int32 nPortNumber = -1; | |
| m_aTypeCollection.extractHostNamePort( sURL, sDatabaseName, sHostName, nPortNumber ); | |
| aReturn.sTitle = sHostName; | |
| } | |
| break; | |
| default: | |
| aReturn = OApplicationController_CBASE::GetState(_nId); | |
| } | |
| } | |
| catch(const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return aReturn; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| namespace | |
| { | |
| bool lcl_handleException_nothrow( const Reference< XModel >& _rxDocument, const Any& _rException ) | |
| { | |
| bool bHandled = false; | |
| // try handling the error with an interaction handler | |
| ::comphelper::NamedValueCollection aArgs( _rxDocument->getArgs() ); | |
| Reference< XInteractionHandler > xHandler( aArgs.getOrDefault( "InteractionHandler", Reference< XInteractionHandler >() ) ); | |
| if ( xHandler.is() ) | |
| { | |
| ::rtl::Reference< ::comphelper::OInteractionRequest > pRequest( new ::comphelper::OInteractionRequest( _rException ) ); | |
| ::rtl::Reference< ::comphelper::OInteractionApprove > pApprove( new ::comphelper::OInteractionApprove ); | |
| pRequest->addContinuation( pApprove.get() ); | |
| try | |
| { | |
| xHandler->handle( pRequest.get() ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| bHandled = pApprove->wasSelected(); | |
| } | |
| return bHandled; | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::Execute(sal_uInt16 _nId, const Sequence< PropertyValue >& aArgs) | |
| { | |
| ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| if ( isUserDefinedFeature( _nId ) ) | |
| { | |
| OApplicationController_CBASE::Execute( _nId, aArgs ); | |
| return; | |
| } | |
| if ( !getContainer() || m_bReadOnly ) | |
| return; // return without execution | |
| try | |
| { | |
| switch(_nId) | |
| { | |
| case ID_BROWSER_CUT: | |
| getContainer()->cut(); | |
| break; | |
| case ID_BROWSER_COPY: | |
| { | |
| TransferableHelper* pTransfer = copyObject( ); | |
| Reference< XTransferable> aEnsureDelete = pTransfer; | |
| if ( pTransfer ) | |
| pTransfer->CopyToClipboard(getView()); | |
| } | |
| break; | |
| case ID_BROWSER_PASTE: | |
| { | |
| const TransferableDataHelper& rTransferData( getViewClipboard() ); | |
| ElementType eType = getContainer()->getElementType(); | |
| switch( eType ) | |
| { | |
| case E_TABLE: | |
| { | |
| // get the selected tablename | |
| ::std::vector< ::rtl::OUString > aList; | |
| getSelectionElementNames( aList ); | |
| if ( !aList.empty() ) | |
| m_aTableCopyHelper.SetTableNameForAppend( *aList.begin() ); | |
| else | |
| m_aTableCopyHelper.ResetTableNameForAppend(); | |
| m_aTableCopyHelper.pasteTable( rTransferData , getDatabaseName(), ensureConnection() ); | |
| } | |
| break; | |
| case E_QUERY: | |
| if ( rTransferData.HasFormat(SOT_FORMATSTR_ID_DBACCESS_QUERY) ) | |
| paste( E_QUERY, ODataAccessObjectTransferable::extractObjectDescriptor( rTransferData ) ); | |
| break; | |
| default: | |
| { | |
| ::std::vector< ::rtl::OUString> aList; | |
| getSelectionElementNames(aList); | |
| ::rtl::OUString sFolderNameToInsertInto; | |
| if ( !aList.empty() ) | |
| { | |
| Reference< XHierarchicalNameAccess > xContainer(getElements(eType),UNO_QUERY); | |
| if ( xContainer.is() | |
| && xContainer->hasByHierarchicalName(*aList.begin()) | |
| && (xContainer->getByHierarchicalName(*aList.begin()) >>= xContainer) | |
| && xContainer.is() | |
| ) | |
| sFolderNameToInsertInto = *aList.begin(); | |
| } | |
| paste( eType, OComponentTransferable::extractComponentDescriptor( rTransferData ), | |
| sFolderNameToInsertInto ); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case SID_DB_APP_PASTE_SPECIAL: | |
| { | |
| if ( !aArgs.getLength() ) | |
| { | |
| SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); | |
| ::std::auto_ptr<SfxAbstractPasteDialog> pDlg(pFact->CreatePasteDialog( getView() )); | |
| ::std::vector<SotFormatStringId> aFormatIds; | |
| getSupportedFormats(getContainer()->getElementType(),aFormatIds); | |
| const ::std::vector<SotFormatStringId>::iterator aEnd = aFormatIds.end(); | |
| ::rtl::OUString sEmpty; | |
| for (::std::vector<SotFormatStringId>::iterator aIter = aFormatIds.begin();aIter != aEnd; ++aIter) | |
| pDlg->Insert(*aIter,sEmpty); | |
| const TransferableDataHelper& rClipboard = getViewClipboard(); | |
| pasteFormat(pDlg->GetFormat(rClipboard.GetTransferable())); | |
| } | |
| else | |
| { | |
| const PropertyValue* pIter = aArgs.getConstArray(); | |
| const PropertyValue* pEnd = pIter + aArgs.getLength(); | |
| for( ; pIter != pEnd ; ++pIter) | |
| { | |
| if ( pIter->Name.equalsAscii("FormatStringId") ) | |
| { | |
| SotFormatStringId nFormatId = 0; | |
| if ( pIter->Value >>= nFormatId ) | |
| pasteFormat(nFormatId); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| case SID_OPENDOC: | |
| case SID_HELP_INDEX: | |
| { | |
| Reference < XDispatchProvider > xProv( getFrame(), UNO_QUERY ); | |
| if ( xProv.is() ) | |
| { | |
| URL aURL; | |
| switch(_nId) | |
| { | |
| case SID_HELP_INDEX: | |
| aURL.Complete = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(".uno:HelpIndex")); | |
| break; | |
| case SID_OPENDOC: | |
| aURL.Complete = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(".uno:Open")); | |
| break; | |
| } | |
| if ( m_xUrlTransformer.is() ) | |
| m_xUrlTransformer->parseStrict( aURL ); | |
| Reference < XDispatch > xDisp = xProv->queryDispatch( aURL, String(), 0 ); | |
| if ( xDisp.is() ) | |
| xDisp->dispatch( aURL, Sequence < PropertyValue >() ); | |
| } | |
| } | |
| break; | |
| case ID_BROWSER_SAVEDOC: | |
| { | |
| Reference< XStorable > xStore( m_xModel, UNO_QUERY_THROW ); | |
| try | |
| { | |
| xStore->store(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| lcl_handleException_nothrow( m_xModel, ::cppu::getCaughtException() ); | |
| } | |
| } | |
| break; | |
| case ID_BROWSER_SAVEASDOC: | |
| { | |
| WinBits nBits(WB_STDMODAL|WB_SAVEAS); | |
| ::rtl::OUString sUrl; | |
| if ( m_xModel.is() ) | |
| sUrl = m_xModel->getURL(); | |
| if ( !sUrl.getLength() ) | |
| sUrl = SvtPathOptions().GetWorkPath(); | |
| ::sfx2::FileDialogHelper aFileDlg( com::sun::star::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION,static_cast<sal_uInt32>(nBits) ,getView()); | |
| aFileDlg.SetDisplayDirectory( sUrl ); | |
| const SfxFilter* pFilter = getStandardDatabaseFilter(); | |
| if ( pFilter ) | |
| { | |
| aFileDlg.AddFilter(pFilter->GetUIName(),pFilter->GetDefaultExtension()); | |
| aFileDlg.SetCurrentFilter(pFilter->GetUIName()); | |
| } | |
| if ( aFileDlg.Execute() != ERRCODE_NONE ) | |
| break; | |
| Reference<XStorable> xStore( m_xModel, UNO_QUERY_THROW ); | |
| INetURLObject aURL( aFileDlg.GetPath() ); | |
| try | |
| { | |
| xStore->storeAsURL( aURL.GetMainURL( INetURLObject::NO_DECODE ), Sequence< PropertyValue >() ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| lcl_handleException_nothrow( m_xModel, ::cppu::getCaughtException() ); | |
| } | |
| /*updateTitle();*/ | |
| m_bCurrentlyModified = sal_False; | |
| InvalidateFeature(ID_BROWSER_SAVEDOC); | |
| if ( getContainer()->getElementType() == E_NONE ) | |
| { | |
| getContainer()->selectContainer(E_NONE); | |
| getContainer()->selectContainer(E_TABLE); | |
| // #i95524# | |
| getContainer()->Invalidate(); | |
| refreshTables(); | |
| } | |
| } | |
| break; | |
| case ID_BROWSER_SORTUP: | |
| getContainer()->sortUp(); | |
| InvalidateFeature(ID_BROWSER_SORTDOWN); | |
| break; | |
| case ID_BROWSER_SORTDOWN: | |
| getContainer()->sortDown(); | |
| InvalidateFeature(ID_BROWSER_SORTUP); | |
| break; | |
| case ID_NEW_TABLE_DESIGN_AUTO_PILOT: | |
| case ID_NEW_VIEW_DESIGN_AUTO_PILOT: | |
| case ID_APP_NEW_QUERY_AUTO_PILOT: | |
| case SID_DB_FORM_NEW_PILOT: | |
| case SID_REPORT_CREATE_REPWIZ_PRE_SEL: | |
| case SID_APP_NEW_REPORT_PRE_SEL: | |
| case SID_FORM_CREATE_REPWIZ_PRE_SEL: | |
| case ID_DOCUMENT_CREATE_REPWIZ: | |
| case SID_APP_NEW_FORM: | |
| case SID_APP_NEW_REPORT: | |
| case ID_NEW_QUERY_SQL: | |
| case ID_NEW_QUERY_DESIGN: | |
| case ID_NEW_TABLE_DESIGN: | |
| { | |
| ElementType eType = E_TABLE; | |
| sal_Bool bAutoPilot = sal_False; | |
| ::comphelper::NamedValueCollection aCreationArgs; | |
| switch( _nId ) | |
| { | |
| case SID_DB_FORM_NEW_PILOT: | |
| case SID_FORM_CREATE_REPWIZ_PRE_SEL: | |
| bAutoPilot = sal_True; | |
| // run through | |
| case SID_APP_NEW_FORM: | |
| eType = E_FORM; | |
| break; | |
| case ID_DOCUMENT_CREATE_REPWIZ: | |
| case SID_REPORT_CREATE_REPWIZ_PRE_SEL: | |
| bAutoPilot = sal_True; | |
| // run through | |
| case SID_APP_NEW_REPORT: | |
| case SID_APP_NEW_REPORT_PRE_SEL: | |
| eType = E_REPORT; | |
| break; | |
| case ID_APP_NEW_QUERY_AUTO_PILOT: | |
| bAutoPilot = sal_True; | |
| eType = E_QUERY; | |
| break; | |
| case ID_NEW_QUERY_DESIGN: | |
| aCreationArgs.put( (::rtl::OUString)PROPERTY_GRAPHICAL_DESIGN, sal_True ); | |
| // run through | |
| case ID_NEW_QUERY_SQL: | |
| eType = E_QUERY; | |
| break; | |
| case ID_NEW_TABLE_DESIGN_AUTO_PILOT: | |
| bAutoPilot = sal_True; | |
| // run through | |
| case ID_NEW_TABLE_DESIGN: | |
| break; | |
| default: | |
| OSL_ENSURE(0,"illegal switch call!"); | |
| } | |
| if ( bAutoPilot ) | |
| getContainer()->PostUserEvent( LINK( this, OApplicationController, OnCreateWithPilot ), reinterpret_cast< void* >( eType ) ); | |
| else | |
| { | |
| Reference< XComponent > xDocDefinition; | |
| newElement( eType, aCreationArgs, xDocDefinition ); | |
| } | |
| } | |
| break; | |
| case SID_APP_NEW_FOLDER: | |
| { | |
| ElementType eType = getContainer()->getElementType(); | |
| ::rtl::OUString sName = getContainer()->getQualifiedName( NULL ); | |
| insertHierachyElement(eType,sName); | |
| } | |
| break; | |
| case ID_NEW_VIEW_DESIGN: | |
| case SID_DB_NEW_VIEW_SQL: | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( xConnection.is() ) | |
| { | |
| QueryDesigner aDesigner( getORB(), this, getFrame(), true ); | |
| ::comphelper::NamedValueCollection aCreationArgs; | |
| aCreationArgs.put( (::rtl::OUString)PROPERTY_GRAPHICAL_DESIGN, ID_NEW_VIEW_DESIGN == _nId ); | |
| const Reference< XDataSource > xDataSource( m_xDataSource, UNO_QUERY ); | |
| const Reference< XComponent > xComponent( aDesigner.createNew( xDataSource, aCreationArgs ), UNO_QUERY ); | |
| onDocumentOpened( ::rtl::OUString(), E_QUERY, E_OPEN_DESIGN, xComponent, NULL ); | |
| } | |
| } | |
| break; | |
| case SID_DB_APP_DELETE: | |
| case SID_DB_APP_TABLE_DELETE: | |
| case SID_DB_APP_QUERY_DELETE: | |
| case SID_DB_APP_FORM_DELETE: | |
| case SID_DB_APP_REPORT_DELETE: | |
| deleteEntries(); | |
| break; | |
| case SID_DB_APP_RENAME: | |
| case SID_DB_APP_TABLE_RENAME: | |
| case SID_DB_APP_QUERY_RENAME: | |
| case SID_DB_APP_FORM_RENAME: | |
| case SID_DB_APP_REPORT_RENAME: | |
| renameEntry(); | |
| break; | |
| case SID_DB_APP_EDIT: | |
| case SID_DB_APP_EDIT_SQL_VIEW: | |
| case SID_DB_APP_TABLE_EDIT: | |
| case SID_DB_APP_QUERY_EDIT: | |
| case SID_DB_APP_FORM_EDIT: | |
| case SID_DB_APP_REPORT_EDIT: | |
| doAction( _nId, E_OPEN_DESIGN ); | |
| break; | |
| case SID_DB_APP_OPEN: | |
| case SID_DB_APP_TABLE_OPEN: | |
| case SID_DB_APP_QUERY_OPEN: | |
| case SID_DB_APP_FORM_OPEN: | |
| case SID_DB_APP_REPORT_OPEN: | |
| doAction( _nId, E_OPEN_NORMAL ); | |
| break; | |
| case SID_DB_APP_CONVERTTOVIEW: | |
| doAction( _nId, E_OPEN_NORMAL ); | |
| break; | |
| case SID_SELECTALL: | |
| getContainer()->selectAll(); | |
| InvalidateAll(); | |
| break; | |
| case SID_DB_APP_DSRELDESIGN: | |
| { | |
| Reference< XComponent > xRelationDesigner; | |
| if ( !m_pSubComponentManager->activateSubFrame( ::rtl::OUString(), SID_DB_APP_DSRELDESIGN, E_OPEN_DESIGN, xRelationDesigner ) ) | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( xConnection.is() ) | |
| { | |
| RelationDesigner aDesigner( getORB(), this, m_aCurrentFrame.getFrame() ); | |
| const Reference< XDataSource > xDataSource( m_xDataSource, UNO_QUERY ); | |
| const Reference< XComponent > xComponent( aDesigner.createNew( xDataSource ), UNO_QUERY ); | |
| onDocumentOpened( ::rtl::OUString(), SID_DB_APP_DSRELDESIGN, E_OPEN_DESIGN, xComponent, NULL ); | |
| } | |
| } | |
| } | |
| break; | |
| case SID_DB_APP_DSUSERADMIN: | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( xConnection.is() ) | |
| openDialog(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.UserAdministrationDialog"))); | |
| } | |
| break; | |
| case SID_DB_APP_TABLEFILTER: | |
| openTableFilterDialog(); | |
| askToReconnect(); | |
| break; | |
| case SID_DB_APP_REFRESH_TABLES: | |
| refreshTables(); | |
| break; | |
| case SID_DB_APP_DSPROPS: | |
| openDataSourceAdminDialog(); | |
| askToReconnect(); | |
| break; | |
| case SID_DB_APP_DSADVANCED_SETTINGS: | |
| openDialog(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.AdvancedDatabaseSettingsDialog"))); | |
| askToReconnect(); | |
| break; | |
| case SID_DB_APP_DSCONNECTION_TYPE: | |
| openDialog(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.DataSourceTypeChangeDialog"))); | |
| askToReconnect(); | |
| break; | |
| case ID_DIRECT_SQL: | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( xConnection.is() ) | |
| openDirectSQLDialog(); | |
| } | |
| break; | |
| case ID_MIGRATE_SCRIPTS: | |
| impl_migrateScripts_nothrow(); | |
| break; | |
| case SID_DB_APP_VIEW_TABLES: | |
| m_aSelectContainerEvent.Call( reinterpret_cast< void* >( E_TABLE ) ); | |
| break; | |
| case SID_DB_APP_VIEW_QUERIES: | |
| m_aSelectContainerEvent.Call( reinterpret_cast< void* >( E_QUERY ) ); | |
| break; | |
| case SID_DB_APP_VIEW_FORMS: | |
| m_aSelectContainerEvent.Call( reinterpret_cast< void* >( E_FORM ) ); | |
| break; | |
| case SID_DB_APP_VIEW_REPORTS: | |
| m_aSelectContainerEvent.Call( reinterpret_cast< void* >( E_REPORT ) ); | |
| break; | |
| case SID_DB_APP_DISABLE_PREVIEW: | |
| m_ePreviewMode = E_PREVIEWNONE; | |
| getContainer()->switchPreview(m_ePreviewMode); | |
| break; | |
| case SID_DB_APP_VIEW_DOCINFO_PREVIEW: | |
| m_ePreviewMode = E_DOCUMENTINFO; | |
| getContainer()->switchPreview(m_ePreviewMode); | |
| break; | |
| case SID_DB_APP_VIEW_DOC_PREVIEW: | |
| m_ePreviewMode = E_DOCUMENT; | |
| getContainer()->switchPreview(m_ePreviewMode); | |
| break; | |
| case SID_MAIL_SENDDOC: | |
| { | |
| SfxMailModel aSendMail; | |
| if ( aSendMail.AttachDocument(rtl::OUString(),getModel(), rtl::OUString()) == SfxMailModel::SEND_MAIL_OK ) | |
| aSendMail.Send( getFrame() ); | |
| } | |
| break; | |
| case SID_DB_APP_SENDREPORTASMAIL: | |
| doAction( _nId, E_OPEN_FOR_MAIL ); | |
| break; | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| InvalidateFeature(_nId); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::describeSupportedFeatures() | |
| { | |
| OApplicationController_CBASE::describeSupportedFeatures(); | |
| implDescribeSupportedFeature( ".uno:Save", ID_BROWSER_SAVEDOC, CommandGroup::DOCUMENT ); | |
| implDescribeSupportedFeature( ".uno:SaveAs", ID_BROWSER_SAVEASDOC, CommandGroup::DOCUMENT ); | |
| implDescribeSupportedFeature( ".uno:SendMail", SID_MAIL_SENDDOC, CommandGroup::DOCUMENT ); | |
| implDescribeSupportedFeature( ".uno:DBSendReportAsMail",SID_DB_APP_SENDREPORTASMAIL, | |
| CommandGroup::DOCUMENT ); | |
| implDescribeSupportedFeature( ".uno:DBSendReportToWriter",SID_DB_APP_SENDREPORTTOWRITER, | |
| CommandGroup::DOCUMENT ); | |
| implDescribeSupportedFeature( ".uno:DBNewForm", SID_APP_NEW_FORM, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewFolder", SID_APP_NEW_FOLDER, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewFormAutoPilot", SID_DB_FORM_NEW_PILOT, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewFormAutoPilotWithPreSelection", | |
| SID_FORM_CREATE_REPWIZ_PRE_SEL, | |
| CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBNewReport", SID_APP_NEW_REPORT, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewReportAutoPilot", | |
| ID_DOCUMENT_CREATE_REPWIZ, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewReportAutoPilotWithPreSelection", | |
| SID_REPORT_CREATE_REPWIZ_PRE_SEL, | |
| CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBNewQuery", ID_NEW_QUERY_DESIGN, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewQuerySql", ID_NEW_QUERY_SQL, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewQueryAutoPilot",ID_APP_NEW_QUERY_AUTO_PILOT, | |
| CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewTable", ID_NEW_TABLE_DESIGN, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewTableAutoPilot",ID_NEW_TABLE_DESIGN_AUTO_PILOT, | |
| CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewView", ID_NEW_VIEW_DESIGN, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBNewViewSQL", SID_DB_NEW_VIEW_SQL, CommandGroup::INSERT ); | |
| implDescribeSupportedFeature( ".uno:DBDelete", SID_DB_APP_DELETE, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:Delete", SID_DB_APP_DELETE, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBRename", SID_DB_APP_RENAME, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBEdit", SID_DB_APP_EDIT, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBEditSqlView", SID_DB_APP_EDIT_SQL_VIEW, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBOpen", SID_DB_APP_OPEN, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBTableDelete", SID_DB_APP_TABLE_DELETE, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBTableRename", SID_DB_APP_TABLE_RENAME, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBTableEdit", SID_DB_APP_TABLE_EDIT, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBTableOpen", SID_DB_APP_TABLE_OPEN, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBQueryDelete", SID_DB_APP_QUERY_DELETE, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBQueryRename", SID_DB_APP_QUERY_RENAME, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBQueryEdit", SID_DB_APP_QUERY_EDIT, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBQueryOpen", SID_DB_APP_QUERY_OPEN, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBFormDelete", SID_DB_APP_FORM_DELETE, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBFormRename", SID_DB_APP_FORM_RENAME, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBFormEdit", SID_DB_APP_FORM_EDIT, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBFormOpen", SID_DB_APP_FORM_OPEN, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBReportDelete", SID_DB_APP_REPORT_DELETE, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBReportRename", SID_DB_APP_REPORT_RENAME, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBReportEdit", SID_DB_APP_REPORT_EDIT, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBReportOpen", SID_DB_APP_REPORT_OPEN, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:SelectAll", SID_SELECTALL, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:Undo", ID_BROWSER_UNDO, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:Sortup", ID_BROWSER_SORTUP, CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:SortDown", ID_BROWSER_SORTDOWN, CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:DBRelationDesign", SID_DB_APP_DSRELDESIGN, CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBUserAdmin", SID_DB_APP_DSUSERADMIN, CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBTableFilter", SID_DB_APP_TABLEFILTER, CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBDSProperties", SID_DB_APP_DSPROPS, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBDSConnectionType", SID_DB_APP_DSCONNECTION_TYPE, | |
| CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBDSAdvancedSettings", | |
| SID_DB_APP_DSADVANCED_SETTINGS, | |
| CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:PasteSpecial", SID_DB_APP_PASTE_SPECIAL, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBConvertToView", SID_DB_APP_CONVERTTOVIEW, CommandGroup::EDIT ); | |
| implDescribeSupportedFeature( ".uno:DBRefreshTables", SID_DB_APP_REFRESH_TABLES, CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBDirectSQL", ID_DIRECT_SQL, CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBMigrateScripts", ID_MIGRATE_SCRIPTS, CommandGroup::APPLICATION ); | |
| implDescribeSupportedFeature( ".uno:DBViewTables", SID_DB_APP_VIEW_TABLES, CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:DBViewQueries", SID_DB_APP_VIEW_QUERIES, CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:DBViewForms", SID_DB_APP_VIEW_FORMS, CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:DBViewReports", SID_DB_APP_VIEW_REPORTS, CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:DBDisablePreview", SID_DB_APP_DISABLE_PREVIEW,CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:DBShowDocInfoPreview", | |
| SID_DB_APP_VIEW_DOCINFO_PREVIEW, | |
| CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:DBShowDocPreview", SID_DB_APP_VIEW_DOC_PREVIEW, | |
| CommandGroup::VIEW ); | |
| implDescribeSupportedFeature( ".uno:OpenUrl", SID_OPENURL, CommandGroup::APPLICATION ); | |
| // this one should not appear under Tools->Customize->Keyboard | |
| implDescribeSupportedFeature( ".uno:DBNewReportWithPreSelection", | |
| SID_APP_NEW_REPORT_PRE_SEL,CommandGroup::INTERNAL ); | |
| implDescribeSupportedFeature( ".uno:DBDSImport", SID_DB_APP_DSIMPORT, CommandGroup::INTERNAL); | |
| implDescribeSupportedFeature( ".uno:DBDSExport", SID_DB_APP_DSEXPORT, CommandGroup::INTERNAL); | |
| implDescribeSupportedFeature( ".uno:DBDBAdmin", SID_DB_APP_DBADMIN, CommandGroup::INTERNAL); | |
| // status info | |
| implDescribeSupportedFeature( ".uno:DBStatusType", SID_DB_APP_STATUS_TYPE, CommandGroup::INTERNAL); | |
| implDescribeSupportedFeature( ".uno:DBStatusDBName", SID_DB_APP_STATUS_DBNAME, CommandGroup::INTERNAL); | |
| implDescribeSupportedFeature( ".uno:DBStatusUserName", SID_DB_APP_STATUS_USERNAME, CommandGroup::INTERNAL); | |
| implDescribeSupportedFeature( ".uno:DBStatusHostName", SID_DB_APP_STATUS_HOSTNAME, CommandGroup::INTERNAL); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| OApplicationView* OApplicationController::getContainer() const | |
| { | |
| return static_cast< OApplicationView* >( getView() ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| // ::com::sun::star::container::XContainerListener | |
| void SAL_CALL OApplicationController::elementInserted( const ContainerEvent& _rEvent ) | |
| { | |
| ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| Reference< XContainer > xContainer(_rEvent.Source, UNO_QUERY); | |
| if ( ::std::find(m_aCurrentContainers.begin(),m_aCurrentContainers.end(),xContainer) != m_aCurrentContainers.end() ) | |
| { | |
| OSL_ENSURE(getContainer(),"View is NULL! -> GPF"); | |
| if ( getContainer() ) | |
| { | |
| ::rtl::OUString sName; | |
| _rEvent.Accessor >>= sName; | |
| ElementType eType = getElementType(xContainer); | |
| switch( eType ) | |
| { | |
| case E_TABLE: | |
| ensureConnection(); | |
| break; | |
| case E_FORM: | |
| case E_REPORT: | |
| { | |
| Reference< XContainer > xSubContainer(_rEvent.Element,UNO_QUERY); | |
| if ( xSubContainer.is() ) | |
| containerFound(xSubContainer); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| getContainer()->elementAdded(eType,sName,_rEvent.Element); | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void SAL_CALL OApplicationController::elementRemoved( const ContainerEvent& _rEvent ) | |
| { | |
| ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| Reference< XContainer > xContainer(_rEvent.Source, UNO_QUERY); | |
| if ( ::std::find(m_aCurrentContainers.begin(),m_aCurrentContainers.end(),xContainer) != m_aCurrentContainers.end() ) | |
| { | |
| OSL_ENSURE(getContainer(),"View is NULL! -> GPF"); | |
| ::rtl::OUString sName; | |
| _rEvent.Accessor >>= sName; | |
| ElementType eType = getElementType(xContainer); | |
| switch( eType ) | |
| { | |
| case E_TABLE: | |
| ensureConnection(); | |
| break; | |
| case E_FORM: | |
| case E_REPORT: | |
| { | |
| Reference<XContent> xContent(xContainer,UNO_QUERY); | |
| if ( xContent.is() ) | |
| { | |
| sName = xContent->getIdentifier()->getContentIdentifier() + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/")) + sName; | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| getContainer()->elementRemoved(eType,sName); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void SAL_CALL OApplicationController::elementReplaced( const ContainerEvent& _rEvent ) | |
| { | |
| ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| Reference< XContainer > xContainer(_rEvent.Source, UNO_QUERY); | |
| if ( ::std::find(m_aCurrentContainers.begin(),m_aCurrentContainers.end(),xContainer) != m_aCurrentContainers.end() ) | |
| { | |
| OSL_ENSURE(getContainer(),"View is NULL! -> GPF"); | |
| ::rtl::OUString sName; | |
| try | |
| { | |
| _rEvent.Accessor >>= sName; | |
| Reference<XConnection> xConnection; | |
| Reference<XPropertySet> xProp(_rEvent.Element,UNO_QUERY); | |
| ::rtl::OUString sNewName; | |
| ElementType eType = getElementType(xContainer); | |
| switch( eType ) | |
| { | |
| case E_TABLE: | |
| { | |
| ensureConnection(); | |
| if ( xProp.is() && m_xMetaData.is() ) | |
| sNewName = ::dbaui::composeTableName( m_xMetaData, xProp, ::dbtools::eInDataManipulation, false, false, false ); | |
| } | |
| break; | |
| case E_FORM: | |
| case E_REPORT: | |
| { | |
| Reference<XContent> xContent(xContainer,UNO_QUERY); | |
| if ( xContent.is() ) | |
| { | |
| sName = xContent->getIdentifier()->getContentIdentifier() + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/")) + sName; | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| // getContainer()->elementReplaced(getContainer()->getElementType(),sName,sNewName); | |
| } | |
| catch( Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| } | |
| namespace | |
| { | |
| ::rtl::OUString lcl_getToolBarResource(ElementType _eType) | |
| { | |
| ::rtl::OUString sToolbar; | |
| switch(_eType) | |
| { | |
| case E_TABLE: | |
| sToolbar = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/tableobjectbar" )); | |
| break; | |
| case E_QUERY: | |
| sToolbar = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/queryobjectbar" )); | |
| break; | |
| case E_FORM: | |
| sToolbar = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/formobjectbar" )); | |
| break; | |
| case E_REPORT: | |
| sToolbar = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/reportobjectbar" )); | |
| break; | |
| case E_NONE: | |
| break; | |
| default: | |
| OSL_ENSURE(0,"Invalid ElementType!"); | |
| break; | |
| } | |
| return sToolbar; | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OApplicationController::onContainerSelect(ElementType _eType) | |
| { | |
| OSL_ENSURE(getContainer(),"View is NULL! -> GPF"); | |
| if ( m_eCurrentType != _eType && _eType != E_NONE ) | |
| { | |
| SelectionGuard aSelGuard( *m_pSelectionNotifier ); | |
| if ( _eType == E_TABLE ) | |
| { | |
| try | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( xConnection.is() && getContainer()->getDetailView() ) | |
| { | |
| getContainer()->getDetailView()->createTablesPage(xConnection); | |
| Reference<XTablesSupplier> xTabSup(xConnection,UNO_QUERY); | |
| if ( xTabSup.is() ) | |
| addContainerListener(xTabSup->getTables()); | |
| } | |
| else | |
| { | |
| return sal_False; | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| return sal_False; | |
| } | |
| } | |
| Reference< XLayoutManager > xLayoutManager = getLayoutManager( getFrame() ); | |
| if ( xLayoutManager.is() ) | |
| { | |
| ::rtl::OUString sToolbar = lcl_getToolBarResource(_eType); | |
| ::rtl::OUString sDestroyToolbar = lcl_getToolBarResource(m_eCurrentType); | |
| xLayoutManager->lock(); | |
| xLayoutManager->destroyElement( sDestroyToolbar ); | |
| if ( sToolbar.getLength() ) | |
| { | |
| xLayoutManager->createElement( sToolbar ); | |
| xLayoutManager->requestElement( sToolbar ); | |
| } | |
| xLayoutManager->unlock(); | |
| xLayoutManager->doLayout(); | |
| } | |
| if ( _eType != E_TABLE && getContainer()->getDetailView() ) | |
| { | |
| Reference< XNameAccess > xContainer = getElements(_eType); | |
| addContainerListener(xContainer); | |
| getContainer()->getDetailView()->createPage(_eType,xContainer); | |
| } | |
| SelectionByElementType::iterator pendingSelection = m_aPendingSelection.find( _eType ); | |
| if ( pendingSelection != m_aPendingSelection.end() ) | |
| { | |
| Sequence< ::rtl::OUString > aSelected( pendingSelection->second.size() ); | |
| ::std::copy( pendingSelection->second.begin(), pendingSelection->second.end(), aSelected.getArray() ); | |
| getContainer()->selectElements( aSelected ); | |
| m_aPendingSelection.erase( pendingSelection ); | |
| } | |
| InvalidateAll(); | |
| } | |
| m_eCurrentType = _eType; | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| bool OApplicationController::onEntryDoubleClick( SvTreeListBox& _rTree ) | |
| { | |
| if ( getContainer() && getContainer()->isLeaf( _rTree.GetHdlEntry() ) ) | |
| { | |
| try | |
| { | |
| openElement( | |
| getContainer()->getQualifiedName( _rTree.GetHdlEntry() ), | |
| getContainer()->getElementType(), | |
| E_OPEN_NORMAL | |
| ); | |
| return true; // handled | |
| } | |
| catch(const Exception&) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return false; // not handled | |
| } | |
| // ----------------------------------------------------------------------------- | |
| bool OApplicationController::impl_isAlterableView_nothrow( const ::rtl::OUString& _rTableOrViewName ) const | |
| { | |
| OSL_PRECOND( m_xDataSourceConnection.is(), "OApplicationController::impl_isAlterableView_nothrow: no connection!" ); | |
| bool bIsAlterableView( false ); | |
| try | |
| { | |
| Reference< XViewsSupplier > xViewsSupp( m_xDataSourceConnection, UNO_QUERY ); | |
| Reference< XNameAccess > xViews; | |
| if ( xViewsSupp.is() ) | |
| xViews = xViewsSupp->getViews(); | |
| Reference< XAlterView > xAsAlterableView; | |
| if ( xViews.is() && xViews->hasByName( _rTableOrViewName ) ) | |
| xAsAlterableView.set( xViews->getByName( _rTableOrViewName ), UNO_QUERY ); | |
| bIsAlterableView = xAsAlterableView.is(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return bIsAlterableView; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Reference< XComponent > OApplicationController::openElement(const ::rtl::OUString& _sName, ElementType _eType, | |
| ElementOpenMode _eOpenMode, sal_uInt16 _nInstigatorCommand ) | |
| { | |
| return openElementWithArguments( _sName, _eType, _eOpenMode, _nInstigatorCommand, ::comphelper::NamedValueCollection() ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Reference< XComponent > OApplicationController::openElementWithArguments( const ::rtl::OUString& _sName, ElementType _eType, | |
| ElementOpenMode _eOpenMode, sal_uInt16 _nInstigatorCommand, const ::comphelper::NamedValueCollection& _rAdditionalArguments ) | |
| { | |
| OSL_PRECOND( getContainer(), "OApplicationController::openElementWithArguments: no view!" ); | |
| if ( !getContainer() ) | |
| return NULL; | |
| Reference< XComponent > xRet; | |
| if ( _eOpenMode == E_OPEN_DESIGN ) | |
| { | |
| // OJ: http://www.openoffice.org/issues/show_bug.cgi?id=30382 | |
| getContainer()->showPreview(NULL); | |
| } | |
| bool isStandaloneDocument = false; | |
| switch ( _eType ) | |
| { | |
| case E_REPORT: | |
| if ( _eOpenMode != E_OPEN_DESIGN ) | |
| { | |
| // reports which are opened in a mode other than design are no sub components of our application | |
| // component, but standalone documents. | |
| isStandaloneDocument = true; | |
| } | |
| // NO break! | |
| case E_FORM: | |
| { | |
| if ( isStandaloneDocument || !m_pSubComponentManager->activateSubFrame( _sName, _eType, _eOpenMode, xRet ) ) | |
| { | |
| ::std::auto_ptr< OLinkedDocumentsAccess > aHelper = getDocumentsAccess( _eType ); | |
| if ( !aHelper->isConnected() ) | |
| break; | |
| Reference< XComponent > xDefinition; | |
| xRet = aHelper->open( _sName, xDefinition, _eOpenMode, _rAdditionalArguments ); | |
| if ( !isStandaloneDocument ) | |
| onDocumentOpened( _sName, _eType, _eOpenMode, xRet, xDefinition ); | |
| } | |
| } | |
| break; | |
| case E_QUERY: | |
| case E_TABLE: | |
| { | |
| if ( !m_pSubComponentManager->activateSubFrame( _sName, _eType, _eOpenMode, xRet ) ) | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( !xConnection.is() ) | |
| break; | |
| ::std::auto_ptr< DatabaseObjectView > pDesigner; | |
| ::comphelper::NamedValueCollection aArguments( _rAdditionalArguments ); | |
| Any aDataSource; | |
| if ( _eOpenMode == E_OPEN_DESIGN ) | |
| { | |
| bool bAddViewTypeArg = false; | |
| if ( _eType == E_TABLE ) | |
| { | |
| if ( impl_isAlterableView_nothrow( _sName ) ) | |
| { | |
| pDesigner.reset( new QueryDesigner( getORB(), this, m_aCurrentFrame.getFrame(), true ) ); | |
| bAddViewTypeArg = true; | |
| } | |
| else | |
| { | |
| pDesigner.reset( new TableDesigner( getORB(), this, m_aCurrentFrame.getFrame() ) ); | |
| } | |
| } | |
| else if ( _eType == E_QUERY ) | |
| { | |
| pDesigner.reset( new QueryDesigner( getORB(), this, m_aCurrentFrame.getFrame(), false ) ); | |
| bAddViewTypeArg = true; | |
| } | |
| aDataSource <<= m_xDataSource; | |
| if ( bAddViewTypeArg ) | |
| { | |
| const bool bQueryGraphicalMode =( _nInstigatorCommand != SID_DB_APP_EDIT_SQL_VIEW ); | |
| aArguments.put( (::rtl::OUString)PROPERTY_GRAPHICAL_DESIGN, bQueryGraphicalMode ); | |
| } | |
| } | |
| else | |
| { | |
| pDesigner.reset( new ResultSetBrowser( getORB(), this, m_aCurrentFrame.getFrame(), _eType == E_TABLE ) ); | |
| if ( !aArguments.has( (::rtl::OUString)PROPERTY_SHOWMENU ) ) | |
| aArguments.put( (::rtl::OUString)PROPERTY_SHOWMENU, makeAny( (sal_Bool)sal_True ) ); | |
| aDataSource <<= getDatabaseName(); | |
| } | |
| xRet.set( pDesigner->openExisting( aDataSource, _sName, aArguments ) ); | |
| onDocumentOpened( _sName, _eType, _eOpenMode, xRet, NULL ); | |
| } | |
| } | |
| break; | |
| default: | |
| OSL_ENSURE( false, "OApplicationController::openElement: illegal object type!" ); | |
| break; | |
| } | |
| return xRet; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| IMPL_LINK( OApplicationController, OnSelectContainer, void*, _pType ) | |
| { | |
| ElementType eType = (ElementType)reinterpret_cast< sal_IntPtr >( _pType ); | |
| getContainer()->selectContainer(eType); | |
| return 0L; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| IMPL_LINK( OApplicationController, OnCreateWithPilot, void*, _pType ) | |
| { | |
| ElementType eType = (ElementType)reinterpret_cast< sal_IntPtr >( _pType ); | |
| newElementWithPilot( eType ); | |
| return 0L; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::newElementWithPilot( ElementType _eType ) | |
| { | |
| CloseVeto aKeepDoc( getFrame() ); | |
| // prevent the document being closed while the wizard is open | |
| OSL_ENSURE( getContainer(), "OApplicationController::newElementWithPilot: without a view?" ); | |
| switch ( _eType ) | |
| { | |
| case E_REPORT: | |
| case E_FORM: | |
| { | |
| ::std::auto_ptr<OLinkedDocumentsAccess> aHelper = getDocumentsAccess(_eType); | |
| if ( aHelper->isConnected() ) | |
| { | |
| sal_Int32 nCommandType = -1; | |
| const ::rtl::OUString sCurrentSelected( getCurrentlySelectedName( nCommandType ) ); | |
| if ( E_REPORT == _eType ) | |
| aHelper->newReportWithPilot( nCommandType, sCurrentSelected ); | |
| else | |
| aHelper->newFormWithPilot( nCommandType, sCurrentSelected ); | |
| } | |
| } | |
| break; | |
| case E_QUERY: | |
| case E_TABLE: | |
| { | |
| ::std::auto_ptr<OLinkedDocumentsAccess> aHelper = getDocumentsAccess(_eType); | |
| if ( aHelper->isConnected() ) | |
| { | |
| if ( E_QUERY == _eType ) | |
| aHelper->newQueryWithPilot(); | |
| else | |
| aHelper->newTableWithPilot(); | |
| } | |
| } | |
| break; | |
| case E_NONE: | |
| break; | |
| } | |
| // no need for onDocumentOpened, the table wizard opens the created table by using | |
| // XDatabaseDocumentUI::loadComponent method. | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Reference< XComponent > OApplicationController::newElement( ElementType _eType, const ::comphelper::NamedValueCollection& i_rAdditionalArguments, | |
| Reference< XComponent >& o_rDocumentDefinition ) | |
| { | |
| OSL_ENSURE(getContainer(),"View is NULL! -> GPF"); | |
| Reference< XComponent > xComponent; | |
| o_rDocumentDefinition.clear(); | |
| switch ( _eType ) | |
| { | |
| case E_FORM: | |
| case E_REPORT: | |
| { | |
| ::std::auto_ptr<OLinkedDocumentsAccess> aHelper = getDocumentsAccess( _eType ); | |
| if ( !aHelper->isConnected() ) | |
| break; | |
| xComponent = aHelper->newDocument( _eType == E_FORM ? ID_FORM_NEW_TEXT : ID_REPORT_NEW_TEXT, i_rAdditionalArguments, o_rDocumentDefinition ); | |
| } | |
| break; | |
| case E_QUERY: | |
| case E_TABLE: | |
| { | |
| ::std::auto_ptr< DatabaseObjectView > pDesigner; | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( !xConnection.is() ) | |
| break; | |
| if ( _eType == E_TABLE ) | |
| { | |
| pDesigner.reset( new TableDesigner( getORB(), this, getFrame() ) ); | |
| } | |
| else if ( _eType == E_QUERY ) | |
| { | |
| pDesigner.reset( new QueryDesigner( getORB(), this, getFrame(), false ) ); | |
| } | |
| Reference< XDataSource > xDataSource( m_xDataSource, UNO_QUERY ); | |
| xComponent.set( pDesigner->createNew( xDataSource, i_rAdditionalArguments ), UNO_QUERY ); | |
| } | |
| break; | |
| default: | |
| OSL_ENSURE( false, "OApplicationController::newElement: illegal type!" ); | |
| break; | |
| } | |
| if ( xComponent.is() ) | |
| onDocumentOpened( ::rtl::OUString(), _eType, E_OPEN_DESIGN, xComponent, o_rDocumentDefinition ); | |
| return xComponent; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::addContainerListener(const Reference<XNameAccess>& _xCollection) | |
| { | |
| try | |
| { | |
| Reference< XContainer > xCont(_xCollection, UNO_QUERY); | |
| if ( xCont.is() ) | |
| { | |
| // add as listener to get notified if elements are inserted or removed | |
| TContainerVector::iterator aFind = ::std::find(m_aCurrentContainers.begin(),m_aCurrentContainers.end(),xCont); | |
| if ( aFind == m_aCurrentContainers.end() ) | |
| { | |
| xCont->addContainerListener(this); | |
| m_aCurrentContainers.push_back(xCont); | |
| } | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::renameEntry() | |
| { | |
| ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| OSL_ENSURE(getContainer(),"View is NULL! -> GPF"); | |
| ::std::vector< ::rtl::OUString> aList; | |
| getSelectionElementNames(aList); | |
| Reference< XNameAccess > xContainer = getElements(getContainer()->getElementType()); | |
| OSL_ENSURE(aList.size() == 1,"Invalid rename call here. More than one element!"); | |
| if ( aList.empty() ) | |
| return; | |
| try | |
| { | |
| if ( xContainer.is() ) | |
| { | |
| ::std::auto_ptr< IObjectNameCheck > pNameChecker; | |
| ::std::auto_ptr< OSaveAsDlg > aDialog; | |
| Reference<XRename> xRename; | |
| const ElementType eType = getContainer()->getElementType(); | |
| switch( eType ) | |
| { | |
| case E_FORM: | |
| case E_REPORT: | |
| { | |
| Reference<XHierarchicalNameContainer> xHNames(xContainer, UNO_QUERY); | |
| if ( xHNames.is() ) | |
| { | |
| String sLabel; | |
| if ( eType == E_FORM ) | |
| sLabel = String(ModuleRes( STR_FRM_LABEL )); | |
| else | |
| sLabel = String(ModuleRes( STR_RPT_LABEL )); | |
| ::rtl::OUString sName = *aList.begin(); | |
| if ( xHNames->hasByHierarchicalName(sName) ) | |
| { | |
| xRename.set(xHNames->getByHierarchicalName(sName),UNO_QUERY); | |
| Reference<XChild> xChild(xRename,UNO_QUERY); | |
| if ( xChild.is() ) | |
| { | |
| Reference<XHierarchicalNameContainer> xParent(xChild->getParent(),UNO_QUERY); | |
| if ( xParent.is() ) | |
| { | |
| xHNames = xParent; | |
| Reference<XPropertySet>(xRename,UNO_QUERY)->getPropertyValue(PROPERTY_NAME) >>= sName; | |
| } | |
| } | |
| pNameChecker.reset( new HierarchicalNameCheck( xHNames.get(), String() ) ); | |
| aDialog.reset( new OSaveAsDlg( | |
| getView(), getORB(), sName, sLabel, *pNameChecker, SAD_TITLE_RENAME ) ); | |
| } | |
| } | |
| } | |
| break; | |
| case E_TABLE: | |
| ensureConnection(); | |
| if ( !getConnection().is() ) | |
| break; | |
| // NO break | |
| case E_QUERY: | |
| if ( xContainer->hasByName(*aList.begin()) ) | |
| { | |
| xRename.set(xContainer->getByName(*aList.begin()),UNO_QUERY); | |
| sal_Int32 nCommandType = eType == E_QUERY ? CommandType::QUERY : CommandType::TABLE; | |
| ensureConnection(); | |
| pNameChecker.reset( new DynamicTableOrQueryNameCheck( getConnection(), nCommandType ) ); | |
| aDialog.reset( new OSaveAsDlg( | |
| getView(), nCommandType, getORB(), getConnection(), | |
| *aList.begin(), *pNameChecker, SAD_TITLE_RENAME ) ); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| if ( xRename.is() && aDialog.get() ) | |
| { | |
| sal_Bool bTryAgain = sal_True; | |
| while( bTryAgain ) | |
| { | |
| if ( aDialog->Execute() == RET_OK ) | |
| { | |
| try | |
| { | |
| ::rtl::OUString sNewName; | |
| if ( eType == E_TABLE ) | |
| { | |
| ::rtl::OUString sName = aDialog->getName(); | |
| ::rtl::OUString sCatalog = aDialog->getCatalog(); | |
| ::rtl::OUString sSchema = aDialog->getSchema(); | |
| sNewName = ::dbtools::composeTableName( m_xMetaData, sCatalog, sSchema, sName, sal_False, ::dbtools::eInDataManipulation ); | |
| } | |
| else | |
| sNewName = aDialog->getName(); | |
| ::rtl::OUString sOldName = *aList.begin(); | |
| if ( eType == E_FORM || eType == E_REPORT ) | |
| { | |
| Reference<XContent> xContent(xRename,UNO_QUERY); | |
| if ( xContent.is() ) | |
| { | |
| sOldName = xContent->getIdentifier()->getContentIdentifier(); | |
| } | |
| } | |
| xRename->rename(sNewName); | |
| if ( eType == E_TABLE ) | |
| { | |
| Reference<XPropertySet> xProp(xRename,UNO_QUERY); | |
| sNewName = ::dbaui::composeTableName( m_xMetaData, xProp, ::dbtools::eInDataManipulation, false, false, false ); | |
| } | |
| getContainer()->elementReplaced( eType , sOldName, sNewName ); | |
| bTryAgain = sal_False; | |
| } | |
| catch(const SQLException& ) | |
| { | |
| showError( SQLExceptionInfo( ::cppu::getCaughtException() ) ); | |
| } | |
| catch(const ElementExistException& e) | |
| { | |
| static ::rtl::OUString sStatus = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000")); | |
| String sMsg = String( ModuleRes( STR_NAME_ALREADY_EXISTS ) ); | |
| sMsg.SearchAndReplace('#',e.Message); | |
| showError(SQLExceptionInfo(SQLException(sMsg, e.Context, sStatus, 0, Any()))); | |
| } | |
| catch(const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| else | |
| bTryAgain = sal_False; | |
| } | |
| } | |
| } | |
| } | |
| catch(const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::onSelectionChanged() | |
| { | |
| InvalidateAll(); | |
| SelectionGuard aSelGuard( *m_pSelectionNotifier ); | |
| OApplicationView* pView = getContainer(); | |
| if ( !pView ) | |
| return; | |
| if ( pView->getSelectionCount() == 1 ) | |
| { | |
| const ElementType eType = pView->getElementType(); | |
| if ( pView->isALeafSelected() ) | |
| { | |
| const ::rtl::OUString sName = pView->getQualifiedName( NULL /* means 'first selected' */ ); | |
| showPreviewFor( eType, sName ); | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::showPreviewFor(const ElementType _eType,const ::rtl::OUString& _sName) | |
| { | |
| if ( m_ePreviewMode == E_PREVIEWNONE ) | |
| return; | |
| OApplicationView* pView = getContainer(); | |
| if ( !pView ) | |
| return; | |
| try | |
| { | |
| switch( _eType ) | |
| { | |
| case E_FORM: | |
| case E_REPORT: | |
| { | |
| Reference< XHierarchicalNameAccess > xContainer( getElements( _eType ), UNO_QUERY_THROW ); | |
| Reference< XContent> xContent( xContainer->getByHierarchicalName( _sName ), UNO_QUERY_THROW ); | |
| pView->showPreview( xContent ); | |
| } | |
| break; | |
| case E_TABLE: | |
| case E_QUERY: | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( xConnection.is() ) | |
| pView->showPreview( getDatabaseName(), xConnection, _sName, _eType == E_TABLE ); | |
| } | |
| return; | |
| default: | |
| OSL_ENSURE( false, "OApplicationController::showPreviewFor: unexpected element type!" ); | |
| break; | |
| } | |
| } | |
| catch( const SQLException& ) | |
| { | |
| showError( SQLExceptionInfo( ::cppu::getCaughtException() ) ); | |
| } | |
| catch(const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| IMPL_LINK( OApplicationController, OnClipboardChanged, void*, EMPTYARG ) | |
| { | |
| return OnInvalidateClipboard( NULL ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| IMPL_LINK(OApplicationController, OnInvalidateClipboard, void*, EMPTYARG) | |
| { | |
| InvalidateFeature(ID_BROWSER_CUT); | |
| InvalidateFeature(ID_BROWSER_COPY); | |
| InvalidateFeature(ID_BROWSER_PASTE); | |
| InvalidateFeature(SID_DB_APP_PASTE_SPECIAL); | |
| return 0L; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::onCutEntry() | |
| { | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::onCopyEntry() | |
| { | |
| Execute(ID_BROWSER_COPY,Sequence<PropertyValue>()); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::onPasteEntry() | |
| { | |
| Execute(ID_BROWSER_PASTE,Sequence<PropertyValue>()); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::onDeleteEntry() | |
| { | |
| ElementType eType = getContainer()->getElementType(); | |
| sal_uInt16 nId = 0; | |
| switch(eType) | |
| { | |
| case E_TABLE: | |
| nId = SID_DB_APP_TABLE_DELETE; | |
| break; | |
| case E_QUERY: | |
| nId = SID_DB_APP_QUERY_DELETE; | |
| break; | |
| case E_FORM: | |
| nId = SID_DB_APP_FORM_DELETE; | |
| break; | |
| case E_REPORT: | |
| nId = SID_DB_APP_REPORT_DELETE; | |
| break; | |
| default: | |
| OSL_ENSURE(0,"Invalid ElementType!"); | |
| break; | |
| } | |
| executeChecked(nId,Sequence<PropertyValue>()); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::executeUnChecked(const URL& _rCommand, const Sequence< PropertyValue>& aArgs) | |
| { | |
| OApplicationController_CBASE::executeUnChecked( _rCommand, aArgs ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::executeChecked(const URL& _rCommand, const Sequence< PropertyValue>& aArgs) | |
| { | |
| OApplicationController_CBASE::executeChecked( _rCommand, aArgs ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::executeUnChecked(sal_uInt16 _nCommandId, const Sequence< PropertyValue>& aArgs) | |
| { | |
| OApplicationController_CBASE::executeUnChecked( _nCommandId, aArgs ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::executeChecked(sal_uInt16 _nCommandId, const Sequence< PropertyValue>& aArgs) | |
| { | |
| OApplicationController_CBASE::executeChecked( _nCommandId, aArgs ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OApplicationController::isCommandEnabled(sal_uInt16 _nCommandId) const | |
| { | |
| return OApplicationController_CBASE::isCommandEnabled( _nCommandId ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OApplicationController::isCommandEnabled( const ::rtl::OUString& _rCompleteCommandURL ) const | |
| { | |
| return OApplicationController_CBASE::isCommandEnabled( _rCompleteCommandURL ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_uInt16 OApplicationController::registerCommandURL( const ::rtl::OUString& _rCompleteCommandURL ) | |
| { | |
| return OApplicationController_CBASE::registerCommandURL( _rCompleteCommandURL ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::notifyHiContrastChanged() | |
| { | |
| OApplicationController_CBASE::notifyHiContrastChanged(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Reference< XController > OApplicationController::getXController() | |
| { | |
| return OApplicationController_CBASE::getXController(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| bool OApplicationController::interceptUserInput( const NotifyEvent& _rEvent ) | |
| { | |
| return OApplicationController_CBASE::interceptUserInput( _rEvent ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| PopupMenu* OApplicationController::getContextMenu( Control& /*_rControl*/ ) const | |
| { | |
| return new PopupMenu( ModuleRes( RID_MENU_APP_EDIT ) ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| IController& OApplicationController::getCommandController() | |
| { | |
| return *static_cast< IApplicationController* >( this ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| ::cppu::OInterfaceContainerHelper* OApplicationController::getContextMenuInterceptors() | |
| { | |
| return &m_aContextMenuInterceptors; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Any OApplicationController::getCurrentSelection( Control& _rControl ) const | |
| { | |
| Sequence< NamedDatabaseObject > aSelection; | |
| getContainer()->describeCurrentSelectionForControl( _rControl, aSelection ); | |
| return makeAny( aSelection ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OApplicationController::requestQuickHelp( const SvLBoxEntry* /*_pEntry*/, String& /*_rText*/ ) const | |
| { | |
| return sal_False; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OApplicationController::requestDrag( sal_Int8 /*_nAction*/, const Point& /*_rPosPixel*/ ) | |
| { | |
| TransferableHelper* pTransfer = NULL; | |
| if ( getContainer() && getContainer()->getSelectionCount() ) | |
| { | |
| try | |
| { | |
| pTransfer = copyObject( ); | |
| Reference< XTransferable> xEnsureDelete = pTransfer; | |
| if ( pTransfer && getContainer()->getDetailView() ) | |
| { | |
| ElementType eType = getContainer()->getElementType(); | |
| pTransfer->StartDrag( getContainer()->getDetailView()->getTreeWindow(), ((eType == E_FORM || eType == E_REPORT) ? DND_ACTION_COPYMOVE : DND_ACTION_COPY) ); | |
| } | |
| } | |
| catch(const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return NULL != pTransfer; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Int8 OApplicationController::queryDrop( const AcceptDropEvent& _rEvt, const DataFlavorExVector& _rFlavors ) | |
| { | |
| sal_Int8 nActionAskedFor = _rEvt.mnAction; | |
| // check if we're a table or query container | |
| OApplicationView* pView = getContainer(); | |
| if ( pView && !isDataSourceReadOnly() ) | |
| { | |
| ElementType eType = pView->getElementType(); | |
| if ( eType != E_NONE && (eType != E_TABLE || !isConnectionReadOnly()) ) | |
| { | |
| // check for the concrete type | |
| if(::std::find_if(_rFlavors.begin(),_rFlavors.end(),TAppSupportedSotFunctor(eType,sal_True)) != _rFlavors.end()) | |
| return DND_ACTION_COPY; | |
| if ( eType == E_FORM || eType == E_REPORT ) | |
| { | |
| sal_Int8 nAction = OComponentTransferable::canExtractComponentDescriptor(_rFlavors,eType == E_FORM) ? DND_ACTION_COPY : DND_ACTION_NONE; | |
| if ( nAction != DND_ACTION_NONE ) | |
| { | |
| SvLBoxEntry* pHitEntry = pView->getEntry(_rEvt.maPosPixel); | |
| ::rtl::OUString sName; | |
| if ( pHitEntry ) | |
| { | |
| sName = pView->getQualifiedName( pHitEntry ); | |
| if ( sName.getLength() ) | |
| { | |
| Reference< XHierarchicalNameAccess > xContainer(getElements(pView->getElementType()),UNO_QUERY); | |
| if ( xContainer.is() && xContainer->hasByHierarchicalName(sName) ) | |
| { | |
| Reference< XHierarchicalNameAccess > xHitObject(xContainer->getByHierarchicalName(sName),UNO_QUERY); | |
| if ( xHitObject.is() ) | |
| nAction = nActionAskedFor & DND_ACTION_COPYMOVE; | |
| } | |
| else | |
| nAction = DND_ACTION_NONE; | |
| } | |
| } | |
| /*else | |
| nAction = nActionAskedFor & DND_ACTION_COPYMOVE; | |
| */ | |
| } | |
| return nAction; | |
| } | |
| } | |
| } | |
| return DND_ACTION_NONE; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Int8 OApplicationController::executeDrop( const ExecuteDropEvent& _rEvt ) | |
| { | |
| OApplicationView* pView = getContainer(); | |
| if ( !pView || pView->getElementType() == E_NONE ) | |
| { | |
| DBG_ERROR("OApplicationController::executeDrop: what the hell did queryDrop do?"); | |
| // queryDrop shoud not have allowed us to reach this situation .... | |
| return DND_ACTION_NONE; | |
| } | |
| // a TransferableDataHelper for accessing the dropped data | |
| TransferableDataHelper aDroppedData(_rEvt.maDropEvent.Transferable); | |
| // reset the data of the previous async drop (if any) | |
| if ( m_nAsyncDrop ) | |
| Application::RemoveUserEvent(m_nAsyncDrop); | |
| m_nAsyncDrop = 0; | |
| m_aAsyncDrop.aDroppedData.clear(); | |
| m_aAsyncDrop.nType = pView->getElementType(); | |
| m_aAsyncDrop.nAction = _rEvt.mnAction; | |
| m_aAsyncDrop.bError = sal_False; | |
| m_aAsyncDrop.bHtml = sal_False; | |
| m_aAsyncDrop.aUrl = ::rtl::OUString(); | |
| // loop through the available formats and see what we can do ... | |
| // first we have to check if it is our own format, if not we have to copy the stream :-( | |
| if ( ODataAccessObjectTransferable::canExtractObjectDescriptor(aDroppedData.GetDataFlavorExVector()) ) | |
| { | |
| m_aAsyncDrop.aDroppedData = ODataAccessObjectTransferable::extractObjectDescriptor(aDroppedData); | |
| // asyncron because we some dialogs and we aren't allowed to show them while in D&D | |
| m_nAsyncDrop = Application::PostUserEvent(LINK(this, OApplicationController, OnAsyncDrop)); | |
| return DND_ACTION_COPY; | |
| } | |
| else if ( OComponentTransferable::canExtractComponentDescriptor(aDroppedData.GetDataFlavorExVector(),m_aAsyncDrop.nType == E_FORM) ) | |
| { | |
| m_aAsyncDrop.aDroppedData = OComponentTransferable::extractComponentDescriptor(aDroppedData); | |
| SvLBoxEntry* pHitEntry = pView->getEntry(_rEvt.maPosPixel); | |
| if ( pHitEntry ) | |
| m_aAsyncDrop.aUrl = pView->getQualifiedName( pHitEntry ); | |
| sal_Int8 nAction = _rEvt.mnAction; | |
| Reference<XContent> xContent; | |
| m_aAsyncDrop.aDroppedData[daComponent] >>= xContent; | |
| if ( xContent.is() ) | |
| { | |
| ::rtl::OUString sName = xContent->getIdentifier()->getContentIdentifier(); | |
| sal_Int32 nIndex = 0; | |
| sName = sName.copy(sName.getToken(0,'/',nIndex).getLength() + 1); | |
| if ( m_aAsyncDrop.aUrl.Len() >= sName.getLength() && 0 == sName.compareTo(m_aAsyncDrop.aUrl,sName.getLength()) ) | |
| { | |
| m_aAsyncDrop.aDroppedData.clear(); | |
| return DND_ACTION_NONE; | |
| } | |
| // check if move is allowed, if another object with the same name exists only copy is allowed | |
| Reference< XHierarchicalNameAccess > xContainer(getElements(m_aAsyncDrop.nType),UNO_QUERY); | |
| Reference<XNameAccess> xNameAccess(xContainer,UNO_QUERY); | |
| if ( m_aAsyncDrop.aUrl.Len() && xContainer.is() && xContainer->hasByHierarchicalName(m_aAsyncDrop.aUrl) ) | |
| xNameAccess.set(xContainer->getByHierarchicalName(m_aAsyncDrop.aUrl),UNO_QUERY); | |
| if ( xNameAccess.is() ) | |
| { | |
| Reference<XPropertySet> xProp(xContent,UNO_QUERY); | |
| if ( xProp.is() ) | |
| { | |
| xProp->getPropertyValue(PROPERTY_NAME) >>= sName; | |
| if ( xNameAccess.is() && xNameAccess->hasByName(sName) ) | |
| nAction &= ~DND_ACTION_MOVE; | |
| } | |
| else | |
| nAction &= ~DND_ACTION_MOVE; | |
| } | |
| } | |
| if ( nAction != DND_ACTION_NONE ) | |
| { | |
| m_aAsyncDrop.nAction = nAction; | |
| // asyncron because we some dialogs and we aren't allowed to show them while in D&D | |
| m_nAsyncDrop = Application::PostUserEvent(LINK(this, OApplicationController, OnAsyncDrop)); | |
| } | |
| else | |
| m_aAsyncDrop.aDroppedData.clear(); | |
| return nAction; | |
| } | |
| else | |
| { | |
| SharedConnection xConnection( ensureConnection() ); | |
| if ( xConnection.is() && m_aTableCopyHelper.copyTagTable( aDroppedData, m_aAsyncDrop, xConnection ) ) | |
| { | |
| // asyncron because we some dialogs and we aren't allowed to show them while in D&D | |
| m_nAsyncDrop = Application::PostUserEvent(LINK(this, OApplicationController, OnAsyncDrop)); | |
| return DND_ACTION_COPY; | |
| } | |
| } | |
| return DND_ACTION_NONE; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Reference< XModel > SAL_CALL OApplicationController::getModel(void) | |
| { | |
| return m_xModel; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::onAttachedFrame() | |
| { | |
| sal_Int32 nConnectedControllers( 0 ); | |
| try | |
| { | |
| Reference< XModel2 > xModel( m_xModel, UNO_QUERY_THROW ); | |
| Reference< XEnumeration > xEnumControllers( xModel->getControllers(), UNO_SET_THROW ); | |
| while ( xEnumControllers->hasMoreElements() ) | |
| { | |
| Reference< XController > xController( xEnumControllers->nextElement(), UNO_QUERY_THROW ); | |
| ++nConnectedControllers; | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| if ( nConnectedControllers > 1 ) | |
| { // we are not the first connected controller, there were already others | |
| return; | |
| } | |
| m_aControllerConnectedEvent.Call(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| IMPL_LINK( OApplicationController, OnFirstControllerConnected, void*, /**/ ) | |
| { | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| if ( !m_xModel.is() ) | |
| { | |
| OSL_ENSURE( false, "OApplicationController::OnFirstControllerConnected: too late!" ); | |
| } | |
| // if we have forms or reports which contain macros/scripts, then show a warning | |
| // which suggests the user to migrate them to the database document | |
| Reference< XEmbeddedScripts > xDocumentScripts( m_xModel, UNO_QUERY ); | |
| if ( xDocumentScripts.is() ) | |
| { | |
| // no need to show this warning, obviously the document supports embedding scripts | |
| // into itself, so there are no "old-style" forms/reports which have macros/scripts | |
| // themselves | |
| return 0L; | |
| } | |
| try | |
| { | |
| // If the migration just happened, but was not successful, the document is reloaded. | |
| // In this case, we should not show the warning, again. | |
| ::comphelper::NamedValueCollection aModelArgs( m_xModel->getArgs() ); | |
| if ( aModelArgs.getOrDefault( "SuppressMigrationWarning", sal_False ) ) | |
| return 0L; | |
| // also, if the document is read-only, then no migration is possible, and the | |
| // respective menu entry is hidden. So, don't show the warning in this case, too. | |
| if ( Reference< XStorable >( m_xModel, UNO_QUERY_THROW )->isReadonly() ) | |
| return 0L; | |
| SQLWarning aWarning; | |
| aWarning.Message = String( ModuleRes( STR_SUB_DOCS_WITH_SCRIPTS ) ); | |
| SQLException aDetail; | |
| aDetail.Message = String( ModuleRes( STR_SUB_DOCS_WITH_SCRIPTS_DETAIL ) ); | |
| aWarning.NextException <<= aDetail; | |
| ::comphelper::ComponentContext aContext( getORB() ); | |
| Sequence< Any > aArgs(1); | |
| aArgs[0] <<= NamedValue( PROPERTY_SQLEXCEPTION, makeAny( aWarning ) ); | |
| Reference< XExecutableDialog > xDialog( | |
| aContext.createComponentWithArguments( "com.sun.star.sdb.ErrorMessageDialog", aArgs ), | |
| UNO_QUERY_THROW ); | |
| xDialog->execute(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return 1L; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void SAL_CALL OApplicationController::attachFrame( const Reference< XFrame > & i_rxFrame ) | |
| { | |
| OApplicationController_CBASE::attachFrame( i_rxFrame ); | |
| if ( getFrame().is() ) | |
| onAttachedFrame(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool SAL_CALL OApplicationController::attachModel(const Reference< XModel > & _rxModel) | |
| { | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| const Reference< XOfficeDatabaseDocument > xOfficeDoc( _rxModel, UNO_QUERY ); | |
| const Reference< XModifiable > xDocModify( _rxModel, UNO_QUERY ); | |
| if ( ( !xOfficeDoc.is() || !xDocModify.is() ) && _rxModel.is() ) | |
| { | |
| DBG_ERROR( "OApplicationController::attachModel: invalid model!" ); | |
| return sal_False; | |
| } | |
| if ( m_xModel.is() && ( m_xModel != _rxModel ) && ( _rxModel.is() ) ) | |
| { | |
| OSL_ENSURE( false, "OApplicationController::attachModel: missing implementation: setting a new model while we have another one!" ); | |
| // we'd need to completely update our view here, close sub components, and the like | |
| return sal_False; | |
| } | |
| const ::rtl::OUString aPropertyNames[] = | |
| { | |
| PROPERTY_URL, PROPERTY_USER | |
| }; | |
| // disconnect from old model | |
| try | |
| { | |
| if ( m_xDataSource.is() ) | |
| { | |
| for ( size_t i=0; i < sizeof( aPropertyNames ) / sizeof( aPropertyNames[0] ); ++i ) | |
| { | |
| m_xDataSource->removePropertyChangeListener( aPropertyNames[i], this ); | |
| } | |
| } | |
| Reference< XModifyBroadcaster > xBroadcaster( m_xModel, UNO_QUERY ); | |
| if ( xBroadcaster.is() ) | |
| xBroadcaster->removeModifyListener( this ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| m_xModel = _rxModel; | |
| m_xDocumentModify = xDocModify; | |
| m_xDataSource.set( xOfficeDoc.is() ? xOfficeDoc->getDataSource() : Reference< XDataSource >(), UNO_QUERY ); | |
| // connect to new model | |
| try | |
| { | |
| if ( m_xDataSource.is() ) | |
| { | |
| for ( size_t i=0; i < sizeof( aPropertyNames ) / sizeof( aPropertyNames[0] ); ++i ) | |
| { | |
| m_xDataSource->addPropertyChangeListener( aPropertyNames[i], this ); | |
| } | |
| } | |
| Reference< XModifyBroadcaster > xBroadcaster( m_xModel, UNO_QUERY_THROW ); | |
| xBroadcaster->addModifyListener( this ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| // initial preview mode | |
| if ( m_xDataSource.is() ) | |
| { | |
| try | |
| { | |
| // to get the 'modified' for the data source | |
| ::comphelper::NamedValueCollection aLayoutInfo( m_xDataSource->getPropertyValue( PROPERTY_LAYOUTINFORMATION ) ); | |
| if ( aLayoutInfo.has( (rtl::OUString)INFO_PREVIEW ) ) | |
| { | |
| const sal_Int32 nPreviewMode( aLayoutInfo.getOrDefault( (rtl::OUString)INFO_PREVIEW, (sal_Int32)0 ) ); | |
| m_ePreviewMode = static_cast< PreviewMode >( nPreviewMode ); | |
| if ( getView() ) | |
| getContainer()->switchPreview( m_ePreviewMode ); | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::containerFound( const Reference< XContainer >& _xContainer) | |
| { | |
| try | |
| { | |
| if ( _xContainer.is() ) | |
| { | |
| m_aCurrentContainers.push_back(_xContainer); | |
| _xContainer->addContainerListener(this); | |
| } | |
| } | |
| catch(const Exception&) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| ::rtl::OUString OApplicationController::getCurrentlySelectedName(sal_Int32& _rnCommandType) const | |
| { | |
| _rnCommandType = ( (getContainer()->getElementType() == E_QUERY) | |
| ? CommandType::QUERY : ( (getContainer()->getElementType() == E_TABLE) ? CommandType::TABLE : -1 )); | |
| ::rtl::OUString sName; | |
| if ( _rnCommandType != -1 ) | |
| { | |
| try | |
| { | |
| sName = getContainer()->getQualifiedName( NULL ); | |
| OSL_ENSURE( sName.getLength(), "OApplicationController::getCurrentlySelectedName: no name given!" ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return sName; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void SAL_CALL OApplicationController::addSelectionChangeListener( const Reference< view::XSelectionChangeListener >& _Listener ) | |
| { | |
| m_pSelectionNotifier->addListener( _Listener ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void SAL_CALL OApplicationController::removeSelectionChangeListener( const Reference< view::XSelectionChangeListener >& _Listener ) | |
| { | |
| m_pSelectionNotifier->removeListener( _Listener ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| ::sal_Bool SAL_CALL OApplicationController::select( const Any& _aSelection ) | |
| { | |
| ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| Sequence< ::rtl::OUString> aSelection; | |
| if ( !_aSelection.hasValue() || !getView() ) | |
| { | |
| getContainer()->selectElements(aSelection); | |
| return sal_True; | |
| } | |
| // -------------------------------------------------------------- | |
| // BEGIN compatibility | |
| Sequence< NamedValue > aCurrentSelection; | |
| if ( (_aSelection >>= aCurrentSelection) && aCurrentSelection.getLength() ) | |
| { | |
| ElementType eType = E_NONE; | |
| const NamedValue* pIter = aCurrentSelection.getConstArray(); | |
| const NamedValue* pEnd = pIter + aCurrentSelection.getLength(); | |
| for(;pIter != pEnd;++pIter) | |
| { | |
| if ( pIter->Name.equalsAscii("Type") ) | |
| { | |
| sal_Int32 nType = 0; | |
| pIter->Value >>= nType; | |
| if ( nType < DatabaseObject::TABLE || nType > DatabaseObject::REPORT ) | |
| throw IllegalArgumentException(); | |
| eType = static_cast< ElementType >( nType ); | |
| } | |
| else if ( pIter->Name.equalsAscii("Selection") ) | |
| pIter->Value >>= aSelection; | |
| } | |
| m_aSelectContainerEvent.CancelCall(); // just in case the async select request was running | |
| getContainer()->selectContainer(eType); | |
| getContainer()->selectElements(aSelection); | |
| return sal_True; | |
| } | |
| // END compatibility | |
| // -------------------------------------------------------------- | |
| Sequence< NamedDatabaseObject > aSelectedObjects; | |
| if ( !( _aSelection >>= aSelectedObjects ) ) | |
| { | |
| aSelectedObjects.realloc( 1 ); | |
| if ( !( _aSelection >>= aSelectedObjects[0] ) ) | |
| throw IllegalArgumentException(); | |
| } | |
| SelectionByElementType aSelectedElements; | |
| ElementType eSelectedCategory = E_NONE; | |
| for ( const NamedDatabaseObject* pObject = aSelectedObjects.getConstArray(); | |
| pObject != aSelectedObjects.getConstArray() + aSelectedObjects.getLength(); | |
| ++pObject | |
| ) | |
| { | |
| switch ( pObject->Type ) | |
| { | |
| case DatabaseObject::TABLE: | |
| case DatabaseObjectContainer::SCHEMA: | |
| case DatabaseObjectContainer::CATALOG: | |
| aSelectedElements[ E_TABLE ].push_back( pObject->Name ); | |
| break; | |
| case DatabaseObject::QUERY: | |
| aSelectedElements[ E_QUERY ].push_back( pObject->Name ); | |
| break; | |
| case DatabaseObject::FORM: | |
| case DatabaseObjectContainer::FORMS_FOLDER: | |
| aSelectedElements[ E_FORM ].push_back( pObject->Name ); | |
| break; | |
| case DatabaseObject::REPORT: | |
| case DatabaseObjectContainer::REPORTS_FOLDER: | |
| aSelectedElements[ E_REPORT ].push_back( pObject->Name ); | |
| break; | |
| case DatabaseObjectContainer::TABLES: | |
| case DatabaseObjectContainer::QUERIES: | |
| case DatabaseObjectContainer::FORMS: | |
| case DatabaseObjectContainer::REPORTS: | |
| if ( eSelectedCategory != E_NONE ) | |
| throw IllegalArgumentException( | |
| String(ModuleRes(RID_STR_NO_DIFF_CAT)), | |
| *this, sal_Int16( pObject - aSelectedObjects.getConstArray() ) ); | |
| eSelectedCategory = | |
| ( pObject->Type == DatabaseObjectContainer::TABLES ) ? E_TABLE | |
| : ( pObject->Type == DatabaseObjectContainer::QUERIES ) ? E_QUERY | |
| : ( pObject->Type == DatabaseObjectContainer::FORMS ) ? E_FORM | |
| : ( pObject->Type == DatabaseObjectContainer::REPORTS ) ? E_REPORT | |
| : E_NONE; | |
| break; | |
| default: | |
| case DatabaseObjectContainer::DATA_SOURCE: | |
| { | |
| ::rtl::OUString sMessage = String(ModuleRes( RID_STR_UNSUPPORTED_OBJECT_TYPE )); | |
| ::comphelper::string::searchAndReplaceAsciiI( sMessage, "$type$", ::rtl::OUString::valueOf(sal_Int32( pObject->Type )) ); | |
| throw IllegalArgumentException(sMessage, *this, sal_Int16( pObject - aSelectedObjects.getConstArray() )); | |
| } | |
| } | |
| } | |
| for ( SelectionByElementType::const_iterator sel = aSelectedElements.begin(); | |
| sel != aSelectedElements.end(); | |
| ++sel | |
| ) | |
| { | |
| if ( sel->first == m_eCurrentType ) | |
| { | |
| Sequence< ::rtl::OUString > aSelected( sel->second.size() ); | |
| ::std::copy( sel->second.begin(), sel->second.end(), aSelected.getArray() ); | |
| getContainer()->selectElements( aSelected ); | |
| } | |
| else | |
| { | |
| m_aPendingSelection[ sel->first ] = sel->second; | |
| } | |
| } | |
| m_aSelectContainerEvent.CancelCall(); // just in case the async select request was running | |
| getContainer()->selectContainer( eSelectedCategory ); | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Any SAL_CALL OApplicationController::getSelection( ) | |
| { | |
| ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| ::osl::MutexGuard aGuard( getMutex() ); | |
| Sequence< NamedDatabaseObject > aCurrentSelection; | |
| const ElementType eType( getContainer()->getElementType() ); | |
| if ( eType != E_NONE ) | |
| { | |
| getContainer()->describeCurrentSelectionForType( eType, aCurrentSelection ); | |
| if ( aCurrentSelection.getLength() == 0 ) | |
| { // if no objects are selected, add an entry to the sequence which describes the overall category | |
| // which is selected currently | |
| aCurrentSelection.realloc(1); | |
| aCurrentSelection[0].Name = getDatabaseName(); | |
| switch ( eType ) | |
| { | |
| case E_TABLE: aCurrentSelection[0].Type = DatabaseObjectContainer::TABLES; break; | |
| case E_QUERY: aCurrentSelection[0].Type = DatabaseObjectContainer::QUERIES; break; | |
| case E_FORM: aCurrentSelection[0].Type = DatabaseObjectContainer::FORMS; break; | |
| case E_REPORT: aCurrentSelection[0].Type = DatabaseObjectContainer::REPORTS; break; | |
| default: | |
| OSL_ENSURE( false, "OApplicationController::getSelection: unexpected current element type!" ); | |
| break; | |
| } | |
| } | |
| } | |
| return makeAny( aCurrentSelection ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OApplicationController::impl_migrateScripts_nothrow() | |
| { | |
| try | |
| { | |
| ::rtl::OUString sDialogService( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.application.MacroMigrationWizard" ) ); | |
| ::comphelper::ComponentContext aContext( getORB() ); | |
| Sequence< Any > aDialogArgs(1); | |
| aDialogArgs[0] <<= Reference< XOfficeDatabaseDocument >( m_xModel, UNO_QUERY_THROW ); | |
| Reference< XExecutableDialog > xDialog( | |
| aContext.createComponentWithArguments( sDialogService, aDialogArgs ), | |
| UNO_QUERY ); | |
| if ( !xDialog.is() ) | |
| { | |
| ShowServiceNotAvailableError( getView(), sDialogService, true ); | |
| return; | |
| } | |
| xDialog->execute(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| //........................................................................ | |
| } // namespace dbaui | |
| //........................................................................ |