| /************************************************************** |
| * |
| * 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_dbaccess.hxx" |
| |
| #ifndef DBACCESS_SBA_GRID_HRC |
| #include "sbagrid.hrc" |
| #endif |
| |
| #ifndef _SVX_SVXIDS_HRC |
| #include <svx/svxids.hrc> |
| #endif |
| |
| #define ITEMID_HORJUSTIFY SID_ATTR_ALIGN_HOR_JUSTIFY |
| #define ITEMID_VERJUSTIFY SID_ATTR_ALIGN_VER_JUSTIFY |
| //#define ITEMID_ORIENTATION SID_ATTR_ALIGN_ORIENTATION |
| #define ITEMID_LINEBREAK SID_ATTR_ALIGN_LINEBREAK |
| #define ITEMID_MARGIN SID_ATTR_ALIGN_MARGIN |
| #define ITEMID_NUMBERINFO SID_ATTR_NUMBERFORMAT_INFO |
| |
| |
| #define _ZFORLIST_DECLARE_TABLE |
| #ifndef _SVX_NUMINF_HXX |
| #include <svx/numinf.hxx> |
| #endif |
| #ifndef _SVX_DBAEXCHANGE_HXX_ |
| #include <svx/dbaexchange.hxx> |
| #endif |
| #ifndef _COM_SUN_STAR_UI_DIALOGS_XEXECUTABLEDIALOG_HPP_ |
| #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> |
| #endif |
| |
| #ifndef _SBA_GRID_HXX |
| #include "sbagrid.hxx" |
| #endif |
| #ifndef DBAUI_SBATTRDLG_HXX |
| #include "dlgattr.hxx" |
| #endif |
| #ifndef _DBAUI_DLGSIZE_HXX |
| #include "dlgsize.hxx" |
| #endif |
| #ifndef _COM_SUN_STAR_FORM_XLOADABLE_HPP_ |
| #include <com/sun/star/form/XLoadable.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDB_COMMANDTYPE_HPP_ |
| #include <com/sun/star/sdb/CommandType.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDB_XSQLQUERYCOMPOSERFACTORY_HPP_ |
| #include <com/sun/star/sdb/XSQLQueryComposerFactory.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDB_XRESULTSETACCESS_HPP_ |
| #include <com/sun/star/sdb/XResultSetAccess.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_FORM_XFORM_HPP_ |
| #include <com/sun/star/form/XForm.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_CONTAINER_XINDEXCONTAINER_HPP_ |
| #include <com/sun/star/container/XIndexContainer.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_NUMBERFORMAT_HPP_ |
| #include <com/sun/star/util/NumberFormat.hpp> |
| #endif |
| |
| #ifndef _COM_SUN_STAR_VIEW_XSELECTIONSUPPLIER_HPP_ |
| #include <com/sun/star/view/XSelectionSupplier.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_FORM_DATASELECTIONTYPE_HPP_ |
| #include <com/sun/star/form/DataSelectionType.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_AWT_TEXTALIGN_HPP_ |
| #include <com/sun/star/awt/TextAlign.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_AWT_XTEXTCOMPONENT_HPP_ |
| #include <com/sun/star/awt/XTextComponent.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_DATE_HPP_ |
| #include <com/sun/star/util/Date.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_TIME_HPP_ |
| #include <com/sun/star/util/Time.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_DATETIME_HPP_ |
| #include <com/sun/star/util/DateTime.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDBC_XRESULTSETUPDATE_HPP_ |
| #include <com/sun/star/sdbc/XResultSetUpdate.hpp> |
| #endif |
| #ifndef _URLOBJ_HXX |
| #include <tools/urlobj.hxx> |
| #endif |
| #ifndef TOOLS_DIAGNOSE_EX_H |
| #include <tools/diagnose_ex.h> |
| #endif |
| |
| #ifndef _SFXINTITEM_HXX |
| #include <svl/intitem.hxx> |
| #endif |
| |
| #ifndef _SVX_ALGITEM_HXX //autogen |
| #include <svx/algitem.hxx> |
| #endif |
| |
| #ifndef _SV_MULTISEL_HXX //autogen |
| #include <tools/multisel.hxx> |
| #endif |
| |
| #ifndef _SVX_SVXIDS_HRC |
| #include <svx/svxids.hrc> |
| #endif |
| |
| #ifndef _NUMUNO_HXX |
| #include <svl/numuno.hxx> |
| #endif |
| |
| #ifndef _SFXITEMPOOL_HXX //autogen wg. SfxItemInfo |
| #include <svl/itempool.hxx> |
| #endif |
| |
| #ifndef _SFXITEMSET_HXX //autogen wg. SfxItemSet |
| #include <svl/itemset.hxx> |
| #endif |
| |
| #ifndef _SFXRNGITEM_HXX |
| #include <svl/rngitem.hxx> |
| #endif |
| |
| #ifndef _SV_WAITOBJ_HXX |
| #include <vcl/waitobj.hxx> |
| #endif |
| #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_ |
| #include <toolkit/helper/vclunohelper.hxx> |
| #endif |
| |
| #ifndef _ZFORLIST_HXX |
| #include <svl/zforlist.hxx> |
| #endif |
| #ifndef _CPPUHELPER_QUERYINTERFACE_HXX_ |
| #include <cppuhelper/queryinterface.hxx> |
| #endif |
| #ifndef _CONNECTIVITY_DBTOOLS_HXX_ |
| #include <connectivity/dbtools.hxx> |
| #endif |
| #ifndef _DBHELPER_DBCONVERSION_HXX_ |
| #include <connectivity/dbconversion.hxx> |
| #endif |
| #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_ |
| #include <cppuhelper/typeprovider.hxx> |
| #endif |
| #ifndef _RTL_UUID_H_ |
| #include <rtl/uuid.h> |
| #endif |
| #ifndef _RTL_MEMORY_H_ |
| #include <rtl/memory.h> |
| #endif |
| #ifndef _COMPHELPER_EXTRACT_HXX_ |
| #include <comphelper/extract.hxx> |
| #endif |
| #ifndef _COM_SUN_STAR_SDBCX_XTABLESSUPPLIER_HPP_ |
| #include <com/sun/star/sdbcx/XTablesSupplier.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_ |
| #include <com/sun/star/sdbc/DataType.hpp> |
| #endif |
| #ifndef _SV_MSGBOX_HXX |
| #include <vcl/msgbox.hxx> |
| #endif |
| #ifndef _SVX_DBEXCH_HRC |
| #include <svx/dbexch.hrc> |
| #endif |
| #ifndef _DBU_BRW_HRC_ |
| #include "dbu_brw.hrc" |
| #endif |
| #ifndef DBACCESS_UI_BROWSER_ID_HXX |
| #include "browserids.hxx" |
| #endif |
| #ifndef DBACCESS_SHARED_DBUSTRINGS_HRC |
| #include "dbustrings.hrc" |
| #endif |
| #ifndef _DBU_REGHELPER_HXX_ |
| #include "dbu_reghelper.hxx" |
| #endif |
| #ifndef DBAUI_DBEXCHANGE_HXX |
| #include "dbexchange.hxx" |
| #endif |
| #ifndef DBAUI_TABLEROW_EXCHANGE_HXX |
| #include "TableRowExchange.hxx" |
| #endif |
| #ifndef DBAUI_TABLEROW_HXX |
| #include "TableRow.hxx" |
| #endif |
| #ifndef DBAUI_FIELDDESCRIPTIONS_HXX |
| #include "FieldDescriptions.hxx" |
| #endif |
| #ifndef _SVTOOLS_STRINGTRANSFER_HXX_ |
| #include <svtools/stringtransfer.hxx> |
| #endif |
| #ifndef _VCL_STDTEXT_HXX |
| #include <vcl/stdtext.hxx> |
| #endif |
| #ifndef DBAUI_TOOLS_HXX |
| #include "UITools.hxx" |
| #endif |
| #ifndef DBAUI_TOKENWRITER_HXX |
| #include "TokenWriter.hxx" |
| #endif |
| |
| using namespace ::com::sun::star::ui::dialogs; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::sdb; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::sdbcx; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::datatransfer; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::view; |
| using namespace ::com::sun::star::form; |
| using namespace ::com::sun::star::frame; |
| using namespace ::com::sun::star::util; |
| using namespace ::dbaui; |
| using namespace ::dbtools; |
| using namespace ::svx; |
| using namespace ::svt; |
| |
| extern "C" void SAL_CALL createRegistryInfo_SbaXGridControl() |
| { |
| static OMultiInstanceAutoRegistration< SbaXGridControl > aAutoRegistration; |
| } |
| //------------------------------------------------------------------------- |
| ::comphelper::StringSequence SAL_CALL SbaXGridControl::getSupportedServiceNames() throw() |
| { |
| return getSupportedServiceNames_Static(); |
| } |
| // ------------------------------------------------------------------------- |
| Reference< XInterface > SAL_CALL SbaXGridControl::Create(const Reference<XMultiServiceFactory >& _rxFactory) |
| { |
| return *(new SbaXGridControl(_rxFactory)); |
| } |
| |
| //------------------------------------------------------------------ |
| |
| //------------------------------------------------------------------ |
| //======================================================================================= |
| // SbaXGridControl |
| //======================================================================================= |
| |
| //------------------------------------------------------------------------------ |
| ::rtl::OUString SAL_CALL SbaXGridControl::getImplementationName() throw() |
| { |
| return getImplementationName_Static(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| ::rtl::OUString SbaXGridControl::getImplementationName_Static() throw( RuntimeException ) |
| { |
| return ::rtl::OUString::createFromAscii("com.sun.star.comp.dbu.SbaXGridControl"); |
| } |
| |
| //------------------------------------------------------------------------------ |
| Sequence< ::rtl::OUString> SbaXGridControl::getSupportedServiceNames_Static(void) throw( RuntimeException ) |
| { |
| Sequence< ::rtl::OUString> aSupported(3); |
| aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.form.control.InteractionGridControl"); |
| aSupported[1] = ::rtl::OUString::createFromAscii("com.sun.star.form.control.GridControl"); |
| aSupported[2] = ::rtl::OUString::createFromAscii("com.sun.star.awt.UnoControl"); |
| return aSupported; |
| } |
| DBG_NAME(SbaXGridControl ); |
| //--------------------------------------------------------------------------------------- |
| SbaXGridControl::SbaXGridControl(const Reference< XMultiServiceFactory >& _rM) |
| : FmXGridControl(_rM) |
| { |
| DBG_CTOR(SbaXGridControl ,NULL); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| SbaXGridControl::~SbaXGridControl() |
| { |
| DBG_DTOR(SbaXGridControl ,NULL); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| FmXGridPeer* SbaXGridControl::imp_CreatePeer(Window* pParent) |
| { |
| FmXGridPeer* pReturn = new SbaXGridPeer(m_xServiceFactory); |
| |
| // translate properties into WinBits |
| WinBits nStyle = WB_TABSTOP; |
| Reference< XPropertySet > xModelSet(getModel(), UNO_QUERY); |
| if (xModelSet.is()) |
| { |
| try |
| { |
| if (::comphelper::getINT16(xModelSet->getPropertyValue(PROPERTY_BORDER))) |
| nStyle |= WB_BORDER; |
| } |
| catch(Exception&) |
| { |
| } |
| |
| } |
| |
| pReturn->Create(pParent, nStyle); |
| return pReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| Any SAL_CALL SbaXGridControl::queryInterface(const Type& _rType) throw (RuntimeException) |
| { |
| Any aRet = FmXGridControl::queryInterface(_rType); |
| return aRet.hasValue() ? aRet : ::cppu::queryInterface(_rType,(::com::sun::star::frame::XDispatch*)this); |
| } |
| |
| //------------------------------------------------------------------------------ |
| Sequence< Type > SAL_CALL SbaXGridControl::getTypes( ) throw (RuntimeException) |
| { |
| Sequence< Type > aTypes = FmXGridControl::getTypes(); |
| |
| sal_Int32 nTypes = aTypes.getLength(); |
| aTypes.realloc(nTypes + 1); |
| aTypes[nTypes] = ::getCppuType(static_cast< Reference< ::com::sun::star::frame::XDispatch >* >(NULL)); |
| |
| return aTypes; |
| } |
| |
| //------------------------------------------------------------------------------ |
| Sequence< sal_Int8 > SAL_CALL SbaXGridControl::getImplementationId( ) throw (RuntimeException) |
| { |
| static ::cppu::OImplementationId * pId = 0; |
| if (! pId) |
| { |
| ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); |
| if (! pId) |
| { |
| static ::cppu::OImplementationId aId; |
| pId = &aId; |
| } |
| } |
| return pId->getImplementationId(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridControl::createPeer(const Reference< ::com::sun::star::awt::XToolkit > & rToolkit, const Reference< ::com::sun::star::awt::XWindowPeer > & rParentPeer) throw( RuntimeException ) |
| { |
| FmXGridControl::createPeer(rToolkit, rParentPeer); |
| |
| DBG_ASSERT(/*(0 == m_nPeerCreationLevel) && */!mbCreatingPeer, "FmXGridControl::createPeer : recursion!"); |
| // see the base class' createPeer for a comment on this |
| // 14.05.2001 - 86836 - frank.schoenheit@germany.sun.com |
| |
| // TODO: why the hell this whole class does not use any mutex? |
| |
| // if (0 == m_nPeerCreationLevel) |
| { |
| Reference< ::com::sun::star::frame::XDispatch > xDisp(getPeer(), UNO_QUERY); |
| for ( StatusMultiplexerArray::iterator aIter = m_aStatusMultiplexer.begin(); |
| aIter != m_aStatusMultiplexer.end(); |
| ++aIter) |
| { |
| if ((*aIter).second && (*aIter).second->getLength()) |
| xDisp->addStatusListener((*aIter).second, (*aIter).first); |
| } |
| } |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridControl::dispatch(const ::com::sun::star::util::URL& aURL, const Sequence< PropertyValue >& aArgs) throw( RuntimeException ) |
| { |
| Reference< ::com::sun::star::frame::XDispatch > xDisp(getPeer(), UNO_QUERY); |
| if (xDisp.is()) |
| xDisp->dispatch(aURL, aArgs); |
| } |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridControl::addStatusListener( const Reference< XStatusListener > & _rxListener, const URL& _rURL ) throw( RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard( GetMutex() ); |
| if ( _rxListener.is() ) |
| { |
| SbaXStatusMultiplexer*& pMultiplexer = m_aStatusMultiplexer[ _rURL ]; |
| if ( !pMultiplexer ) |
| { |
| pMultiplexer = new SbaXStatusMultiplexer( *this, GetMutex() ); |
| pMultiplexer->acquire(); |
| } |
| |
| pMultiplexer->addInterface( _rxListener ); |
| if ( getPeer().is() ) |
| { |
| if ( 1 == pMultiplexer->getLength() ) |
| { // the first external listener for this URL |
| Reference< XDispatch > xDisp( getPeer(), UNO_QUERY ); |
| xDisp->addStatusListener( pMultiplexer, _rURL ); |
| } |
| else |
| { // already have other listeners for this URL |
| _rxListener->statusChanged( pMultiplexer->getLastEvent() ); |
| } |
| } |
| } |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridControl::removeStatusListener(const Reference< ::com::sun::star::frame::XStatusListener > & _rxListener, const ::com::sun::star::util::URL& _rURL) throw( RuntimeException ) |
| { |
| ::osl::MutexGuard aGuard( GetMutex() ); |
| |
| SbaXStatusMultiplexer*& pMultiplexer = m_aStatusMultiplexer[_rURL]; |
| if (!pMultiplexer) |
| { |
| pMultiplexer = new SbaXStatusMultiplexer(*this,GetMutex()); |
| pMultiplexer->acquire(); |
| } |
| |
| if (getPeer().is() && pMultiplexer->getLength() == 1) |
| { |
| Reference< ::com::sun::star::frame::XDispatch > xDisp(getPeer(), UNO_QUERY); |
| xDisp->removeStatusListener(pMultiplexer, _rURL); |
| } |
| pMultiplexer->removeInterface( _rxListener ); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridControl::dispose(void) throw( RuntimeException ) |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| EventObject aEvt; |
| aEvt.Source = *this; |
| |
| for ( StatusMultiplexerArray::iterator aIter = m_aStatusMultiplexer.begin(); |
| aIter != m_aStatusMultiplexer.end(); |
| ++aIter) |
| { |
| if ((*aIter).second) |
| { |
| (*aIter).second->disposeAndClear(aEvt); |
| (*aIter).second->release(); |
| (*aIter).second = NULL; |
| } |
| } |
| StatusMultiplexerArray().swap(m_aStatusMultiplexer); |
| |
| FmXGridControl::dispose(); |
| } |
| |
| //======================================================================================= |
| // SbaXGridPeer |
| //======================================================================================= |
| DBG_NAME(SbaXGridPeer ) |
| //--------------------------------------------------------------------------------------- |
| SbaXGridPeer::SbaXGridPeer(const Reference< XMultiServiceFactory >& _rM) |
| : FmXGridPeer(_rM) |
| ,m_aStatusListeners(m_aMutex) |
| { |
| DBG_CTOR(SbaXGridPeer ,NULL); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| SbaXGridPeer::~SbaXGridPeer() |
| { |
| DBG_DTOR(SbaXGridPeer ,NULL); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridPeer::dispose(void) throw( RuntimeException ) |
| { |
| EventObject aEvt(*this); |
| |
| m_aStatusListeners.disposeAndClear(aEvt); |
| |
| FmXGridPeer::dispose(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaXGridPeer::NotifyStatusChanged(const ::com::sun::star::util::URL& _rUrl, const Reference< ::com::sun::star::frame::XStatusListener > & xControl) |
| { |
| SbaGridControl* pGrid = (SbaGridControl*) GetWindow(); |
| if (!pGrid) |
| return; |
| |
| ::com::sun::star::frame::FeatureStateEvent aEvt; |
| aEvt.Source = *this; |
| aEvt.IsEnabled = !pGrid->IsReadOnlyDB(); |
| aEvt.FeatureURL = _rUrl; |
| |
| ConstMapDispatchToBoolIterator aURLStatePos = m_aDispatchStates.find( classifyDispatchURL( _rUrl ) ); |
| if ( m_aDispatchStates.end() != aURLStatePos ) |
| aEvt.State <<= aURLStatePos->second; |
| else |
| aEvt.State <<= sal_False; |
| |
| if (xControl.is()) |
| xControl->statusChanged(aEvt); |
| else |
| { |
| ::cppu::OInterfaceContainerHelper * pIter = m_aStatusListeners.getContainer(_rUrl); |
| |
| if (pIter) |
| { |
| ::cppu::OInterfaceIteratorHelper aListIter(*pIter); |
| while (aListIter.hasMoreElements()) |
| ((::com::sun::star::frame::XStatusListener*)aListIter.next())->statusChanged(aEvt); |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| Any SAL_CALL SbaXGridPeer::queryInterface(const Type& _rType) throw (RuntimeException) |
| { |
| Any aRet = ::cppu::queryInterface(_rType,(::com::sun::star::frame::XDispatch*)this); |
| if(aRet.hasValue()) |
| return aRet; |
| return FmXGridPeer::queryInterface(_rType); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| Reference< ::com::sun::star::frame::XDispatch > SAL_CALL SbaXGridPeer::queryDispatch(const ::com::sun::star::util::URL& aURL, const ::rtl::OUString& aTargetFrameName, sal_Int32 nSearchFlags) throw( RuntimeException ) |
| { |
| if ( (aURL.Complete.equals(::rtl::OUString::createFromAscii(".uno:GridSlots/BrowserAttribs"))) |
| || (aURL.Complete.equals(::rtl::OUString::createFromAscii(".uno:GridSlots/RowHeight"))) |
| || (aURL.Complete.equals(::rtl::OUString::createFromAscii(".uno:GridSlots/ColumnAttribs"))) |
| || (aURL.Complete.equals(::rtl::OUString::createFromAscii(".uno:GridSlots/ColumnWidth"))) |
| ) |
| { |
| return (::com::sun::star::frame::XDispatch*)this; |
| } |
| |
| return FmXGridPeer::queryDispatch(aURL, aTargetFrameName, nSearchFlags); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| IMPL_LINK( SbaXGridPeer, OnDispatchEvent, void*, /*NOTINTERESTEDIN*/ ) |
| { |
| SbaGridControl* pGrid = static_cast< SbaGridControl* >( GetWindow() ); |
| if ( pGrid ) // if this fails, we were disposing before arriving here |
| { |
| if ( Application::GetMainThreadIdentifier() != ::vos::OThread::getCurrentIdentifier() ) |
| { |
| // still not in the main thread (see SbaXGridPeer::dispatch). post an event, again |
| // without moving the special even to the back of the queue |
| pGrid->PostUserEvent( LINK( this, SbaXGridPeer, OnDispatchEvent ) ); |
| } |
| else |
| { |
| DispatchArgs aArgs = m_aDispatchArgs.front(); |
| m_aDispatchArgs.pop(); |
| |
| SbaXGridPeer::dispatch( aArgs.aURL, aArgs.aArgs ); |
| } |
| } |
| |
| return 0; |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| SbaXGridPeer::DispatchType SbaXGridPeer::classifyDispatchURL( const URL& _rURL ) |
| { |
| DispatchType eURLType = dtUnknown; |
| if ( _rURL.Complete.equalsAscii( ".uno:GridSlots/BrowserAttribs" ) ) |
| eURLType = dtBrowserAttribs; |
| else if ( _rURL.Complete.equalsAscii( ".uno:GridSlots/RowHeight" ) ) |
| eURLType = dtRowHeight; |
| else if ( _rURL.Complete.equalsAscii( ".uno:GridSlots/ColumnAttribs" ) ) |
| eURLType = dtColumnAttribs; |
| else if ( _rURL.Complete.equalsAscii( ".uno:GridSlots/ColumnWidth" ) ) |
| eURLType = dtColumnWidth; |
| return eURLType; |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridPeer::dispatch(const URL& aURL, const Sequence< PropertyValue >& aArgs) throw( RuntimeException ) |
| { |
| SbaGridControl* pGrid = (SbaGridControl*)GetWindow(); |
| if (!pGrid) |
| return; |
| |
| if ( Application::GetMainThreadIdentifier() != ::vos::OThread::getCurrentIdentifier() ) |
| { |
| // we're not in the main thread. This is bad, as we want to raise windows here, |
| // and VCL does not like windows to be opened in non-main threads (at least on Win32). |
| // Okay, do this async. No problem with this, as XDispatch::dispatch is defined to be |
| // a one-way method. |
| |
| // save the args |
| DispatchArgs aDispatchArgs; |
| aDispatchArgs.aURL = aURL; |
| aDispatchArgs.aArgs = aArgs; |
| m_aDispatchArgs.push( aDispatchArgs ); |
| |
| // post an event |
| // we use the Window::PostUserEvent here, instead of the application::PostUserEvent |
| // this saves us from keeping track of these events - as soon as the window dies, |
| // the events are deleted automatically. For the application way, we would need to |
| // do this ourself. |
| // As we use our grid as window, and the grid dies before we dy, this should be no problem. |
| pGrid->PostUserEvent( LINK( this, SbaXGridPeer, OnDispatchEvent ) ); |
| return; |
| } |
| |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Int16 nColId = -1; |
| const PropertyValue* pArgs = aArgs.getConstArray(); |
| for (sal_uInt16 i=0; i<aArgs.getLength(); ++i, ++pArgs) |
| { |
| if (pArgs->Name == ::rtl::OUString::createFromAscii("ColumnViewPos")) |
| { |
| nColId = pGrid->GetColumnIdFromViewPos(::comphelper::getINT16(pArgs->Value)); |
| break; |
| } |
| if (pArgs->Name == ::rtl::OUString::createFromAscii("ColumnModelPos")) |
| { |
| nColId = pGrid->GetColumnIdFromModelPos(::comphelper::getINT16(pArgs->Value)); |
| break; |
| } |
| if (pArgs->Name == ::rtl::OUString::createFromAscii("ColumnId")) |
| { |
| nColId = ::comphelper::getINT16(pArgs->Value); |
| break; |
| } |
| } |
| |
| DispatchType eURLType = classifyDispatchURL( aURL ); |
| |
| if ( dtUnknown != eURLType ) |
| { |
| // notify any status listeners that the dialog is now active (well, about to be active) |
| MapDispatchToBool::iterator aThisURLState = m_aDispatchStates.insert( MapDispatchToBool::value_type( eURLType, sal_True ) ).first; |
| NotifyStatusChanged( aURL, NULL ); |
| |
| // execute the dialog |
| switch ( eURLType ) |
| { |
| case dtBrowserAttribs: |
| pGrid->SetBrowserAttrs(); |
| break; |
| |
| case dtRowHeight: |
| pGrid->SetRowHeight(); |
| break; |
| |
| case dtColumnAttribs: |
| { |
| DBG_ASSERT(nColId != -1, "SbaXGridPeer::dispatch : invalid parameter !"); |
| if (nColId != -1) |
| break; |
| pGrid->SetColAttrs(nColId); |
| } |
| break; |
| |
| case dtColumnWidth: |
| { |
| DBG_ASSERT(nColId != -1, "SbaXGridPeer::dispatch : invalid parameter !"); |
| if (nColId != -1) |
| break; |
| pGrid->SetColWidth(nColId); |
| } |
| break; |
| |
| case dtUnknown: |
| break; |
| } |
| |
| // notify any status listeners that the dialog vanished |
| m_aDispatchStates.erase( aThisURLState ); |
| NotifyStatusChanged( aURL, NULL ); |
| } |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridPeer::addStatusListener(const Reference< ::com::sun::star::frame::XStatusListener > & xControl, const ::com::sun::star::util::URL& aURL) throw( RuntimeException ) |
| { |
| ::cppu::OInterfaceContainerHelper* pCont = m_aStatusListeners.getContainer(aURL); |
| if (!pCont) |
| m_aStatusListeners.addInterface(aURL,xControl); |
| else |
| pCont->addInterface(xControl); |
| NotifyStatusChanged(aURL, xControl); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SAL_CALL SbaXGridPeer::removeStatusListener(const Reference< ::com::sun::star::frame::XStatusListener > & xControl, const ::com::sun::star::util::URL& aURL) throw( RuntimeException ) |
| { |
| ::cppu::OInterfaceContainerHelper* pCont = m_aStatusListeners.getContainer(aURL); |
| if ( pCont ) |
| pCont->removeInterface(xControl); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| const Sequence< sal_Int8 > & SbaXGridPeer::getUnoTunnelId() |
| { |
| static Sequence< sal_Int8 > * pSeq = 0; |
| if( !pSeq ) |
| { |
| ::osl::Guard< ::osl::Mutex > aGuard( ::osl::Mutex::getGlobalMutex() ); |
| if( !pSeq ) |
| { |
| static Sequence< sal_Int8 > aSeq( 16 ); |
| rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0,sal_True ); |
| pSeq = &aSeq; |
| } |
| } |
| return *pSeq; |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| Sequence< Type > SAL_CALL SbaXGridPeer::getTypes() throw (RuntimeException) |
| { |
| Sequence< Type > aTypes = FmXGridPeer::getTypes(); |
| sal_Int32 nOldLen = aTypes.getLength(); |
| aTypes.realloc(nOldLen + 1); |
| aTypes.getArray()[nOldLen] = ::getCppuType( reinterpret_cast< Reference< ::com::sun::star::frame::XDispatch >* >(NULL) ); |
| |
| return aTypes; |
| } |
| |
| // return implementation specific data |
| //------------------------------------------------------------------ |
| sal_Int64 SAL_CALL SbaXGridPeer::getSomething( const Sequence< sal_Int8 > & rId ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) |
| return reinterpret_cast< sal_Int64 >( this ); |
| |
| return FmXGridPeer::getSomething(rId); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| SbaXGridPeer* SbaXGridPeer::getImplementation(const Reference< XInterface >& _rxIFace) |
| { |
| Reference< XUnoTunnel > xTunnel( |
| _rxIFace, UNO_QUERY); |
| if (xTunnel.is()) |
| return reinterpret_cast<SbaXGridPeer*>(xTunnel->getSomething(getUnoTunnelId())); |
| return NULL; |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| FmGridControl* SbaXGridPeer::imp_CreateControl(Window* pParent, WinBits nStyle) |
| { |
| return new SbaGridControl(m_xServiceFactory, pParent, this, nStyle); |
| } |
| |
| //================================================================== |
| // SbaGridHeader |
| //================================================================== |
| |
| //--------------------------------------------------------------------------------------- |
| SbaGridHeader::SbaGridHeader(BrowseBox* pParent, WinBits nWinBits) |
| :FmGridHeader(pParent, nWinBits) |
| ,DragSourceHelper(this) |
| { |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridHeader::StartDrag( sal_Int8 _nAction, const Point& _rPosPixel ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| // in the new DnD API, the solar mutex is not locked when StartDrag get's called |
| |
| ImplStartColumnDrag( _nAction, _rPosPixel ); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridHeader::MouseButtonDown( const MouseEvent& _rMEvt ) |
| { |
| if (_rMEvt.IsLeft()) |
| if (_rMEvt.GetClicks() != 2) |
| { |
| // the base class will start a column move here, which we don't want to allow |
| // (at the moment. If we store relative positions with the columns, we can allow column moves ....) |
| |
| // sal_uInt16 nPos(0); |
| // sal_uInt16 nHitTest = ImplHitTest( _rMEvt.GetPosPixel(), mnMouseOff, nPos ); |
| // if (!nHitTest & HEAD_HITTEST_DIVIDER) |
| // return; |
| } |
| |
| FmGridHeader::MouseButtonDown(_rMEvt); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| sal_Bool SbaGridHeader::ImplStartColumnDrag(sal_Int8 _nAction, const Point& _rMousePos) |
| { |
| sal_uInt16 nId = GetItemId(_rMousePos); |
| sal_Bool bResizingCol = sal_False; |
| if (HEADERBAR_ITEM_NOTFOUND != nId) |
| { |
| Rectangle aColRect = GetItemRect(nId); |
| aColRect.Left() += nId ? 3 : 0; // the handle col (nId == 0) does not have a left margin for resizing |
| aColRect.Right() -= 3; |
| bResizingCol = !aColRect.IsInside(_rMousePos); |
| } |
| if (!bResizingCol) |
| { |
| // force the the base class to end it's drag mode |
| EndTracking(ENDTRACK_CANCEL | ENDTRACK_END); |
| |
| // because we have 3d-buttons the select handler is called from MouseButtonUp, but StartDrag |
| // occures earlier (while the mouse button is down) |
| // so for optical reasons we select the column before really starting the drag operation. |
| notifyColumnSelect(nId); |
| |
| static_cast<SbaGridControl*>(GetParent())->StartDrag(_nAction, |
| Point( |
| _rMousePos.X() + GetPosPixel().X(), // we aren't left-justified with our parent, in contrast to the data window |
| _rMousePos.Y() - GetSizePixel().Height() |
| ) |
| ); |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridHeader::PreExecuteColumnContextMenu(sal_uInt16 nColId, PopupMenu& rMenu) |
| { |
| FmGridHeader::PreExecuteColumnContextMenu(nColId, rMenu); |
| |
| // some items are valid only if the db isn't readonly |
| sal_Bool bDBIsReadOnly = ((SbaGridControl*)GetParent())->IsReadOnlyDB(); |
| |
| if (bDBIsReadOnly) |
| { |
| rMenu.EnableItem(SID_FM_HIDECOL, sal_False); |
| PopupMenu* pShowColsMenu = rMenu.GetPopupMenu(SID_FM_SHOWCOLS); |
| if (pShowColsMenu) |
| { |
| // at most 16 items which mean "show column <name>" |
| for (sal_uInt16 i=1; i<16; ++i) |
| pShowColsMenu->EnableItem(i, sal_False); |
| // "show cols/more..." and "show cols/all" |
| pShowColsMenu->EnableItem(SID_FM_SHOWCOLS_MORE, sal_False); |
| pShowColsMenu->EnableItem(SID_FM_SHOWALLCOLS, sal_False); |
| } |
| } |
| |
| // prepend some new items |
| sal_Bool bColAttrs = (nColId != (sal_uInt16)-1) && (nColId != 0); |
| if ( bColAttrs && !bDBIsReadOnly) |
| { |
| PopupMenu aNewItems(ModuleRes(RID_SBA_GRID_COLCTXMENU)); |
| sal_uInt16 nPos = 0; |
| sal_uInt16 nModelPos = ((SbaGridControl*)GetParent())->GetModelColumnPos(nColId); |
| Reference< XPropertySet > xField = ((SbaGridControl*)GetParent())->getField(nModelPos); |
| |
| if ( xField.is() ) |
| { |
| switch( ::comphelper::getINT32(xField->getPropertyValue(PROPERTY_TYPE)) ) |
| { |
| case DataType::BINARY: |
| case DataType::VARBINARY: |
| case DataType::LONGVARBINARY: |
| case DataType::SQLNULL: |
| case DataType::OBJECT: |
| case DataType::BLOB: |
| case DataType::CLOB: |
| case DataType::REF: |
| break; |
| default: |
| rMenu.InsertItem(ID_BROWSER_COLATTRSET, aNewItems.GetItemText(ID_BROWSER_COLATTRSET), 0, nPos++); |
| rMenu.SetHelpId(ID_BROWSER_COLATTRSET, aNewItems.GetHelpId(ID_BROWSER_COLATTRSET)); |
| rMenu.InsertSeparator(nPos++); |
| } |
| } |
| |
| rMenu.InsertItem(ID_BROWSER_COLWIDTH, aNewItems.GetItemText(ID_BROWSER_COLWIDTH), 0, nPos++); |
| rMenu.SetHelpId(ID_BROWSER_COLWIDTH, aNewItems.GetHelpId(ID_BROWSER_COLWIDTH)); |
| rMenu.InsertSeparator(nPos++); |
| } |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridHeader::PostExecuteColumnContextMenu(sal_uInt16 nColId, const PopupMenu& rMenu, sal_uInt16 nExecutionResult) |
| { |
| switch (nExecutionResult) |
| { |
| case ID_BROWSER_COLWIDTH: |
| ((SbaGridControl*)GetParent())->SetColWidth(nColId); |
| break; |
| |
| case ID_BROWSER_COLATTRSET: |
| ((SbaGridControl*)GetParent())->SetColAttrs(nColId); |
| break; |
| case ID_BROWSER_COLUMNINFO: |
| { |
| sal_uInt16 nModelPos = ((SbaGridControl*)GetParent())->GetModelColumnPos(nColId); |
| Reference< XPropertySet > xField = ((SbaGridControl*)GetParent())->getField(nModelPos); |
| |
| if(!xField.is()) |
| break; |
| ::std::vector< ::boost::shared_ptr<OTableRow> > vClipboardList; |
| // send it to the clipboard |
| vClipboardList.push_back(::boost::shared_ptr<OTableRow>(new OTableRow(xField))); |
| OTableRowExchange* pData = new OTableRowExchange(vClipboardList); |
| Reference< ::com::sun::star::datatransfer::XTransferable> xRef = pData; |
| pData->CopyToClipboard(GetParent()); |
| } |
| break; |
| |
| default: FmGridHeader::PostExecuteColumnContextMenu(nColId, rMenu, nExecutionResult); |
| } |
| } |
| |
| //================================================================== |
| // SbaGridControl |
| //================================================================== |
| DBG_NAME(SbaGridControl ); |
| //--------------------------------------------------------------------------------------- |
| SbaGridControl::SbaGridControl(Reference< XMultiServiceFactory > _rM, |
| Window* pParent, FmXGridPeer* _pPeer, WinBits nBits) |
| :FmGridControl(_rM,pParent, _pPeer, nBits) |
| ,m_pMasterListener(NULL) |
| ,m_nAsyncDropEvent(0) |
| ,m_nCurrentActionColId((sal_uInt16)-1) |
| ,m_bActivatingForDrop(sal_False) |
| { |
| DBG_CTOR(SbaGridControl ,NULL); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| SbaGridControl::~SbaGridControl() |
| { |
| DBG_DTOR(SbaGridControl ,NULL); |
| if (m_nAsyncDropEvent) |
| Application::RemoveUserEvent(m_nAsyncDropEvent); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| BrowserHeader* SbaGridControl::imp_CreateHeaderBar(BrowseBox* pParent) |
| { |
| return new SbaGridHeader(pParent); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| CellController* SbaGridControl::GetController(long nRow, sal_uInt16 nCol) |
| { |
| if ( m_bActivatingForDrop ) |
| return NULL; |
| |
| return FmGridControl::GetController(nRow, nCol); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::PreExecuteRowContextMenu(sal_uInt16 nRow, PopupMenu& rMenu) |
| { |
| FmGridControl::PreExecuteRowContextMenu(nRow, rMenu); |
| |
| PopupMenu aNewItems(ModuleRes(RID_SBA_GRID_ROWCTXMENU)); |
| sal_uInt16 nPos = 0; |
| |
| if (!IsReadOnlyDB()) |
| { |
| rMenu.InsertItem(ID_BROWSER_TABLEATTR, aNewItems.GetItemText(ID_BROWSER_TABLEATTR), 0, nPos++); |
| rMenu.SetHelpId(ID_BROWSER_TABLEATTR, aNewItems.GetHelpId(ID_BROWSER_TABLEATTR)); |
| |
| rMenu.InsertItem(ID_BROWSER_ROWHEIGHT, aNewItems.GetItemText(ID_BROWSER_ROWHEIGHT), 0, nPos++); |
| rMenu.SetHelpId(ID_BROWSER_ROWHEIGHT, aNewItems.GetHelpId(ID_BROWSER_ROWHEIGHT)); |
| rMenu.InsertSeparator(nPos++); |
| } // if (!IsReadOnlyDB()) |
| |
| if ( GetSelectRowCount() > 0 ) |
| { |
| rMenu.InsertItem(ID_BROWSER_COPY, aNewItems.GetItemText(SID_COPY), 0, nPos++); |
| rMenu.SetHelpId(ID_BROWSER_COPY, aNewItems.GetHelpId(SID_COPY)); |
| |
| rMenu.InsertSeparator(nPos++); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| SvNumberFormatter* SbaGridControl::GetDatasourceFormatter() |
| { |
| Reference< ::com::sun::star::util::XNumberFormatsSupplier > xSupplier = ::dbtools::getNumberFormats(::dbtools::getConnection(Reference< XRowSet > (getDataSource(),UNO_QUERY)), sal_True,getServiceManager()); |
| |
| SvNumberFormatsSupplierObj* pSupplierImpl = SvNumberFormatsSupplierObj::getImplementation( xSupplier ); |
| if ( !pSupplierImpl ) |
| return NULL; |
| |
| SvNumberFormatter* pFormatter = pSupplierImpl->GetNumberFormatter(); |
| return pFormatter; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void SbaGridControl::SetColWidth(sal_uInt16 nColId) |
| { |
| // get the (UNO) column model |
| sal_uInt16 nModelPos = GetModelColumnPos(nColId); |
| Reference< XIndexAccess > xCols(GetPeer()->getColumns(), UNO_QUERY); |
| Reference< XPropertySet > xAffectedCol; |
| if (xCols.is() && (nModelPos != (sal_uInt16)-1)) |
| ::cppu::extractInterface(xAffectedCol,xCols->getByIndex(nModelPos)); |
| |
| if (xAffectedCol.is()) |
| { |
| Any aWidth = xAffectedCol->getPropertyValue(PROPERTY_WIDTH); |
| sal_Int32 nCurWidth = aWidth.hasValue() ? ::comphelper::getINT32(aWidth) : -1; |
| |
| DlgSize aDlgColWidth(this, nCurWidth, sal_False); |
| if (aDlgColWidth.Execute()) |
| { |
| sal_Int32 nValue = aDlgColWidth.GetValue(); |
| Any aNewWidth; |
| if (-1 == nValue) |
| { // set to default |
| Reference< XPropertyState > xPropState(xAffectedCol, UNO_QUERY); |
| if (xPropState.is()) |
| { |
| try { aNewWidth = xPropState->getPropertyDefault(PROPERTY_WIDTH); } catch(Exception&) { } ; |
| } |
| } |
| else |
| aNewWidth <<= nValue; |
| try { xAffectedCol->setPropertyValue(PROPERTY_WIDTH, aNewWidth); } catch(Exception&) { } ; |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void SbaGridControl::SetRowHeight() |
| { |
| Reference< XPropertySet > xCols(GetPeer()->getColumns(), UNO_QUERY); |
| if (!xCols.is()) |
| return; |
| |
| Any aHeight = xCols->getPropertyValue(PROPERTY_ROW_HEIGHT); |
| sal_Int32 nCurHeight = aHeight.hasValue() ? ::comphelper::getINT32(aHeight) : -1; |
| |
| DlgSize aDlgRowHeight(this, nCurHeight, sal_True); |
| if (aDlgRowHeight.Execute()) |
| { |
| sal_Int32 nValue = aDlgRowHeight.GetValue(); |
| Any aNewHeight; |
| if ((sal_Int16)-1 == nValue) |
| { // set to default |
| Reference< XPropertyState > xPropState(xCols, UNO_QUERY); |
| if (xPropState.is()) |
| { |
| try |
| { |
| aNewHeight = xPropState->getPropertyDefault(PROPERTY_ROW_HEIGHT); |
| } |
| catch(Exception&) |
| { } |
| } |
| } |
| else |
| aNewHeight <<= nValue; |
| try |
| { |
| xCols->setPropertyValue(PROPERTY_ROW_HEIGHT, aNewHeight); |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(0,"setPropertyValue: PROPERTY_ROW_HEIGHT throws a exception"); |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void SbaGridControl::SetColAttrs(sal_uInt16 nColId) |
| { |
| SvNumberFormatter* pFormatter = GetDatasourceFormatter(); |
| if (!pFormatter) |
| return; |
| |
| sal_uInt16 nModelPos = GetModelColumnPos(nColId); |
| |
| // get the (UNO) column model |
| Reference< XIndexAccess > xCols(GetPeer()->getColumns(), UNO_QUERY); |
| Reference< XPropertySet > xAffectedCol; |
| if (xCols.is() && (nModelPos != (sal_uInt16)-1)) |
| ::cppu::extractInterface(xAffectedCol,xCols->getByIndex(nModelPos)); |
| |
| // get the field the column is bound to |
| Reference< XPropertySet > xField = getField(nModelPos); |
| ::dbaui::callColumnFormatDialog(xAffectedCol,xField,pFormatter,this);//(Window::GetSettings().GetLanguage()); |
| } |
| |
| |
| //------------------------------------------------------------------------------ |
| void SbaGridControl::SetBrowserAttrs() |
| { |
| Reference< XPropertySet > xGridModel(GetPeer()->getColumns(), UNO_QUERY); |
| if (!xGridModel.is()) |
| return; |
| |
| try |
| { |
| PropertyValue aArg; |
| aArg.Name = ::rtl::OUString::createFromAscii("IntrospectedObject"); |
| aArg.Value <<= xGridModel; |
| Sequence< Any > aDialogArgs(1); |
| aDialogArgs[0] <<= aArg; |
| |
| Reference< XInterface > xDialog = getServiceManager()->createInstanceWithArguments( |
| ::rtl::OUString::createFromAscii("com.sun.star.form.ControlFontDialog"), |
| aDialogArgs |
| ); |
| if (!xDialog.is()) |
| { |
| ShowServiceNotAvailableError(this, String::CreateFromAscii("com.sun.star.form.ControlFontDialog"), sal_True); |
| return; |
| } |
| |
| Reference< XExecutableDialog > xExecute(xDialog, UNO_QUERY); |
| OSL_ENSURE(xExecute.is(), "SbaGridControl::SetBrowserAttrs: missing an interface on the dialog!"); |
| if (xExecute.is()) |
| xExecute->execute(); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::PostExecuteRowContextMenu(sal_uInt16 nRow, const PopupMenu& rMenu, sal_uInt16 nExecutionResult) |
| { |
| switch (nExecutionResult) |
| { |
| case ID_BROWSER_TABLEATTR: |
| SetBrowserAttrs(); |
| break; |
| case ID_BROWSER_ROWHEIGHT: |
| SetRowHeight(); |
| break; |
| case ID_BROWSER_COPY: |
| CopySelectedRowsToClipboard(); |
| break; |
| |
| default: |
| FmGridControl::PostExecuteRowContextMenu(nRow, rMenu, nExecutionResult); |
| break; |
| } |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::Select() |
| { |
| // irgendeine Selektion hat sich geaendert .... |
| FmGridControl::Select(); |
| |
| if (m_pMasterListener) |
| m_pMasterListener->SelectionChanged(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::CursorMoved() |
| { |
| FmGridControl::CursorMoved(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::ActivateCell(long nRow, sal_uInt16 nCol, sal_Bool bSetCellFocus /*= sal_True*/ ) |
| { |
| FmGridControl::ActivateCell(nRow, nCol, bSetCellFocus); |
| if (m_pMasterListener) |
| m_pMasterListener->CellActivated(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::DeactivateCell(sal_Bool bUpdate /*= sal_True*/) |
| { |
| FmGridControl::DeactivateCell(bUpdate); |
| if (m_pMasterListener) |
| m_pMasterListener->CellDeactivated(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::onRowChange() |
| { |
| if ( m_pMasterListener ) |
| m_pMasterListener->RowChanged(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::onColumnChange() |
| { |
| if ( m_pMasterListener ) |
| m_pMasterListener->ColumnChanged(); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::BeforeDrop() |
| { |
| if (m_pMasterListener) |
| m_pMasterListener->BeforeDrop(); |
| } |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::AfterDrop() |
| { |
| if (m_pMasterListener) |
| m_pMasterListener->AfterDrop(); |
| } |
| |
| |
| //------------------------------------------------------------------------------ |
| Reference< XPropertySet > SbaGridControl::getField(sal_uInt16 nModelPos) |
| { |
| Reference< XPropertySet > xEmptyReturn; |
| try |
| { |
| // first get the name of the column |
| Reference< XIndexAccess > xCols(GetPeer()->getColumns(), UNO_QUERY); |
| if ( xCols.is() && xCols->getCount() > nModelPos ) |
| { |
| Reference< XPropertySet > xCol(xCols->getByIndex(nModelPos),UNO_QUERY); |
| if ( xCol.is() ) |
| xEmptyReturn.set(xCol->getPropertyValue(PROPERTY_BOUNDFIELD),UNO_QUERY); |
| } |
| else |
| OSL_ENSURE(0,"SbaGridControl::getField getColumns returns NULL or ModelPos is > than count!"); |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(0,"SbaGridControl::getField Exception occurred!"); |
| } |
| |
| return xEmptyReturn; |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| sal_Bool SbaGridControl::IsReadOnlyDB() const |
| { |
| // assume yes if anything fails |
| sal_Bool bDBIsReadOnly = sal_True; |
| |
| // the db is the implemented by the parent of the grid control's model ... |
| Reference< XChild > xColumns(GetPeer()->getColumns(), UNO_QUERY); |
| if (xColumns.is()) |
| { |
| Reference< XRowSet > xDataSource(xColumns->getParent(), UNO_QUERY); |
| Reference< XChild > xConn(::dbtools::getConnection(xDataSource),UNO_QUERY); |
| if (xConn.is()) |
| { |
| // ... and the RO-flag simply is implemented by a property |
| Reference< XPropertySet > xDbProps(xConn->getParent(), UNO_QUERY); |
| if (xDbProps.is()) |
| { |
| Reference< XPropertySetInfo > xInfo = xDbProps->getPropertySetInfo(); |
| if (xInfo->hasPropertyByName(PROPERTY_ISREADONLY)) |
| bDBIsReadOnly = ::comphelper::getBOOL(xDbProps->getPropertyValue(PROPERTY_ISREADONLY)); |
| } |
| } |
| } |
| return bDBIsReadOnly; |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::MouseButtonDown( const BrowserMouseEvent& rMEvt) |
| { |
| long nRow = GetRowAtYPosPixel(rMEvt.GetPosPixel().Y()); |
| sal_uInt16 nColPos = GetColumnAtXPosPixel(rMEvt.GetPosPixel().X()); |
| sal_uInt16 nViewPos = (nColPos == BROWSER_INVALIDID) ? (sal_uInt16)-1 : nColPos-1; |
| // 'the handle column' and 'no valid column' will both result in a view position of -1 ! |
| |
| sal_Bool bHitEmptySpace = (nRow > GetRowCount()) || (nViewPos == (sal_uInt16)-1); |
| |
| if (bHitEmptySpace && (rMEvt.GetClicks() == 2) && rMEvt.IsMod1()) |
| Control::MouseButtonDown(rMEvt); |
| else |
| FmGridControl::MouseButtonDown(rMEvt); |
| } |
| |
| //--------------------------------------------------------------------------------------- |
| void SbaGridControl::StartDrag( sal_Int8 _nAction, const Point& _rPosPixel ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| // in the new DnD API, the solar mutex is not locked when StartDrag get's called |
| |
| sal_Bool bHandled = sal_False; |
| |
| do |
| { |
| // determine if dragging is allowed |
| // (Yes, this is controller (not view) functionality. But collecting and evaluating all the |
| // informations necessary via UNO would be quite difficult (if not impossible) so |
| // my laziness says 'do it here' ...) |
| long nRow = GetRowAtYPosPixel(_rPosPixel.Y()); |
| sal_uInt16 nColPos = GetColumnAtXPosPixel(_rPosPixel.X()); |
| sal_uInt16 nViewPos = (nColPos == BROWSER_INVALIDID) ? (sal_uInt16)-1 : nColPos-1; |
| // 'the handle column' and 'no valid column' will both result in a view position of -1 ! |
| |
| sal_Bool bCurrentRowVirtual = IsCurrentAppending() && IsModified(); |
| // the current row doesn't really exist : the user's appendign a new one and already has entered some data, |
| // so the row contains data which has no counter part within the data source |
| |
| long nCorrectRowCount = GetRowCount(); |
| if (GetOptions() & OPT_INSERT) |
| --nCorrectRowCount; // there is a empty row for inserting records |
| if (bCurrentRowVirtual) |
| --nCorrectRowCount; |
| |
| if ((nColPos == BROWSER_INVALIDID) || (nRow >= nCorrectRowCount)) |
| break; |
| |
| sal_Bool bHitHandle = (nColPos == 0); |
| |
| // check which kind of dragging has to be initiated |
| if ( bHitHandle // the handle column |
| // AND |
| && ( GetSelectRowCount() // at least one row is selected |
| // OR |
| || ( (nRow >= 0) // a row below the header |
| && !bCurrentRowVirtual // we aren't appending a new record |
| && (nRow != GetCurrentPos()) // a row which is not the current one |
| ) // OR |
| || ( (0 == GetSelectRowCount()) // no rows selected |
| && (-1 == nRow) // hit the header |
| ) |
| ) |
| ) |
| { // => start dragging the row |
| if (GetDataWindow().IsMouseCaptured()) |
| GetDataWindow().ReleaseMouse(); |
| |
| if (0 == GetSelectRowCount()) |
| // no rows selected, but here in this branch |
| // -> the user started dragging the upper left corner, which symbolizes the whole table |
| SelectAll(); |
| |
| getMouseEvent().Clear(); |
| DoRowDrag((sal_Int16)nRow); |
| |
| bHandled = sal_True; |
| } |
| else if ( (nRow < 0) // the header |
| && (!bHitHandle) // non-handle column |
| && (nViewPos < GetViewColCount()) // valid (existing) column |
| ) |
| { // => start dragging the column |
| if (GetDataWindow().IsMouseCaptured()) |
| GetDataWindow().ReleaseMouse(); |
| |
| getMouseEvent().Clear(); |
| DoColumnDrag(nViewPos); |
| |
| bHandled = sal_True; |
| } |
| else if ( !bHitHandle // non-handle column |
| && (nRow >= 0) // non-header row |
| ) |
| { // => start dragging the field content |
| if (GetDataWindow().IsMouseCaptured()) |
| GetDataWindow().ReleaseMouse(); |
| |
| getMouseEvent().Clear(); |
| DoFieldDrag(nViewPos, (sal_Int16)nRow); |
| |
| bHandled = sal_True; |
| } |
| } |
| while (sal_False); |
| |
| if (!bHandled) |
| FmGridControl::StartDrag(_nAction, _rPosPixel); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void SbaGridControl::Command(const CommandEvent& rEvt) |
| { |
| FmGridControl::Command(rEvt); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void SbaGridControl::DoColumnDrag(sal_uInt16 nColumnPos) |
| { |
| Reference< XPropertySet > xDataSource(getDataSource(), UNO_QUERY); |
| DBG_ASSERT(xDataSource.is(), "SbaGridControl::DoColumnDrag : invalid data source !"); |
| |
| Reference< XPropertySet > xAffectedCol; |
| Reference< XPropertySet > xAffectedField; |
| Reference< XConnection > xActiveConnection; |
| |
| // determine the field to drag |
| ::rtl::OUString sField; |
| try |
| { |
| xActiveConnection = ::dbtools::getConnection(Reference< XRowSet >(getDataSource(),UNO_QUERY)); |
| |
| sal_uInt16 nModelPos = GetModelColumnPos(GetColumnIdFromViewPos(nColumnPos)); |
| Reference< XIndexContainer > xCols(GetPeer()->getColumns(), UNO_QUERY); |
| xAffectedCol.set(xCols->getByIndex(nModelPos),UNO_QUERY); |
| if (xAffectedCol.is()) |
| { |
| xAffectedCol->getPropertyValue(PROPERTY_CONTROLSOURCE) >>= sField; |
| xAffectedField.set(xAffectedCol->getPropertyValue(PROPERTY_BOUNDFIELD),UNO_QUERY); |
| } |
| } |
| catch(Exception&) |
| { |
| DBG_ERROR("SbaGridControl::DoColumnDrag : something went wrong while getting the column"); |
| } |
| if (0 == sField.getLength()) |
| return; |
| |
| OColumnTransferable* pDataTransfer = new OColumnTransferable(xDataSource, sField, xAffectedField, xActiveConnection, CTF_FIELD_DESCRIPTOR | CTF_COLUMN_DESCRIPTOR); |
| Reference< XTransferable > xEnsureDelete = pDataTransfer; |
| pDataTransfer->StartDrag(this, DND_ACTION_COPY | DND_ACTION_LINK); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void SbaGridControl::CopySelectedRowsToClipboard() |
| { |
| DBG_ASSERT( GetSelectRowCount() > 0, "SbaGridControl::CopySelectedRowsToClipboard: invalid call!" ); |
| implTransferSelectedRows( (sal_Int16)FirstSelectedRow(), true ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void SbaGridControl::DoRowDrag( sal_Int16 nRowPos ) |
| { |
| implTransferSelectedRows( nRowPos, false ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void SbaGridControl::implTransferSelectedRows( sal_Int16 nRowPos, bool _bTrueIfClipboardFalseIfDrag ) |
| { |
| Reference< XPropertySet > xForm( getDataSource(), UNO_QUERY ); |
| DBG_ASSERT( xForm.is(), "SbaGridControl::implTransferSelectedRows: invalid form!" ); |
| |
| // build the sequence of numbers of selected rows |
| Sequence< Any > aSelectedRows; |
| sal_Bool bSelectionBookmarks = sal_True; |
| |
| // collect the affected rows |
| if ((GetSelectRowCount() == 0) && (nRowPos >= 0)) |
| { |
| aSelectedRows.realloc( 1 ); |
| aSelectedRows[0] <<= (sal_Int32)(nRowPos + 1); |
| bSelectionBookmarks = sal_False; |
| } |
| else if ( !IsAllSelected() && GetSelectRowCount() ) |
| { |
| aSelectedRows = getSelectionBookmarks(); |
| bSelectionBookmarks = sal_True; |
| } |
| |
| Reference< XResultSet> xRowSetClone; |
| try |
| { |
| ODataClipboard* pTransfer = new ODataClipboard( xForm, aSelectedRows, bSelectionBookmarks, getServiceManager() ); |
| |
| Reference< XTransferable > xEnsureDelete = pTransfer; |
| if ( _bTrueIfClipboardFalseIfDrag ) |
| pTransfer->CopyToClipboard( this ); |
| else |
| pTransfer->StartDrag(this, DND_ACTION_COPY | DND_ACTION_LINK); |
| } |
| catch(Exception&) |
| { |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| void SbaGridControl::DoFieldDrag(sal_uInt16 nColumnPos, sal_Int16 nRowPos) |
| { |
| // the only thing to do here is dragging the pure cell text |
| // the old implementation copied a SBA_FIELDDATAEXCHANGE_FORMAT, too, (which was rather expensive to obtain), |
| // but we have no client for this DnD format anymore (the mail part of SO 5.2 was the only client) |
| |
| ::rtl::OUString sCellText; |
| try |
| { |
| Reference< XGridFieldDataSupplier > xFieldData(static_cast< XGridPeer* >(GetPeer()), UNO_QUERY); |
| Sequence<sal_Bool> aSupportingText = xFieldData->queryFieldDataType(::getCppuType(&sCellText)); |
| if (aSupportingText.getConstArray()[nColumnPos]) |
| { |
| Sequence< Any> aCellContents = xFieldData->queryFieldData(nRowPos, ::getCppuType(&sCellText)); |
| sCellText = ::comphelper::getString(aCellContents.getConstArray()[nColumnPos]); |
| ::svt::OStringTransfer::StartStringDrag(sCellText, this, DND_ACTION_COPY); |
| } |
| } |
| catch(Exception&) |
| { |
| DBG_ERROR("SbaGridControl::DoFieldDrag : could not retrieve the cell's contents !"); |
| return; |
| } |
| |
| } |
| /// unary_function Functor object for class ZZ returntype is void |
| struct SbaGridControlPrec : ::std::unary_function<DataFlavorExVector::value_type,bool> |
| { |
| sal_Bool bQueryDrop; |
| SbaGridControlPrec(sal_Bool _bQueryDrop) |
| : bQueryDrop(_bQueryDrop) |
| { |
| } |
| |
| inline bool operator()(const DataFlavorExVector::value_type& _aType) |
| { |
| switch (_aType.mnSotId) |
| { |
| // case SOT_FORMAT_RTF: // RTF data descriptions |
| // case SOT_FORMATSTR_ID_HTML: // HTML data descriptions |
| case SOT_FORMATSTR_ID_DBACCESS_TABLE: // table descriptor |
| case SOT_FORMATSTR_ID_DBACCESS_QUERY: // query descriptor |
| case SOT_FORMATSTR_ID_DBACCESS_COMMAND: // SQL command |
| return true; |
| } |
| return false; |
| } |
| }; |
| //------------------------------------------------------------------------------ |
| sal_Int8 SbaGridControl::AcceptDrop( const BrowserAcceptDropEvent& rEvt ) |
| { |
| sal_Int8 nAction = DND_ACTION_NONE; |
| |
| // we need a valid connection |
| if (!::dbtools::getConnection(Reference< XRowSet > (getDataSource(),UNO_QUERY)).is()) |
| return nAction; |
| |
| if ( IsDropFormatSupported( FORMAT_STRING ) ) do |
| { // odd construction, but spares us a lot of (explicit ;) goto's |
| |
| if (!GetEmptyRow().Is()) |
| // without an empty row we're not in update mode |
| break; |
| |
| long nRow = GetRowAtYPosPixel(rEvt.maPosPixel.Y(), sal_False); |
| sal_uInt16 nCol = GetColumnAtXPosPixel(rEvt.maPosPixel.X(), sal_False); |
| |
| long nCorrectRowCount = GetRowCount(); |
| if (GetOptions() & OPT_INSERT) |
| --nCorrectRowCount; // there is a empty row for inserting records |
| if (IsCurrentAppending()) |
| --nCorrectRowCount; // the current data record doesn't really exist, we are appending a new one |
| |
| if ((nCol == BROWSER_INVALIDID) || (nRow >= nCorrectRowCount) || GetColumnId(nCol) == 0 ) |
| // no valid cell under the mouse cursor |
| break; |
| |
| Rectangle aRect = GetCellRect(nRow, nCol, sal_False); |
| if (!aRect.IsInside(rEvt.maPosPixel)) |
| // not dropped within a cell (a cell isn't as wide as the column - the are small spaces) |
| break; |
| |
| if ((IsModified() || (GetCurrentRow().Is() && GetCurrentRow()->IsModified())) && (GetCurrentPos() != nRow)) |
| // there is a current and modified row or cell and he text is to be dropped into another one |
| break; |
| |
| CellControllerRef xCurrentController = Controller(); |
| if (xCurrentController.Is() && xCurrentController->IsModified() && ((nRow != GetCurRow()) || (nCol != GetCurColumnId()))) |
| // the current controller is modified and the user wants to drop in another cell -> no chance |
| // (when leaving the modified cell a error may occur - this is deadly while dragging) |
| break; |
| |
| Reference< XPropertySet > xField = getField(GetModelColumnPos(nCol)); |
| if (!xField.is()) |
| // the column is not valid bound (for instance a binary field) |
| break; |
| |
| try |
| { |
| if (::comphelper::getBOOL(xField->getPropertyValue(PROPERTY_ISREADONLY))) |
| break; |
| } |
| catch (const Exception& e ) |
| { |
| (void)e; // make compiler happy |
| // assume RO |
| break; |
| } |
| |
| try |
| { |
| // assume that text can be dropped into a field if the column has a ::com::sun::star::awt::XTextComponent interface |
| Reference< XIndexAccess > xColumnControls((::com::sun::star::form::XGridPeer*)GetPeer(), UNO_QUERY); |
| if (xColumnControls.is()) |
| { |
| Reference< ::com::sun::star::awt::XTextComponent > xColControl; |
| ::cppu::extractInterface(xColControl,xColumnControls->getByIndex(GetViewColumnPos(nCol))); |
| if (xColControl.is()) |
| { |
| m_bActivatingForDrop = sal_True; |
| GoToRowColumnId(nRow, nCol); |
| m_bActivatingForDrop = sal_False; |
| |
| nAction = DND_ACTION_COPY; |
| } |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| } while (sal_False); |
| |
| if(nAction != DND_ACTION_COPY && GetEmptyRow().Is()) |
| { |
| const DataFlavorExVector& _rFlavors = GetDataFlavors(); |
| if(::std::find_if(_rFlavors.begin(),_rFlavors.end(),SbaGridControlPrec(sal_True)) != _rFlavors.end()) |
| nAction = DND_ACTION_COPY; |
| } |
| |
| /* |
| // check formats |
| SvDataObjectRef xDataObj = SvDataObject::PasteDragServer( rEvt ); |
| if (!xDataObj.Is()) |
| return sal_False; |
| |
| const SvDataTypeList& rTypeList = xDataObj->GetTypeList(); |
| if ((rTypeList.Get(Exchange::RegisterFormatName(String::CreateFromAscii(SBA_DATAEXCHANGE_FORMAT)))) ) |
| { |
| bAllow = (GetOptions() & OPT_INSERT) && rEvt.GetColumnId() > 0 && rEvt.GetRow() >= 0; |
| ((BrowserDropEvent&)rEvt).SetAction(DROP_COPY); |
| } |
| |
| */ |
| return (DND_ACTION_NONE != nAction) ? nAction : FmGridControl::AcceptDrop(rEvt); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Int8 SbaGridControl::ExecuteDrop( const BrowserExecuteDropEvent& rEvt ) |
| { |
| // we need some properties of our data source |
| Reference< XPropertySet > xDataSource = getDataSource(); |
| if (!xDataSource.is()) |
| return DND_ACTION_NONE; |
| |
| // we need a valid connection |
| if (!::dbtools::getConnection(Reference< XRowSet > (xDataSource,UNO_QUERY)).is()) |
| return DND_ACTION_NONE; |
| |
| if ( IsDropFormatSupported( FORMAT_STRING ) ) |
| { |
| long nRow = GetRowAtYPosPixel(rEvt.maPosPixel.Y(), sal_False); |
| sal_uInt16 nCol = GetColumnAtXPosPixel(rEvt.maPosPixel.X(), sal_False); |
| |
| long nCorrectRowCount = GetRowCount(); |
| if (GetOptions() & OPT_INSERT) |
| --nCorrectRowCount; // there is a empty row for inserting records |
| if (IsCurrentAppending()) |
| --nCorrectRowCount; // the current data record doesn't really exist, we are appending a new one |
| |
| DBG_ASSERT((nCol != BROWSER_INVALIDID) && (nRow < nCorrectRowCount), "SbaGridControl::Drop : dropped on an invalid position !"); |
| // AcceptDrop should have caught this |
| |
| // from now we work with ids instead of positions |
| nCol = GetColumnId(nCol); |
| |
| GoToRowColumnId(nRow, nCol); |
| if (!IsEditing()) |
| ActivateCell(); |
| |
| CellControllerRef xCurrentController = Controller(); |
| if (!xCurrentController.Is() || !xCurrentController->ISA(EditCellController)) |
| return DND_ACTION_NONE; |
| Edit& rEdit = (Edit&)xCurrentController->GetWindow(); |
| |
| // get the dropped string |
| TransferableDataHelper aDropped( rEvt.maDropEvent.Transferable ); |
| String sDropped; |
| if ( !aDropped.GetString( FORMAT_STRING, sDropped ) ) |
| return DND_ACTION_NONE; |
| |
| rEdit.SetText( sDropped ); |
| xCurrentController->SetModified(); |
| rEdit.Modify(); |
| // SetText itself doesn't call a Modify as it isn't a user interaction |
| |
| return DND_ACTION_COPY; |
| } |
| |
| if(GetEmptyRow().Is()) |
| { |
| const DataFlavorExVector& _rFlavors = GetDataFlavors(); |
| DataFlavorExVector::const_iterator aFind = ::std::find_if(_rFlavors.begin(),_rFlavors.end(),SbaGridControlPrec(sal_True)); |
| if( aFind != _rFlavors.end()) |
| { |
| TransferableDataHelper aDropped( rEvt.maDropEvent.Transferable ); |
| m_aDataDescriptor = ODataAccessObjectTransferable::extractObjectDescriptor(aDropped); |
| if (m_nAsyncDropEvent) |
| Application::RemoveUserEvent(m_nAsyncDropEvent); |
| m_nAsyncDropEvent = Application::PostUserEvent(LINK(this, SbaGridControl, AsynchDropEvent)); |
| return DND_ACTION_COPY; |
| } |
| } |
| |
| return DND_ACTION_NONE; |
| } |
| |
| //------------------------------------------------------------------------------ |
| Reference< XPropertySet > SbaGridControl::getDataSource() const |
| { |
| Reference< XPropertySet > xReturn; |
| |
| Reference< XChild > xColumns(GetPeer()->getColumns(), UNO_QUERY); |
| Reference< XPropertySet > xDataSource; |
| if (xColumns.is()) |
| xReturn = Reference< XPropertySet > (xColumns->getParent(), UNO_QUERY); |
| |
| return xReturn; |
| } |
| // ----------------------------------------------------------------------------- |
| IMPL_LINK(SbaGridControl, AsynchDropEvent, void*, /*EMPTY_ARG*/) |
| { |
| m_nAsyncDropEvent = 0; |
| |
| Reference< XPropertySet > xDataSource = getDataSource(); |
| if ( xDataSource.is() ) |
| { |
| sal_Bool bCountFinal = sal_False; |
| xDataSource->getPropertyValue(PROPERTY_ISROWCOUNTFINAL) >>= bCountFinal; |
| if ( !bCountFinal ) |
| setDataSource(NULL); // deattach from grid control |
| Reference< XResultSetUpdate > xResultSetUpdate(xDataSource,UNO_QUERY); |
| ODatabaseImportExport* pImExport = new ORowSetImportExport(this,xResultSetUpdate,m_aDataDescriptor,getServiceManager()); |
| Reference<XEventListener> xHolder = pImExport; |
| Hide(); |
| try |
| { |
| pImExport->initialize(m_aDataDescriptor); |
| BeforeDrop(); |
| if(!pImExport->Read()) |
| { |
| String sError = String(ModuleRes(STR_NO_COLUMNNAME_MATCHING)); |
| throwGenericSQLException(sError,NULL); |
| } |
| AfterDrop(); |
| Show(); |
| } |
| catch(const SQLException& e) |
| { |
| AfterDrop(); |
| Show(); |
| ::dbaui::showError(::dbtools::SQLExceptionInfo(e),this,getServiceManager()); |
| } |
| catch(const Exception& ) |
| { |
| AfterDrop(); |
| Show(); |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| if ( !bCountFinal ) |
| setDataSource(Reference< XRowSet >(xDataSource,UNO_QUERY)); |
| } |
| m_aDataDescriptor.clear(); |
| |
| return 0L; |
| } |
| // ------------------------------------------------------------------------- |
| ::rtl::OUString SbaGridControl::GetAccessibleObjectDescription( ::svt::AccessibleBrowseBoxObjType eObjType,sal_Int32 _nPosition) const |
| { |
| ::rtl::OUString sRet; |
| if ( ::svt::BBTYPE_BROWSEBOX == eObjType ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sRet = String(ModuleRes(STR_DATASOURCE_GRIDCONTROL_DESC)); |
| } |
| else |
| sRet = FmGridControl::GetAccessibleObjectDescription( eObjType,_nPosition); |
| return sRet; |
| } |
| // ----------------------------------------------------------------------------- |
| void SbaGridControl::DeleteSelectedRows() |
| { |
| FmGridControl::DeleteSelectedRows(); |
| } |
| |
| |