/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_extensions.hxx"
#include <vcl/waitobj.hxx>
#include <cppuhelper/interfacecontainer.hxx>
#include <com/sun/star/util/URL.hpp>
#include <osl/mutex.hxx>
#include <vcl/msgbox.hxx>
#include <tools/debug.hxx>
#include <vcl/stdtext.hxx>
#include <comphelper/types.hxx>
#include <comphelper/sequence.hxx>
#include "framectr.hxx"
#include "datman.hxx"
#include "bibresid.hxx"
#include "bib.hrc"
#include <toolkit/helper/vclunohelper.hxx>
#include "bibconfig.hxx"
#include <cppuhelper/implbase1.hxx> // helper for implementations
#include <vcl/svapp.hxx>
#include "bibliography.hrc"
#include <comphelper/processfactory.hxx>
#include <com/sun/star/form/XConfirmDeleteListener.hpp>
#include <com/sun/star/form/runtime/XFormController.hpp>
#include <com/sun/star/beans/PropertyState.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
#include <com/sun/star/sdbcx/Privilege.hpp>
#include <com/sun/star/sdbc/XResultSetUpdate.hpp>
#include <com/sun/star/sdb/RowChangeAction.hpp>
#include <com/sun/star/frame/CommandGroup.hpp>
#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
#include <sot/exchange.hxx>
#include <sot/formats.hxx>
#include <vcl/edit.hxx>
#include <vos/mutex.hxx>
#include <hash_map>
using namespace osl;
using namespace cppu;
using namespace rtl;
using namespace com::sun::star::sdbc;
using namespace com::sun::star::frame;
using namespace com::sun::star::uno;
using namespace com::sun::star;
#define C2U(cChar) OUString::createFromAscii(cChar)
struct DispatchInfo
{
const char* pCommand;
sal_Int16 nGroupId;
sal_Bool bActiveConnection;
};
struct CacheDispatchInfo
{
sal_Int16 nGroupId;
sal_Bool bActiveConnection;
};
// Attention: commands must be sorted by command groups. Implementation is dependent
// on this!!
static DispatchInfo SupportedCommandsArray[] =
{
{ ".uno:Undo" , frame::CommandGroup::EDIT , sal_False },
{ ".uno:Cut" , frame::CommandGroup::EDIT , sal_False },
{ ".uno:Copy" , frame::CommandGroup::EDIT , sal_False },
{ ".uno:Paste" , frame::CommandGroup::EDIT , sal_False },
{ ".uno:SelectAll" , frame::CommandGroup::EDIT , sal_False },
{ ".uno:CloseDoc" , frame::CommandGroup::DOCUMENT , sal_False },
{ ".uno:StatusBarVisible" , frame::CommandGroup::VIEW , sal_False },
{ ".uno:AvailableToolbars" , frame::CommandGroup::VIEW , sal_False },
{ ".uno:Bib/standardFilter" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/DeleteRecord" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/InsertRecord" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/query" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/autoFilter" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/source" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/removeFilter" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/sdbsource" , frame::CommandGroup::DATA , sal_True },
{ ".uno:Bib/Mapping" , frame::CommandGroup::DATA , sal_True },
{ 0 , 0 , sal_False }
};
typedef ::std::hash_map< ::rtl::OUString, CacheDispatchInfo, rtl::OUStringHash, ::std::equal_to< ::rtl::OUString > > CmdToInfoCache;
SV_IMPL_PTRARR( BibStatusDispatchArr, BibStatusDispatchPtr );
const CmdToInfoCache& GetCommandToInfoCache()
{
static sal_Bool bCacheInitialized = sal_False;
static CmdToInfoCache aCmdToInfoCache;
if ( !bCacheInitialized )
{
::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
if ( !bCacheInitialized )
{
sal_Int32 i( 0 );
while ( SupportedCommandsArray[i].pCommand != 0 )
{
rtl::OUString aCommand( rtl::OUString::createFromAscii( SupportedCommandsArray[i].pCommand ));
CacheDispatchInfo aDispatchInfo;
aDispatchInfo.nGroupId = SupportedCommandsArray[i].nGroupId;
aDispatchInfo.bActiveConnection = SupportedCommandsArray[i].bActiveConnection;
aCmdToInfoCache.insert( CmdToInfoCache::value_type( aCommand, aDispatchInfo ));
++i;
}
bCacheInitialized = sal_True;
}
}
return aCmdToInfoCache;
}
class BibFrameCtrl_Impl : public cppu::WeakImplHelper1 < XFrameActionListener >
{
public:
Mutex aMutex;
OMultiTypeInterfaceContainerHelper aLC;
BibFrameController_Impl* pController;
BibFrameCtrl_Impl()
: aLC( aMutex )
, pController(0)
{}
~BibFrameCtrl_Impl();
virtual void SAL_CALL frameAction(const FrameActionEvent& aEvent) throw( RuntimeException );
virtual void SAL_CALL disposing( const lang::EventObject& Source ) throw (::com::sun::star::uno::RuntimeException);
};
BibFrameCtrl_Impl::~BibFrameCtrl_Impl()
{
}
void BibFrameCtrl_Impl::frameAction(const FrameActionEvent& aEvent) throw( uno::RuntimeException )
{
if ( pController && aEvent.Frame == pController->getFrame())
{
if(aEvent.Action == FrameAction_FRAME_ACTIVATED)
{
pController->activate();
}
else if(aEvent.Action == FrameAction_FRAME_DEACTIVATING)
{
pController->deactivate();
}
}
}
void BibFrameCtrl_Impl::disposing( const lang::EventObject& /*Source*/ )
throw (::com::sun::star::uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
if ( pController )
pController->getFrame()->removeFrameActionListener( this );
}
BibFrameController_Impl::BibFrameController_Impl( const uno::Reference< awt::XWindow > & xComponent,
BibDataManager* pDataManager)
:xWindow( xComponent )
,m_xDatMan( pDataManager )
,pDatMan( pDataManager )
,pBibMod(NULL)
{
Window* pParent = VCLUnoHelper::GetWindow( xWindow );
pParent->SetUniqueId(UID_BIB_FRAME_WINDOW);
bDisposing=sal_False;
bHierarchical=sal_True;
pImp = new BibFrameCtrl_Impl;
pImp->pController = this;
pImp->acquire();
}
BibFrameController_Impl::~BibFrameController_Impl()
{
pImp->pController = NULL;
pImp->release();
delete pDatMan;
if(pBibMod)
CloseBibModul(pBibMod);
}
::rtl::OUString SAL_CALL BibFrameController_Impl::getImplementationName() throw (::com::sun::star::uno::RuntimeException)
{
return ::rtl::OUString::createFromAscii("com.sun.star.comp.extensions.Bibliography");
}
sal_Bool SAL_CALL BibFrameController_Impl::supportsService( const ::rtl::OUString& sServiceName ) throw (::com::sun::star::uno::RuntimeException)
{
return (
sServiceName.equalsAscii("com.sun.star.frame.Bibliography") ||
sServiceName.equalsAscii("com.sun.star.frame.Controller")
);
}
::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL BibFrameController_Impl::getSupportedServiceNames() throw (::com::sun::star::uno::RuntimeException)
{
// return only top level services ...
// base services are included there and should be asked by uno-rtti.
::com::sun::star::uno::Sequence< ::rtl::OUString > lNames(1);
lNames[0] = ::rtl::OUString::createFromAscii("com.sun.star.frame.Bibliography");
return lNames;
}
void BibFrameController_Impl::attachFrame( const uno::Reference< XFrame > & xArg ) throw (::com::sun::star::uno::RuntimeException)
{
xFrame = xArg;
xFrame->addFrameActionListener( pImp );
}
sal_Bool BibFrameController_Impl::attachModel( const uno::Reference< XModel > & /*xModel*/ ) throw (::com::sun::star::uno::RuntimeException)
{
return sal_False;
}
sal_Bool BibFrameController_Impl::suspend( sal_Bool bSuspend ) throw (::com::sun::star::uno::RuntimeException)
{
if ( bSuspend )
getFrame()->removeFrameActionListener( pImp );
else
getFrame()->addFrameActionListener( pImp );
return sal_True;
}
uno::Any BibFrameController_Impl::getViewData() throw (::com::sun::star::uno::RuntimeException)
{
return uno::Any();
}
void BibFrameController_Impl::restoreViewData( const uno::Any& /*Value*/ ) throw (::com::sun::star::uno::RuntimeException)
{
}
uno::Reference< XFrame > BibFrameController_Impl::getFrame() throw (::com::sun::star::uno::RuntimeException)
{
return xFrame;
}
uno::Reference< XModel > BibFrameController_Impl::getModel() throw (::com::sun::star::uno::RuntimeException)
{
return uno::Reference< XModel > ();
}
void BibFrameController_Impl::dispose() throw (::com::sun::star::uno::RuntimeException)
{
bDisposing = sal_True;
lang::EventObject aObject;
aObject.Source = (XController*)this;
pImp->aLC.disposeAndClear(aObject);
m_xDatMan = 0;
pDatMan = 0;
aStatusListeners.DeleteAndDestroy( 0, aStatusListeners.Count() );
}
void BibFrameController_Impl::addEventListener( const uno::Reference< lang::XEventListener > & aListener ) throw (::com::sun::star::uno::RuntimeException)
{
pImp->aLC.addInterface( ::getCppuType((const Reference< lang::XEventListener >*)0), aListener );
}
void BibFrameController_Impl::removeEventListener( const uno::Reference< lang::XEventListener > & aListener ) throw (::com::sun::star::uno::RuntimeException)
{
pImp->aLC.removeInterface( ::getCppuType((const Reference< lang::XEventListener >*)0), aListener );
}
uno::Reference< frame::XDispatch > BibFrameController_Impl::queryDispatch( const util::URL& aURL, const rtl::OUString& /*aTarget*/, sal_Int32 /*nSearchFlags*/ ) throw (::com::sun::star::uno::RuntimeException)
{
if ( !bDisposing )
{
const CmdToInfoCache& rCmdCache = GetCommandToInfoCache();
CmdToInfoCache::const_iterator pIter = rCmdCache.find( aURL.Complete );
if ( pIter != rCmdCache.end() )
{
if (( pDatMan->HasActiveConnection() ) ||
( !pIter->second.bActiveConnection ))
return (frame::XDispatch*) this;
}
}
return uno::Reference< frame::XDispatch > ();
}
uno::Sequence<uno::Reference< XDispatch > > BibFrameController_Impl::queryDispatches( const uno::Sequence<DispatchDescriptor>& aDescripts ) throw (::com::sun::star::uno::RuntimeException)
{
uno::Sequence< uno::Reference< XDispatch > > aDispatches( aDescripts.getLength() );
for ( sal_Int32 i=0; i<aDescripts.getLength(); ++i )
aDispatches[i] = queryDispatch( aDescripts[i].FeatureURL, aDescripts[i].FrameName, aDescripts[i].SearchFlags );
return aDispatches;
}
uno::Sequence< ::sal_Int16 > SAL_CALL BibFrameController_Impl::getSupportedCommandGroups()
throw (::com::sun::star::uno::RuntimeException)
{
uno::Sequence< ::sal_Int16 > aDispatchInfo( 4 );
aDispatchInfo[0] = frame::CommandGroup::EDIT;
aDispatchInfo[1] = frame::CommandGroup::DOCUMENT;
aDispatchInfo[2] = frame::CommandGroup::DATA;
aDispatchInfo[3] = frame::CommandGroup::VIEW;
return aDispatchInfo;
}
uno::Sequence< frame::DispatchInformation > SAL_CALL BibFrameController_Impl::getConfigurableDispatchInformation( ::sal_Int16 nCommandGroup )
throw (::com::sun::star::uno::RuntimeException)
{
const CmdToInfoCache& rCmdCache = GetCommandToInfoCache();
sal_Bool bGroupFound( sal_False );
frame::DispatchInformation aDispatchInfo;
std::list< frame::DispatchInformation > aDispatchInfoList;
if (( nCommandGroup == frame::CommandGroup::EDIT ) ||
( nCommandGroup == frame::CommandGroup::DOCUMENT ) ||
( nCommandGroup == frame::CommandGroup::DATA ) ||
( nCommandGroup == frame::CommandGroup::VIEW ))
{
CmdToInfoCache::const_iterator pIter = rCmdCache.begin();
while ( pIter != rCmdCache.end() )
{
if ( pIter->second.nGroupId == nCommandGroup )
{
bGroupFound = sal_True;
aDispatchInfo.Command = pIter->first;
aDispatchInfo.GroupId = pIter->second.nGroupId;
aDispatchInfoList.push_back( aDispatchInfo );
}
else if ( bGroupFound )
break;
++pIter;
}
}
::com::sun::star::uno::Sequence< ::com::sun::star::frame::DispatchInformation > aSeq =
comphelper::containerToSequence< ::com::sun::star::frame::DispatchInformation, std::list< ::com::sun::star::frame::DispatchInformation > >( aDispatchInfoList );
return aSeq;
}
sal_Bool canInsertRecords(const Reference< beans::XPropertySet>& _rxCursorSet)
{
sal_Int32 nPriv = 0;
_rxCursorSet->getPropertyValue(C2U("Privileges")) >>= nPriv;
return ((_rxCursorSet.is() && (nPriv & sdbcx::Privilege::INSERT) != 0));
}
/* -----------------------------08.05.2002 08:58------------------------------
---------------------------------------------------------------------------*/
sal_Bool BibFrameController_Impl::SaveModified(const Reference< form::runtime::XFormController>& xController)
{
if (!xController.is())
return sal_False;
sal_Bool bInserted = sal_False;
Reference< XResultSetUpdate> _xCursor = Reference< XResultSetUpdate>(xController->getModel(), UNO_QUERY);
if (!_xCursor.is())
return sal_False;
Reference< beans::XPropertySet> _xSet = Reference< beans::XPropertySet>(_xCursor, UNO_QUERY);
if (!_xSet.is())
return sal_False;
// muß gespeichert werden ?
sal_Bool bIsNew = ::comphelper::getBOOL(_xSet->getPropertyValue(C2U("IsNew")));
sal_Bool bIsModified = ::comphelper::getBOOL(_xSet->getPropertyValue(C2U("IsModified")));
sal_Bool bResult = !bIsModified;
if (bIsModified)
{
try
{
if (bIsNew)
_xCursor->insertRow();
else
_xCursor->updateRow();
bResult = sal_True;
}
catch(Exception&)
{
DBG_ERROR("SaveModified: Exception occurred!");
}
bInserted = bIsNew && bResult;
}
return bResult;
}
Window* lcl_GetFocusChild( Window* pParent )
{
sal_uInt16 nChildren = pParent->GetChildCount();
for( sal_uInt16 nChild = 0; nChild < nChildren; ++nChild)
{
Window* pChild = pParent->GetChild( nChild );
if(pChild->HasFocus())
return pChild;
Window* pSubChild = lcl_GetFocusChild( pChild );
if(pSubChild)
return pSubChild;
}
return 0;
}
//class XDispatch
void BibFrameController_Impl::dispatch(const util::URL& _rURL, const uno::Sequence< beans::PropertyValue >& aArgs) throw (::com::sun::star::uno::RuntimeException)
{
if ( !bDisposing )
{
vos::OGuard aGuard(Application::GetSolarMutex());
Window* pParent = VCLUnoHelper::GetWindow( xWindow );
WaitObject aWaitObject( pParent );
String aCommand( _rURL.Path);
if(aCommand.EqualsAscii("Bib/Mapping"))
{
pDatMan->CreateMappingDialog(pParent);
}
else if(aCommand.EqualsAscii("Bib/source"))
{
ChangeDataSource(aArgs);
}
else if(aCommand.EqualsAscii("Bib/sdbsource"))
{
rtl::OUString aURL = pDatMan->CreateDBChangeDialog(pParent);
if(aURL.getLength())
{
try
{
uno::Sequence< beans::PropertyValue > aNewDataSource(2);
beans::PropertyValue* pProps = aNewDataSource.getArray();
pProps[0].Value <<= rtl::OUString();
pProps[1].Value <<= aURL;
ChangeDataSource(aNewDataSource);
}
catch(const Exception&)
{
DBG_ERROR("Exception catched while changing the data source");
}
}
}
else if(aCommand.EqualsAscii("Bib/autoFilter"))
{
sal_uInt16 nCount = aStatusListeners.Count();
for ( sal_uInt16 n=0; n<nCount; n++ )
{
BibStatusDispatch *pObj = aStatusListeners[n];
if ( pObj->aURL.Path == C2U("Bib/removeFilter") )
{
FeatureStateEvent aEvent;
aEvent.FeatureURL = pObj->aURL;
aEvent.IsEnabled = sal_True;
aEvent.Requery = sal_False;
aEvent.Source = (XDispatch *) this;
pObj->xListener->statusChanged( aEvent );
//break; because there are more than one
}
}
const beans::PropertyValue* pPropertyValue = aArgs.getConstArray();
uno::Any aValue=pPropertyValue[0].Value;
rtl::OUString aQuery;
aValue >>= aQuery;
aValue=pPropertyValue[1].Value;
rtl::OUString aQueryField;
aValue >>= aQueryField;
BibConfig* pConfig = BibModul::GetConfig();
pConfig->setQueryField(aQueryField);
pDatMan->startQueryWith(aQuery);
}
else if(aCommand.EqualsAscii("Bib/standardFilter"))
{
try
{
uno::Reference< lang::XMultiServiceFactory > xORB = ::comphelper::getProcessServiceFactory();
// build the arguments for the filter dialog to be created
Sequence< Any > aDialogCreationArgs( 3 );
Any* pDialogCreationArgs = aDialogCreationArgs.getArray();
// the query composer
*pDialogCreationArgs++ <<= beans::PropertyValue( ::rtl::OUString::createFromAscii( "QueryComposer" ),
-1,
makeAny( pDatMan->getParser() ),
beans::PropertyState_DIRECT_VALUE
);
// the rowset
*pDialogCreationArgs++ <<= beans::PropertyValue( ::rtl::OUString::createFromAscii( "RowSet" ),
-1,
makeAny( pDatMan->getForm() ),
beans::PropertyState_DIRECT_VALUE
);
// the parent window for the dialog
*pDialogCreationArgs++ <<= beans::PropertyValue( ::rtl::OUString::createFromAscii( "ParentWindow" ),
-1,
makeAny( xWindow ),
beans::PropertyState_DIRECT_VALUE
);
// create the dialog object
const ::rtl::OUString sDialogServiceName = ::rtl::OUString::createFromAscii( "com.sun.star.sdb.FilterDialog" );
uno::Reference< uno::XInterface > xDialog = xORB->createInstanceWithArguments(
sDialogServiceName,
aDialogCreationArgs
);
if ( !xDialog.is() )
{
ShowServiceNotAvailableError( VCLUnoHelper::GetWindow( xWindow ), sDialogServiceName, sal_True );
}
else
{
// execute it
uno::Reference< ui::dialogs::XExecutableDialog > xExec( xDialog, UNO_QUERY );
DBG_ASSERT( xExec.is(), "BibFrameController_Impl::dispatch: missing an interface on the dialog!" );
if ( xExec.is() )
if ( xExec->execute( ) )
{
// the dialog has been executed successfully, and the filter on the query composer
// has been changed
::rtl::OUString sNewFilter = pDatMan->getParser()->getFilter();
pDatMan->setFilter( sNewFilter );
}
}
}
catch( const uno::Exception& )
{
DBG_ERROR( "BibFrameController_Impl::dispatch: caught an exception!" );
}
sal_uInt16 nCount = aStatusListeners.Count();
for ( sal_uInt16 n=0; n<nCount; n++ )
{
BibStatusDispatch *pObj = aStatusListeners[n];
if ( pObj->aURL.Path == C2U("Bib/removeFilter") && pDatMan->getParser().is())
{
FeatureStateEvent aEvent;
aEvent.FeatureURL = pObj->aURL;
aEvent.IsEnabled = 0 != pDatMan->getParser()->getFilter().getLength();
aEvent.Requery = sal_False;
aEvent.Source = (XDispatch *) this;
pObj->xListener->statusChanged( aEvent );
}
}
}
else if(aCommand.EqualsAscii("Bib/removeFilter"))
{
RemoveFilter();
}
else if(_rURL.Complete.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("slot:5503")) ||
aCommand.EqualsAscii("CloseDoc"))
{
Application::PostUserEvent( STATIC_LINK( this, BibFrameController_Impl,
DisposeHdl ), 0 );
}
else if(aCommand.EqualsAscii("Bib/InsertRecord"))
{
Reference<form::runtime::XFormController > xFormCtrl = pDatMan->GetFormController();
if(SaveModified(xFormCtrl))
{
try
{
Reference< sdbc::XResultSet > xCursor( pDatMan->getForm(), UNO_QUERY );
xCursor->last();
Reference< XResultSetUpdate > xUpdateCursor( pDatMan->getForm(), UNO_QUERY );
xUpdateCursor->moveToInsertRow();
}
catch(Exception&)
{
DBG_ERROR("Exception in last() or moveToInsertRow()");
}
}
}
else if(aCommand.EqualsAscii("Bib/DeleteRecord"))
{
Reference< ::com::sun::star::sdbc::XResultSet > xCursor(pDatMan->getForm(), UNO_QUERY);
Reference< XResultSetUpdate > xUpdateCursor(xCursor, UNO_QUERY);
Reference< beans::XPropertySet > xSet(pDatMan->getForm(), UNO_QUERY);
sal_Bool bIsNew = ::comphelper::getBOOL(xSet->getPropertyValue(C2U("IsNew")));
if(!bIsNew)
{
sal_uInt32 nCount = 0;
xSet->getPropertyValue(C2U("RowCount")) >>= nCount;
// naechste position festellen
sal_Bool bSuccess = sal_False;
sal_Bool bLeft = sal_False;
sal_Bool bRight = sal_False;
try
{
bLeft = xCursor->isLast() && nCount > 1;
bRight= !xCursor->isLast();
// ask for confirmation
Reference< frame::XController > xCtrl = pImp->pController;
Reference< form::XConfirmDeleteListener > xConfirm(pDatMan->GetFormController(),UNO_QUERY);
if (xConfirm.is())
{
sdb::RowChangeEvent aEvent;
aEvent.Source = Reference< XInterface > (xCursor, UNO_QUERY);
aEvent.Action = sdb::RowChangeAction::DELETE;
aEvent.Rows = 1;
bSuccess = xConfirm->confirmDelete(aEvent);
}
// das Ding loeschen
if (bSuccess)
xUpdateCursor->deleteRow();
}
catch(Exception&)
{
bSuccess = sal_False;
}
if (bSuccess)
{
if (bLeft || bRight)
xCursor->relative(bRight ? 1 : -1);
else
{
sal_Bool bCanInsert = canInsertRecords(xSet);
// kann noch ein Datensatz eingefuegt weden
try
{
if (bCanInsert)
xUpdateCursor->moveToInsertRow();
else
// Datensatz bewegen um Stati neu zu setzen
xCursor->first();
}
catch(Exception&)
{
DBG_ERROR("DeleteRecord : exception caught !");
}
}
}
}
}
else if(aCommand.EqualsAscii("Cut"))
{
Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
if(pChild)
{
KeyEvent aEvent( 0, KEYFUNC_CUT );
pChild->KeyInput( aEvent );
}
}
else if(aCommand.EqualsAscii("Copy"))
{
Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
if(pChild)
{
KeyEvent aEvent( 0, KEYFUNC_COPY );
pChild->KeyInput( aEvent );
}
}
else if(aCommand.EqualsAscii("Paste"))
{
Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
if(pChild)
{
KeyEvent aEvent( 0, KEYFUNC_PASTE );
pChild->KeyInput( aEvent );
}
}
}
}
IMPL_STATIC_LINK( BibFrameController_Impl, DisposeHdl, void*, EMPTYARG )
{
pThis->xFrame->dispose();
return 0;
};
//-----------------------------------------------------------------------------
void BibFrameController_Impl::addStatusListener(
const uno::Reference< frame::XStatusListener > & aListener,
const util::URL& aURL)
throw (::com::sun::star::uno::RuntimeException)
{
BibConfig* pConfig = BibModul::GetConfig();
// create a new Reference and insert into listener array
aStatusListeners.Insert( new BibStatusDispatch( aURL, aListener ), aStatusListeners.Count() );
// den ersten Status synchron zusenden
FeatureStateEvent aEvent;
aEvent.FeatureURL = aURL;
aEvent.Requery = sal_False;
aEvent.Source = (XDispatch *) this;
if ( aURL.Path == C2U("StatusBarVisible") )
{
aEvent.IsEnabled = sal_False;
aEvent.State <<= sal_Bool( sal_False );
}
else if ( aURL.Path == C2U("Bib/hierarchical") )
{
aEvent.IsEnabled = sal_True;
const char* pHier = bHierarchical? "" : "*" ;
aEvent.State <<= rtl::OUString::createFromAscii(pHier);
}
else if(aURL.Path == C2U("Bib/MenuFilter"))
{
aEvent.IsEnabled = sal_True;
aEvent.FeatureDescriptor=pDatMan->getQueryField();
uno::Sequence<rtl::OUString> aStringSeq=pDatMan->getQueryFields();
aEvent.State.setValue(&aStringSeq,::getCppuType((uno::Sequence<rtl::OUString>*)0));
}
else if ( aURL.Path == C2U("Bib/source"))
{
aEvent.IsEnabled = sal_True;
aEvent.FeatureDescriptor=pDatMan->getActiveDataTable();
uno::Sequence<rtl::OUString> aStringSeq=pDatMan->getDataSources();
aEvent.State.setValue(&aStringSeq,::getCppuType((uno::Sequence<rtl::OUString>*)0));
}
else if(aURL.Path == C2U("Bib/sdbsource") ||
aURL.Path == C2U("Bib/Mapping") ||
aURL.Path == C2U("Bib/autoFilter") ||
aURL.Path.equalsAscii("Bib/standardFilter"))
{
aEvent.IsEnabled = sal_True;
}
else if(aURL.Path == C2U("Bib/query"))
{
aEvent.IsEnabled = sal_True;
aEvent.State <<= pConfig->getQueryText();
}
else if (aURL.Path == C2U("Bib/removeFilter") )
{
rtl::OUString aFilterStr=pDatMan->getFilter();
aEvent.IsEnabled = (aFilterStr.getLength() > 0);
}
else if(aURL.Path == C2U("Cut"))
{
Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
Edit* pEdit = dynamic_cast<Edit*>( pChild );
if( pEdit )
aEvent.IsEnabled = !pEdit->IsReadOnly() && pEdit->GetSelection().Len();
}
if(aURL.Path == C2U("Copy"))
{
Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
Edit* pEdit = dynamic_cast<Edit*>( pChild );
if( pEdit )
aEvent.IsEnabled = pEdit->GetSelection().Len() > 0;
}
else if(aURL.Path == C2U("Paste") )
{
aEvent.IsEnabled = sal_False;
Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
if(pChild)
{
uno::Reference< datatransfer::clipboard::XClipboard > xClip = pChild->GetClipboard();
if(xClip.is())
{
uno::Reference< datatransfer::XTransferable > xDataObj;
const sal_uInt32 nRef = Application::ReleaseSolarMutex();
try
{
xDataObj = xClip->getContents();
}
catch( const uno::Exception& )
{
}
Application::AcquireSolarMutex( nRef );
if ( xDataObj.is() )
{
datatransfer::DataFlavor aFlavor;
SotExchange::GetFormatDataFlavor( SOT_FORMAT_STRING, aFlavor );
try
{
uno::Any aData = xDataObj->getTransferData( aFlavor );
::rtl::OUString aText;
aData >>= aText;
aEvent.IsEnabled = aText.getLength() > 0;
}
catch( const uno::Exception& )
{
}
}
}
uno::Reference< datatransfer::XTransferable > xContents = xClip->getContents( );
}
}
else if(aURL.Path == C2U("Bib/DeleteRecord"))
{
Reference< ::com::sun::star::sdbc::XResultSet > xCursor(pDatMan->getForm(), UNO_QUERY);
Reference< XResultSetUpdate > xUpdateCursor(xCursor, UNO_QUERY);
Reference< beans::XPropertySet > xSet(pDatMan->getForm(), UNO_QUERY);
sal_Bool bIsNew = ::comphelper::getBOOL(xSet->getPropertyValue(C2U("IsNew")));
if(!bIsNew)
{
sal_uInt32 nCount = 0;
xSet->getPropertyValue(C2U("RowCount")) >>= nCount;
aEvent.IsEnabled = nCount > 0;
}
}
else if (aURL.Path == C2U("Bib/InsertRecord"))
{
Reference< beans::XPropertySet > xSet(pDatMan->getForm(), UNO_QUERY);
aEvent.IsEnabled = canInsertRecords(xSet);
}
aListener->statusChanged( aEvent );
}
//-----------------------------------------------------------------------------
void BibFrameController_Impl::removeStatusListener(
const uno::Reference< frame::XStatusListener > & aObject, const util::URL& aURL)
throw (::com::sun::star::uno::RuntimeException)
{
// search listener array for given listener
// for checking equality always "cast" to XInterface
if ( !bDisposing )
{
sal_uInt16 nCount = aStatusListeners.Count();
for ( sal_uInt16 n=0; n<nCount; n++ )
{
BibStatusDispatch *pObj = aStatusListeners[n];
sal_Bool bFlag=pObj->xListener.is();
if (!bFlag || (pObj->xListener == aObject &&
( !aURL.Complete.getLength() || pObj->aURL.Path == aURL.Path )))
{
aStatusListeners.DeleteAndDestroy( n );
break;
}
}
}
}
//-----------------------------------------------------------------------------
void BibFrameController_Impl::RemoveFilter()
{
rtl::OUString aQuery;
pDatMan->startQueryWith(aQuery);
sal_uInt16 nCount = aStatusListeners.Count();
sal_Bool bRemoveFilter=sal_False;
sal_Bool bQueryText=sal_False;
for ( sal_uInt16 n=0; n<nCount; n++ )
{
BibStatusDispatch *pObj = aStatusListeners[n];
if ( pObj->aURL.Path == C2U("Bib/removeFilter") )
{
FeatureStateEvent aEvent;
aEvent.FeatureURL = pObj->aURL;
aEvent.IsEnabled = sal_False;
aEvent.Requery = sal_False;
aEvent.Source = (XDispatch *) this;
pObj->xListener->statusChanged( aEvent );
bRemoveFilter=sal_True;
}
else if(pObj->aURL.Path == C2U("Bib/query"))
{
FeatureStateEvent aEvent;
aEvent.FeatureURL = pObj->aURL;
aEvent.IsEnabled = sal_True;
aEvent.Requery = sal_False;
aEvent.Source = (XDispatch *) this;
aEvent.State <<= aQuery;
pObj->xListener->statusChanged( aEvent );
bQueryText=sal_True;
}
if(bRemoveFilter && bQueryText)
break;
}
}
//-----------------------------------------------------------------------------
void BibFrameController_Impl::ChangeDataSource(const uno::Sequence< beans::PropertyValue >& aArgs)
{
const beans::PropertyValue* pPropertyValue = aArgs.getConstArray();
uno::Any aValue=pPropertyValue[0].Value;
rtl::OUString aDBTableName;
aValue >>= aDBTableName;
if(aArgs.getLength() > 1)
{
uno::Any aDB = pPropertyValue[1].Value;
rtl::OUString aURL;
aDB >>= aURL;
pDatMan->setActiveDataSource(aURL);
aDBTableName = pDatMan->getActiveDataTable();
}
else
{
m_xDatMan->unload();
pDatMan->setActiveDataTable(aDBTableName);
pDatMan->updateGridModel();
m_xDatMan->load();
}
sal_uInt16 nCount = aStatusListeners.Count();
sal_Bool bMenuFilter=sal_False;
sal_Bool bQueryText=sal_False;
for ( sal_uInt16 n=0; n<nCount; n++ )
{
BibStatusDispatch *pObj = aStatusListeners[n];
if(COMPARE_EQUAL == pObj->aURL.Path.compareToAscii("Bib/MenuFilter"))
{
FeatureStateEvent aEvent;
aEvent.FeatureURL = pObj->aURL;
aEvent.IsEnabled = sal_True;
aEvent.Requery = sal_False;
aEvent.Source = (XDispatch *) this;
aEvent.FeatureDescriptor=pDatMan->getQueryField();
uno::Sequence<rtl::OUString> aStringSeq=pDatMan->getQueryFields();
aEvent.State = makeAny( aStringSeq );
pObj->xListener->statusChanged( aEvent );
bMenuFilter=sal_True;
}
else if(COMPARE_EQUAL == pObj->aURL.Path.compareToAscii("Bib/query"))
{
FeatureStateEvent aEvent;
aEvent.FeatureURL = pObj->aURL;
aEvent.IsEnabled = sal_True;
aEvent.Requery = sal_False;
aEvent.Source = (XDispatch *) this;
BibConfig* pConfig = BibModul::GetConfig();
aEvent.State <<= pConfig->getQueryText();
pObj->xListener->statusChanged( aEvent );
bQueryText=sal_True;
}
if (bMenuFilter && bQueryText)
break;
}
}
void BibFrameController_Impl::activate()
{
}
void BibFrameController_Impl::deactivate()
{
}