xref: /aoo42x/main/extensions/source/bibliography/framectr.cxx (revision 2a97ec55)

/**************************************************************
 *
 * 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 occured!");
		}

        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()
{
}