    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * This file is part of the LibreOffice project.
     *
     * This Source Code Form is subject to the terms of the Mozilla Public
     * License, v. 2.0. If a copy of the MPL was not distributed with this
     * file, You can obtain one at http://mozilla.org/MPL/2.0/.
     *
     * This file incorporates work covered by the following license notice:
     *
     *   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 .
     */

    #include <svx/fmgridif.hxx>
    #include <fmprop.hxx>
    #include <fmservs.hxx>
    #include <svx/fmtools.hxx>
    #include <fmurl.hxx>
    #include <formcontrolfactory.hxx>
    #include <gridcell.hxx>
    #include <sdbdatacolumn.hxx>
    #include <svx/fmgridcl.hxx>
    #include <svx/svxids.hrc>
    #include <tools/urlobj.hxx>

    #include <com/sun/star/awt/PosSize.hpp>
    #include <com/sun/star/beans/PropertyAttribute.hpp>
    #include <com/sun/star/form/FormComponentType.hpp>
    #include <com/sun/star/form/XFormComponent.hpp>
    #include <com/sun/star/form/XLoadable.hpp>
    #include <com/sun/star/lang/DisposedException.hpp>
    #include <com/sun/star/lang/NoSupportException.hpp>
    #include <com/sun/star/sdbc/ResultSetType.hpp>
    #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
    #include <com/sun/star/util/URLTransformer.hpp>
    #include <com/sun/star/util/XURLTransformer.hpp>
    #include <com/sun/star/view/XSelectionSupplier.hpp>
    #include <com/sun/star/sdbcx/XRowLocate.hpp>

    #include <comphelper/enumhelper.hxx>
    #include <comphelper/processfactory.hxx>
    #include <comphelper/property.hxx>
    #include <comphelper/sequence.hxx>
    #include <comphelper/servicehelper.hxx>
    #include <comphelper/types.hxx>
    #include <cppuhelper/supportsservice.hxx>
    #include <cppuhelper/typeprovider.hxx>
    #include <cppuhelper/queryinterface.hxx>
    #include <vcl/unohelp.hxx>
    #include <tools/diagnose_ex.h>
    #include <sal/macros.h>

    using namespace ::svxform;
    using namespace ::com::sun::star::container;
    using namespace ::com::sun::star::sdb;
    using namespace ::com::sun::star::sdbc;
    using namespace ::com::sun::star::uno;
    using namespace ::com::sun::star::view;
    using namespace ::com::sun::star::beans;
    using namespace ::com::sun::star::lang;
    using namespace ::com::sun::star::form;
    using namespace ::com::sun::star::util;
    using namespace ::com::sun::star;

    using ::com::sun::star::sdbcx::XColumnsSupplier;
    using ::com::sun::star::frame::XDispatchProviderInterceptor;
    using ::com::sun::star::frame::XDispatchProvider;
    using ::com::sun::star::accessibility::XAccessible;
    using ::com::sun::star::accessibility::XAccessibleContext;
    using ::com::sun::star::sdb::XRowSetSupplier;
    using ::com::sun::star::awt::XVclWindowPeer;

    css::awt::FontDescriptor ImplCreateFontDescriptor( const vcl::Font& rFont )
    {
        css::awt::FontDescriptor aFD;
        aFD.Name = rFont.GetFamilyName();
        aFD.StyleName = rFont.GetStyleName();
        aFD.Height = static_cast<sal_Int16>(rFont.GetFontSize().Height());
        aFD.Width = static_cast<sal_Int16>(rFont.GetFontSize().Width());
        aFD.Family = static_cast<sal_Int16>(rFont.GetFamilyType());
        aFD.CharSet = rFont.GetCharSet();
        aFD.Pitch = static_cast<sal_Int16>(rFont.GetPitch());
        aFD.CharacterWidth = vcl::unohelper::ConvertFontWidth( rFont.GetWidthType() );
        aFD.Weight= vcl::unohelper::ConvertFontWeight( rFont.GetWeight() );
        aFD.Slant = vcl::unohelper::ConvertFontSlant( rFont.GetItalic() );
        aFD.Underline = static_cast<sal_Int16>(rFont.GetUnderline());
        aFD.Strikeout = static_cast<sal_Int16>(rFont.GetStrikeout());
        aFD.Orientation = rFont.GetOrientation();
        aFD.Kerning = rFont.IsKerning();
        aFD.WordLineMode = rFont.IsWordLineMode();
        aFD.Type = 0;   // ??? => only to metric...
        return aFD;
    }

    vcl::Font ImplCreateFont( const css::awt::FontDescriptor& rDescr )
    {
        vcl::Font aFont;
        aFont.SetFamilyName( rDescr.Name );
        aFont.SetStyleName( rDescr.StyleName );
        aFont.SetFontSize( ::Size( rDescr.Width, rDescr.Height ) );
        aFont.SetFamily( static_cast<FontFamily>(rDescr.Family) );
        aFont.SetCharSet( static_cast<rtl_TextEncoding>(rDescr.CharSet) );
        aFont.SetPitch( static_cast<FontPitch>(rDescr.Pitch) );
        aFont.SetWidthType( vcl::unohelper::ConvertFontWidth( rDescr.CharacterWidth ) );
        aFont.SetWeight( vcl::unohelper::ConvertFontWeight( rDescr.Weight ) );
        aFont.SetItalic( static_cast<FontItalic>(rDescr.Slant) );
        aFont.SetUnderline( static_cast<::FontLineStyle>(rDescr.Underline) );
        aFont.SetStrikeout( static_cast<::FontStrikeout>(rDescr.Strikeout) );
        aFont.SetOrientation( static_cast<sal_Int16>(rDescr.Orientation) );
        aFont.SetKerning( static_cast<FontKerning>(rDescr.Kerning) );
        aFont.SetWordLineMode( rDescr.WordLineMode );
        return aFont;
    }

    FmXModifyMultiplexer::FmXModifyMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
                        :OWeakSubObject( rSource )
                        ,OInterfaceContainerHelper2( _rMutex )
    {
    }

    Any SAL_CALL FmXModifyMultiplexer::queryInterface(const Type& _rType)
    {
        Any aReturn;
        aReturn = ::cppu::queryInterface(_rType,
            static_cast< css::util::XModifyListener*>(this),
            static_cast< XEventListener*>(this)
        );

        if (!aReturn.hasValue())
            aReturn = OWeakSubObject::queryInterface( _rType );

        return aReturn;
    }

    void FmXModifyMultiplexer::disposing(const EventObject& )
    {
    }

    void FmXModifyMultiplexer::modified(const EventObject& e)
    {
        EventObject aMulti( e);
        aMulti.Source = &m_rParent;
        notifyEach( &XModifyListener::modified, aMulti );
    }

    FmXUpdateMultiplexer::FmXUpdateMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
                        :OWeakSubObject( rSource )
                        ,OInterfaceContainerHelper2( _rMutex )
    {
    }

    Any SAL_CALL FmXUpdateMultiplexer::queryInterface(const Type& _rType)
    {
        Any aReturn;
        aReturn = ::cppu::queryInterface(_rType,
            static_cast< XUpdateListener*>(this),
            static_cast< XEventListener*>(this)
        );

        if (!aReturn.hasValue())
            aReturn = OWeakSubObject::queryInterface( _rType );

        return aReturn;
    }

    void FmXUpdateMultiplexer::disposing(const EventObject& )
    {
    }

    sal_Bool FmXUpdateMultiplexer::approveUpdate(const EventObject &e)
    {
        EventObject aMulti( e );
        aMulti.Source = &m_rParent;

        bool bResult = true;
        if (getLength())
        {
            ::comphelper::OInterfaceIteratorHelper2 aIter(*this);
            while ( bResult && aIter.hasMoreElements() )
                bResult = static_cast< XUpdateListener* >( aIter.next() )->approveUpdate( aMulti );
        }

        return bResult;
    }

    void FmXUpdateMultiplexer::updated(const EventObject &e)
    {
        EventObject aMulti( e );
        aMulti.Source = &m_rParent;
        notifyEach( &XUpdateListener::updated, aMulti );
    }

    FmXSelectionMultiplexer::FmXSelectionMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
        :OWeakSubObject( rSource )
        ,OInterfaceContainerHelper2( _rMutex )
    {
    }

    Any SAL_CALL FmXSelectionMultiplexer::queryInterface(const Type& _rType)
    {
        Any aReturn;
        aReturn = ::cppu::queryInterface(_rType,
            static_cast< XSelectionChangeListener*>(this),
            static_cast< XEventListener*>(this)
        );

        if (!aReturn.hasValue())
            aReturn = OWeakSubObject::queryInterface( _rType );

        return aReturn;
    }

    void FmXSelectionMultiplexer::disposing(const EventObject& )
    {
    }

    void SAL_CALL FmXSelectionMultiplexer::selectionChanged( const EventObject& _rEvent )
    {
        EventObject aMulti(_rEvent);
        aMulti.Source = &m_rParent;
        notifyEach( &XSelectionChangeListener::selectionChanged, aMulti );
    }

    FmXContainerMultiplexer::FmXContainerMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
                            :OWeakSubObject( rSource )
                            ,OInterfaceContainerHelper2( _rMutex )
    {
    }

    Any SAL_CALL FmXContainerMultiplexer::queryInterface(const Type& _rType)
    {
        Any aReturn;
        aReturn = ::cppu::queryInterface(_rType,
            static_cast< XContainerListener*>(this),
            static_cast< XEventListener*>(this)
        );

        if (!aReturn.hasValue())
            aReturn = OWeakSubObject::queryInterface( _rType );

        return aReturn;
    }

    void FmXContainerMultiplexer::disposing(const EventObject& )
    {
    }

    void FmXContainerMultiplexer::elementInserted(const ContainerEvent& e)
    {
        ContainerEvent aMulti( e );
        aMulti.Source = &m_rParent;
        notifyEach( &XContainerListener::elementInserted, aMulti );
    }

    void FmXContainerMultiplexer::elementRemoved(const ContainerEvent& e)
    {
        ContainerEvent aMulti( e );
        aMulti.Source = &m_rParent;
        notifyEach( &XContainerListener::elementRemoved, aMulti );
    }

    void FmXContainerMultiplexer::elementReplaced(const ContainerEvent& e)
    {
        ContainerEvent aMulti( e );
        aMulti.Source = &m_rParent;
        notifyEach( &XContainerListener::elementReplaced, aMulti );
    }

    FmXGridControlMultiplexer::FmXGridControlMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
        :OWeakSubObject( rSource )
        ,OInterfaceContainerHelper2( _rMutex )
    {
    }

    Any SAL_CALL FmXGridControlMultiplexer::queryInterface(const Type& _rType)
    {
        Any aReturn;
        aReturn = ::cppu::queryInterface( _rType,
            static_cast< XGridControlListener*>(this)
        );

        if (!aReturn.hasValue())
            aReturn = OWeakSubObject::queryInterface( _rType );

        return aReturn;
    }

    void FmXGridControlMultiplexer::disposing( const EventObject& )
    {
    }

    void SAL_CALL FmXGridControlMultiplexer::columnChanged( const EventObject& _event )
    {
        EventObject aForwardedEvent( _event );
        aForwardedEvent.Source = &m_rParent;
        notifyEach( &XGridControlListener::columnChanged, aForwardedEvent );
    }

    //= FmXGridControl

    Reference< XInterface > FmXGridControl_NewInstance_Impl(const Reference< XMultiServiceFactory>& _rxFactory)
    {
        return *(new FmXGridControl( comphelper::getComponentContext(_rxFactory) ));
    }

    FmXGridControl::FmXGridControl(const Reference< XComponentContext >& _rxContext)
                   :UnoControl()
                   ,m_aModifyListeners(*this, GetMutex())
                   ,m_aUpdateListeners(*this, GetMutex())
                   ,m_aContainerListeners(*this, GetMutex())
                   ,m_aSelectionListeners(*this, GetMutex())
                   ,m_aGridControlListeners(*this, GetMutex())
                   ,m_bInDraw(false)
                   ,m_xContext(_rxContext)
    {
    }

    FmXGridControl::~FmXGridControl()
    {
    }

    Any SAL_CALL FmXGridControl::queryAggregation(const Type& _rType)
    {
        Any aReturn = FmXGridControl_BASE::queryInterface(_rType);

        if (!aReturn.hasValue())
            aReturn = UnoControl::queryAggregation( _rType );
        return aReturn;
    }

    Sequence< Type> SAL_CALL FmXGridControl::getTypes(  )
    {
        return comphelper::concatSequences(UnoControl::getTypes(),FmXGridControl_BASE::getTypes());
    }

    Sequence<sal_Int8> SAL_CALL FmXGridControl::getImplementationId(  )
    {
        return css::uno::Sequence<sal_Int8>();
    }

    // XServiceInfo
    sal_Bool SAL_CALL FmXGridControl::supportsService(const OUString& ServiceName)
    {
        return cppu::supportsService(this, ServiceName);
    }

    OUString SAL_CALL FmXGridControl::getImplementationName()
    {
        return OUString("com.sun.star.form.FmXGridControl");
    }

    css::uno::Sequence<OUString> SAL_CALL FmXGridControl::getSupportedServiceNames()
    {
        Sequence< OUString > aServiceNames(2);
        aServiceNames[0] = FM_SUN_CONTROL_GRIDCONTROL;
        aServiceNames[1] = "com.sun.star.awt.UnoControl";
        return aServiceNames;
    }

    void SAL_CALL FmXGridControl::dispose()
    {
        SolarMutexGuard aGuard;

        EventObject aEvt;
        aEvt.Source = static_cast< ::cppu::OWeakObject* >(this);
        m_aModifyListeners.disposeAndClear(aEvt);
        m_aUpdateListeners.disposeAndClear(aEvt);
        m_aContainerListeners.disposeAndClear(aEvt);

        UnoControl::dispose();
    }

    OUString FmXGridControl::GetComponentServiceName()
    {
        return OUString("DBGrid");
    }

    sal_Bool SAL_CALL FmXGridControl::setModel(const Reference< css::awt::XControlModel >& rModel)
    {
        SolarMutexGuard aGuard;

        if (!UnoControl::setModel(rModel))
            return false;

        Reference< XGridPeer > xGridPeer(getPeer(), UNO_QUERY);
        if (xGridPeer.is())
        {
            Reference< XIndexContainer > xCols(mxModel, UNO_QUERY);
            xGridPeer->setColumns(xCols);
        }
        return true;
    }

    FmXGridPeer* FmXGridControl::imp_CreatePeer(vcl::Window* pParent)
    {
        FmXGridPeer* pReturn = new FmXGridPeer(m_xContext);

        // translate properties into WinBits
        WinBits nStyle = WB_TABSTOP;
        Reference< XPropertySet >  xModelSet(getModel(), UNO_QUERY);
        if (xModelSet.is())
        {
            try
            {
                if (::comphelper::getINT16(xModelSet->getPropertyValue(FM_PROP_BORDER)))
                    nStyle |= WB_BORDER;
            }
            catch(const Exception&)
            {
                OSL_FAIL("Can not get style");
            }
        }

        pReturn->Create(pParent, nStyle);
        return pReturn;
    }

    void SAL_CALL FmXGridControl::createPeer(const Reference< css::awt::XToolkit >& /*rToolkit*/, const Reference< css::awt::XWindowPeer >& rParentPeer)
    {
        if ( !mxModel.is() )
            throw DisposedException( OUString(), *this );

        DBG_ASSERT(/*(0 == m_nPeerCreationLevel) && */!mbCreatingPeer, "FmXGridControl::createPeer : recursion!");
            // I think this should never assert, now that we're using the base class' mbCreatingPeer in addition to
            // our own m_nPeerCreationLevel
            // But I'm not sure as I don't _fully_ understand the underlying toolkit implementations ....
            // (if this asserts, we still need m_nPeerCreationLevel. If not, we could omit it ....)
            // 14.05.2001 - 86836 - frank.schoenheit@germany.sun.com

        // TODO: why the hell this whole class does not use any mutex?

        if (!getPeer().is())
        {
            mbCreatingPeer = true;
            // mbCreatingPeer is virtually the same as m_nPeerCreationLevel, but it's the base class' method
            // to prevent recursion.

            vcl::Window* pParentWin = nullptr;
            if (rParentPeer.is())
            {
                VCLXWindow* pParent = VCLXWindow::GetImplementation(rParentPeer);
                if (pParent)
                    pParentWin = pParent->GetWindow().get();
            }

            FmXGridPeer* pPeer = imp_CreatePeer(pParentWin);
            DBG_ASSERT(pPeer != nullptr, "FmXGridControl::createPeer : imp_CreatePeer didn't return a peer !");
            setPeer( pPeer );

            // reading the properties from the model
    //      ++m_nPeerCreationLevel;
            updateFromModel();

            // consider the following ugly scenario: updateFromModel leads to a propertiesChanges on the Control,
            // which determines, dat a "critical" property has changed (e.g. "Border") and therefore starts a new
            // Peer, which lands again here in createPeer we also start a second FmXGridPeer and initialise it.
            // Then we exit from the first incarnation's updateFromModel and continue working with the pPeer,
            // that is in fact now already obsolete (as another peer is being started in the second incarnation).
            // Therefore the effort with the PeerCreationLevel, which ensures that we really use the Peer
            // created at the deepest level, but first initialise it in the top-level.
    //      if (--m_nPeerCreationLevel == 0)
            {
                DBG_ASSERT(getPeer().is(), "FmXGridControl::createPeer : something went wrong ... no top level peer !");
                pPeer = FmXGridPeer::getImplementation(getPeer());

                setPosSize( maComponentInfos.nX, maComponentInfos.nY, maComponentInfos.nWidth, maComponentInfos.nHeight, css::awt::PosSize::POSSIZE );

                Reference< XIndexContainer >  xColumns(getModel(), UNO_QUERY);
                if (xColumns.is())
                    pPeer->setColumns(xColumns);

                if (maComponentInfos.bVisible)
                    pPeer->setVisible(true);

                if (!maComponentInfos.bEnable)
                    pPeer->setEnable(false);

                if (maWindowListeners.getLength())
                    pPeer->addWindowListener( &maWindowListeners );

                if (maFocusListeners.getLength())
                    pPeer->addFocusListener( &maFocusListeners );

                if (maKeyListeners.getLength())
                    pPeer->addKeyListener( &maKeyListeners );

                if (maMouseListeners.getLength())
                    pPeer->addMouseListener( &maMouseListeners );

                if (maMouseMotionListeners.getLength())
                    pPeer->addMouseMotionListener( &maMouseMotionListeners );

                if (maPaintListeners.getLength())
                    pPeer->addPaintListener( &maPaintListeners );

                if (m_aModifyListeners.getLength())
                    pPeer->addModifyListener( &m_aModifyListeners );

                if (m_aUpdateListeners.getLength())
                    pPeer->addUpdateListener( &m_aUpdateListeners );

                if (m_aContainerListeners.getLength())
                    pPeer->addContainerListener( &m_aContainerListeners );

                // forward the design mode
                bool bForceAlivePeer = m_bInDraw && !maComponentInfos.bVisible;
                // (we force an alive-mode peer if we're in "draw", cause in this case the peer will be used for drawing in
                // foreign devices. We ensure this with the visibility check as an living peer is assumed to be noncritical
                // only if invisible)
                Any aOldCursorBookmark;
                if (!mbDesignMode || bForceAlivePeer)
                {
                    Reference< XFormComponent >  xComp(getModel(), UNO_QUERY);
                    if (xComp.is())
                    {
                        Reference< XRowSet >  xForm(xComp->getParent(), UNO_QUERY);
                        // is the form alive?
                        // we can see that if the form contains columns
                        Reference< css::sdbcx::XColumnsSupplier >  xColumnsSupplier(xForm, UNO_QUERY);
                        if (xColumnsSupplier.is())
                        {
                            if (Reference< XIndexAccess > (xColumnsSupplier->getColumns(),UNO_QUERY)->getCount())
                            {
                                // we get only a new bookmark if the resultset is not forwardonly
                                if (::comphelper::getINT32(Reference< XPropertySet > (xForm, UNO_QUERY)->getPropertyValue(FM_PROP_RESULTSET_TYPE)) != ResultSetType::FORWARD_ONLY)
                                {
                                    // as the FmGridControl touches the data source it is connected to we have to remember the current
                                    // cursor position (and restore afterwards)
                                    // OJ: but only when we stand on a valid row
                                    Reference< XResultSet > xResultSet(xForm, UNO_QUERY);
                                    if ( !xResultSet->isBeforeFirst() && !xResultSet->isAfterLast() )
                                    {
                                        try
                                        {
                                            aOldCursorBookmark = Reference< css::sdbcx::XRowLocate > (xForm, UNO_QUERY)->getBookmark();
                                        }
                                        catch( const Exception& )
                                        {
                                            DBG_UNHANDLED_EXCEPTION("svx");
                                        }
                                    }
                                }
                            }
                        }
                        pPeer->setRowSet(xForm);
                    }
                }
                pPeer->setDesignMode(mbDesignMode && !bForceAlivePeer);

                try
                {
                    if (aOldCursorBookmark.hasValue())
                    {   // we have a valid bookmark, so we have to restore the cursor's position
                        Reference< XFormComponent >  xComp(getModel(), UNO_QUERY);
                        Reference< css::sdbcx::XRowLocate >  xLocate(xComp->getParent(), UNO_QUERY);
                        xLocate->moveToBookmark(aOldCursorBookmark);
                    }
                }
                catch( const Exception& )
                {
                    DBG_UNHANDLED_EXCEPTION("svx");
                }

                Reference< css::awt::XView >  xPeerView(getPeer(), UNO_QUERY);
                xPeerView->setZoom( maComponentInfos.nZoomX, maComponentInfos.nZoomY );
                xPeerView->setGraphics( mxGraphics );
            }
            mbCreatingPeer = false;
        }
    }

    void FmXGridControl::addModifyListener(const Reference< css::util::XModifyListener >& l)
    {
        m_aModifyListeners.addInterface( l );
        if( getPeer().is() && m_aModifyListeners.getLength() == 1 )
        {
            Reference< css::util::XModifyBroadcaster >  xGrid(getPeer(), UNO_QUERY);
            xGrid->addModifyListener( &m_aModifyListeners);
        }
    }

    sal_Bool SAL_CALL FmXGridControl::select( const Any& _rSelection )
    {
        SolarMutexGuard aGuard;
        Reference< XSelectionSupplier > xPeer(getPeer(), UNO_QUERY);
        return xPeer->select(_rSelection);
    }

    Any SAL_CALL FmXGridControl::getSelection(  )
    {
        SolarMutexGuard aGuard;
        Reference< XSelectionSupplier > xPeer(getPeer(), UNO_QUERY);
        return xPeer->getSelection();
    }

    void SAL_CALL FmXGridControl::addSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener )
    {
        m_aSelectionListeners.addInterface( _rxListener );
        if( getPeer().is() && 1 == m_aSelectionListeners.getLength() )
        {
            Reference< XSelectionSupplier > xGrid(getPeer(), UNO_QUERY);
            xGrid->addSelectionChangeListener( &m_aSelectionListeners);
        }
    }

    void SAL_CALL FmXGridControl::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener )
    {
        if( getPeer().is() && 1 == m_aSelectionListeners.getLength() )
        {
            Reference< XSelectionSupplier > xGrid(getPeer(), UNO_QUERY);
            xGrid->removeSelectionChangeListener( &m_aSelectionListeners);
        }
        m_aSelectionListeners.removeInterface( _rxListener );
    }

    Sequence< sal_Bool > SAL_CALL FmXGridControl::queryFieldDataType( const Type& xType )
    {
        if (getPeer().is())
        {
            Reference< XGridFieldDataSupplier >  xPeerSupplier(getPeer(), UNO_QUERY);
            if (xPeerSupplier.is())
                return xPeerSupplier->queryFieldDataType(xType);
        }

        return Sequence<sal_Bool>();
    }

    Sequence< Any > SAL_CALL FmXGridControl::queryFieldData( sal_Int32 nRow, const Type& xType )
    {
        if (getPeer().is())
        {
            Reference< XGridFieldDataSupplier >  xPeerSupplier(getPeer(), UNO_QUERY);
            if (xPeerSupplier.is())
                return xPeerSupplier->queryFieldData(nRow, xType);
        }

        return Sequence< Any>();
    }

    void SAL_CALL FmXGridControl::removeModifyListener(const Reference< css::util::XModifyListener >& l)
    {
        if( getPeer().is() && m_aModifyListeners.getLength() == 1 )
        {
            Reference< css::util::XModifyBroadcaster >  xGrid(getPeer(), UNO_QUERY);
            xGrid->removeModifyListener( &m_aModifyListeners);
        }
        m_aModifyListeners.removeInterface( l );
    }

    void SAL_CALL FmXGridControl::draw( sal_Int32 x, sal_Int32 y )
    {
        SolarMutexGuard aGuard;
        m_bInDraw = true;
        UnoControl::draw(x, y);
        m_bInDraw = false;
    }

    void SAL_CALL FmXGridControl::setDesignMode(sal_Bool bOn)
    {
        css::util::ModeChangeEvent aModeChangeEvent;

        // --- <mutex_lock> ---
        {
            SolarMutexGuard aGuard;

            Reference< XRowSetSupplier >  xGrid(getPeer(), UNO_QUERY);

            if (xGrid.is() && (bool(bOn) != mbDesignMode || (!bOn && !xGrid->getRowSet().is())))
            {
                if (bOn)
                {
                    xGrid->setRowSet(Reference< XRowSet > ());
                }
                else
                {
                    Reference< XFormComponent >  xComp(getModel(), UNO_QUERY);
                    if (xComp.is())
                    {
                        Reference< XRowSet >  xForm(xComp->getParent(), UNO_QUERY);
                        xGrid->setRowSet(xForm);
                    }
                }

                mbDesignMode = bOn;

                Reference< XVclWindowPeer >  xVclWindowPeer( getPeer(), UNO_QUERY );
                if (xVclWindowPeer.is())
                    xVclWindowPeer->setDesignMode(bOn);
            }
            mbDesignMode = bOn;

            // dispose our current AccessibleContext, if we have one
            // (changing the design mode implies having a new implementation for this context,
            // so the old one must be declared DEFUNC)
            DisposeAccessibleContext(
                    Reference<XComponent>(maAccessibleContext, UNO_QUERY));
            maAccessibleContext.clear();

            // prepare firing an event
            aModeChangeEvent.Source = *this;
            aModeChangeEvent.NewMode = mbDesignMode ? OUString( "design" ) : OUString( "alive" );
        }

        // --- </mutex_lock> ---
        maModeChangeListeners.notifyEach( &XModeChangeListener::modeChanged, aModeChangeEvent );
    }

    // XBoundComponent

    void SAL_CALL FmXGridControl::addUpdateListener(const Reference< XUpdateListener >& l)
    {
        m_aUpdateListeners.addInterface( l );
        if( getPeer().is() && m_aUpdateListeners.getLength() == 1 )
        {
            Reference< XBoundComponent >  xBound(getPeer(), UNO_QUERY);
            xBound->addUpdateListener( &m_aUpdateListeners);
        }
    }

    void SAL_CALL FmXGridControl::removeUpdateListener(const Reference< XUpdateListener >& l)
    {
        if( getPeer().is() && m_aUpdateListeners.getLength() == 1 )
        {
            Reference< XBoundComponent >  xBound(getPeer(), UNO_QUERY);
            xBound->removeUpdateListener( &m_aUpdateListeners);
        }
        m_aUpdateListeners.removeInterface( l );
    }

    sal_Bool SAL_CALL FmXGridControl::commit()
    {
        Reference< XBoundComponent >  xBound(getPeer(), UNO_QUERY);
        if (xBound.is())
            return xBound->commit();
        else
            return true;
    }

    // XContainer

    void SAL_CALL FmXGridControl::addContainerListener(const Reference< XContainerListener >& l)
    {
        m_aContainerListeners.addInterface( l );
        if( getPeer().is() && m_aContainerListeners.getLength() == 1 )
        {
            Reference< XContainer >  xContainer(getPeer(), UNO_QUERY);
            xContainer->addContainerListener( &m_aContainerListeners);
        }
    }

    void SAL_CALL FmXGridControl::removeContainerListener(const Reference< XContainerListener >& l)
    {
        if( getPeer().is() && m_aContainerListeners.getLength() == 1 )
        {
            Reference< XContainer >  xContainer(getPeer(), UNO_QUERY);
            xContainer->removeContainerListener( &m_aContainerListeners);
        }
        m_aContainerListeners.removeInterface( l );
    }

    Reference< css::frame::XDispatch >  SAL_CALL FmXGridControl::queryDispatch(const css::util::URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags)
    {
        Reference< css::frame::XDispatchProvider >  xPeerProvider(getPeer(), UNO_QUERY);
        if (xPeerProvider.is())
            return xPeerProvider->queryDispatch(aURL, aTargetFrameName, nSearchFlags);
        else
            return Reference< css::frame::XDispatch > ();
    }

    Sequence< Reference< css::frame::XDispatch > > SAL_CALL FmXGridControl::queryDispatches(const Sequence< css::frame::DispatchDescriptor>& aDescripts)
    {
        Reference< css::frame::XDispatchProvider >  xPeerProvider(getPeer(), UNO_QUERY);
        if (xPeerProvider.is())
            return xPeerProvider->queryDispatches(aDescripts);
        else
            return Sequence< Reference< css::frame::XDispatch > >();
    }

    void SAL_CALL FmXGridControl::registerDispatchProviderInterceptor(const Reference< css::frame::XDispatchProviderInterceptor >& _xInterceptor)
    {
        Reference< css::frame::XDispatchProviderInterception >  xPeerInterception(getPeer(), UNO_QUERY);
        if (xPeerInterception.is())
            xPeerInterception->registerDispatchProviderInterceptor(_xInterceptor);
    }

    void SAL_CALL FmXGridControl::releaseDispatchProviderInterceptor(const Reference< css::frame::XDispatchProviderInterceptor >& _xInterceptor)
    {
        Reference< css::frame::XDispatchProviderInterception >  xPeerInterception(getPeer(), UNO_QUERY);
        if (xPeerInterception.is())
            xPeerInterception->releaseDispatchProviderInterceptor(_xInterceptor);
    }

    void SAL_CALL FmXGridControl::addGridControlListener( const Reference< XGridControlListener >& _listener )
    {
        ::osl::MutexGuard aGuard( GetMutex() );

        m_aGridControlListeners.addInterface( _listener );
        if ( getPeer().is() && 1 == m_aGridControlListeners.getLength() )
        {
            Reference< XGridControl > xPeerGrid( getPeer(), UNO_QUERY );
            if ( xPeerGrid.is() )
                xPeerGrid->addGridControlListener( &m_aGridControlListeners );
        }
    }

    void SAL_CALL FmXGridControl::removeGridControlListener( const Reference< XGridControlListener >& _listener )
    {
        ::osl::MutexGuard aGuard( GetMutex() );

        if( getPeer().is() && 1 == m_aGridControlListeners.getLength() )
        {
            Reference< XGridControl > xPeerGrid( getPeer(), UNO_QUERY );
            if ( xPeerGrid.is() )
                xPeerGrid->removeGridControlListener( &m_aGridControlListeners );
        }

        m_aGridControlListeners.removeInterface( _listener );
    }

    sal_Int16 SAL_CALL FmXGridControl::getCurrentColumnPosition()
    {
        Reference< XGridControl > xGrid( getPeer(), UNO_QUERY );
        return xGrid.is() ? xGrid->getCurrentColumnPosition() : -1;
    }

    void SAL_CALL FmXGridControl::setCurrentColumnPosition(sal_Int16 nPos)
    {
        Reference< XGridControl > xGrid( getPeer(), UNO_QUERY );
        if ( xGrid.is() )
        {
            SolarMutexGuard aGuard;
            xGrid->setCurrentColumnPosition( nPos );
        }
    }

    // XElementAccess

    sal_Bool SAL_CALL FmXGridControl::hasElements()
    {
        Reference< XElementAccess >  xPeer(getPeer(), UNO_QUERY);
        return xPeer.is() && xPeer->hasElements();
    }

    Type SAL_CALL FmXGridControl::getElementType(  )
    {
        return cppu::UnoType<css::awt::XTextComponent>::get();
    }

    // XEnumerationAccess

    Reference< XEnumeration >  SAL_CALL FmXGridControl::createEnumeration()
    {
        Reference< XEnumerationAccess >  xPeer(getPeer(), UNO_QUERY);
        if (xPeer.is())
            return xPeer->createEnumeration();
        else
            return new ::comphelper::OEnumerationByIndex(this);
    }

    // XIndexAccess

    sal_Int32 SAL_CALL FmXGridControl::getCount()
    {
        Reference< XIndexAccess >  xPeer(getPeer(), UNO_QUERY);
        return xPeer.is() ? xPeer->getCount() : 0;
    }

    Any SAL_CALL FmXGridControl::getByIndex(sal_Int32 _nIndex)
    {
        Reference< XIndexAccess >  xPeer(getPeer(), UNO_QUERY);
        if (!xPeer.is())
            throw IndexOutOfBoundsException();

        return xPeer->getByIndex(_nIndex);
    }

    // css::util::XModeSelector

    void SAL_CALL FmXGridControl::setMode(const OUString& Mode)
    {
        Reference< css::util::XModeSelector >  xPeer(getPeer(), UNO_QUERY);
        if (!xPeer.is())
            throw NoSupportException();

        xPeer->setMode(Mode);
    }

    OUString SAL_CALL FmXGridControl::getMode()
    {
        Reference< css::util::XModeSelector >  xPeer(getPeer(), UNO_QUERY);
        return xPeer.is() ? xPeer->getMode() : OUString();
    }

    css::uno::Sequence<OUString> SAL_CALL FmXGridControl::getSupportedModes()
    {
        Reference< css::util::XModeSelector >  xPeer(getPeer(), UNO_QUERY);
        return xPeer.is() ? xPeer->getSupportedModes() : css::uno::Sequence<OUString>();
    }

    sal_Bool SAL_CALL FmXGridControl::supportsMode(const OUString& Mode)
    {
        Reference< css::util::XModeSelector >  xPeer(getPeer(), UNO_QUERY);
        return xPeer.is() && xPeer->supportsMode(Mode);
    }

    // helper class which prevents that in the peer's header the FmGridListener must be known
    class FmXGridPeer::GridListenerDelegator : public FmGridListener
    {
    protected:
        FmXGridPeer*        m_pPeer;

    public:
        explicit GridListenerDelegator( FmXGridPeer* _pPeer );
        virtual ~GridListenerDelegator();

    protected:
        virtual void selectionChanged() override;
        virtual void columnChanged() override;
    };

    FmXGridPeer::GridListenerDelegator::GridListenerDelegator(FmXGridPeer* _pPeer)
        :m_pPeer(_pPeer)
    {
        DBG_ASSERT(m_pPeer, "GridListenerDelegator::GridListenerDelegator");
    }

    FmXGridPeer::GridListenerDelegator::~GridListenerDelegator()
    {
    }

    void FmXGridPeer::GridListenerDelegator::selectionChanged()
    {
        m_pPeer->selectionChanged();
    }

    void FmXGridPeer::GridListenerDelegator::columnChanged()
    {
        m_pPeer->columnChanged();
    }

    void FmXGridPeer::selectionChanged()
    {
        EventObject aSource;
        aSource.Source = static_cast< ::cppu::OWeakObject* >(this);
        m_aSelectionListeners.notifyEach( &XSelectionChangeListener::selectionChanged, aSource);
    }

    void FmXGridPeer::columnChanged()
    {
        EventObject aEvent( *this );
        m_aGridControlListeners.notifyEach( &XGridControlListener::columnChanged, aEvent );
    }

    namespace fmgridif
    {
        const OUString getDataModeIdentifier()
        {
            return OUString("DataMode");
        }
    }
    using namespace fmgridif;

    FmXGridPeer::FmXGridPeer(const Reference< XComponentContext >& _rxContext)
                :m_aModifyListeners(m_aMutex)
                ,m_aUpdateListeners(m_aMutex)
                ,m_aContainerListeners(m_aMutex)
                ,m_aSelectionListeners(m_aMutex)
                ,m_aGridControlListeners(m_aMutex)
                ,m_aMode( getDataModeIdentifier() )
                ,m_nCursorListening(0)
                ,m_bInterceptingDispatch(false)
                ,m_xContext(_rxContext)
    {
        // Create must be called after this constructor
        m_pGridListener.reset( new GridListenerDelegator( this ) );
    }

    VclPtr<FmGridControl> FmXGridPeer::imp_CreateControl(vcl::Window* pParent, WinBits nStyle)
    {
        return VclPtr<FmGridControl>::Create(m_xContext, pParent, this, nStyle);
    }

    void FmXGridPeer::Create(vcl::Window* pParent, WinBits nStyle)
    {
        VclPtr<FmGridControl> pWin = imp_CreateControl(pParent, nStyle);
        DBG_ASSERT(pWin != nullptr, "FmXGridPeer::Create : imp_CreateControl didn't return a control !");

        pWin->SetStateProvider(LINK(this, FmXGridPeer, OnQueryGridSlotState));
        pWin->SetSlotExecutor(LINK(this, FmXGridPeer, OnExecuteGridSlot));

        // want to hear about row selections
        pWin->setGridListener( m_pGridListener.get() );

        // Init must always be called
        pWin->Init();
        pWin->SetComponentInterface(this);

        getSupportedURLs();
    }

    FmXGridPeer::~FmXGridPeer()
    {
        setRowSet(Reference< XRowSet > ());
        setColumns(Reference< XIndexContainer > ());
    }

    namespace
    {
        class theFmXGridPeerImplementationId : public rtl::Static< UnoTunnelIdInit, theFmXGridPeerImplementationId > {};
    }

    const Sequence< sal_Int8 >& FmXGridPeer::getUnoTunnelImplementationId() throw()
    {
        return theFmXGridPeerImplementationId::get().getSeq();
    }

    FmXGridPeer* FmXGridPeer::getImplementation( const Reference< XInterface >& _rxIFace ) throw()
    {
        FmXGridPeer* pReturn = nullptr;
        Reference< XUnoTunnel >  xTunnel(_rxIFace, UNO_QUERY);
        if (xTunnel.is())
            pReturn = reinterpret_cast<FmXGridPeer*>(xTunnel->getSomething(getUnoTunnelImplementationId()));

        return pReturn;
    }

    sal_Int64 SAL_CALL FmXGridPeer::getSomething( const Sequence< sal_Int8 >& _rIdentifier )
    {
        sal_Int64 nReturn(0);

        if  (   (_rIdentifier.getLength() == 16)
            &&  (0 == memcmp( getUnoTunnelImplementationId().getConstArray(), _rIdentifier.getConstArray(), 16 ))
            )
        {
            nReturn = reinterpret_cast<sal_Int64>(this);
        }
        else
            nReturn = VCLXWindow::getSomething(_rIdentifier);

        return nReturn;
    }

    // XEventListener

    void FmXGridPeer::disposing(const EventObject& e)
    {
        bool bKnownSender = false;

        Reference< XIndexContainer >  xCols( e.Source, UNO_QUERY );
        if ( xCols.is() )
        {
            setColumns(Reference< XIndexContainer > ());
            bKnownSender = true;
        }

        Reference< XRowSet >  xCursor(e.Source, UNO_QUERY);
        if (xCursor.is())
        {
            setRowSet( m_xCursor );
            m_xCursor = nullptr;
            bKnownSender = true;
        }

        if ( !bKnownSender && m_pDispatchers )
        {
            const Sequence< URL>& aSupportedURLs = getSupportedURLs();
            const URL* pSupportedURLs = aSupportedURLs.getConstArray();
            for ( sal_Int32 i=0; i < ( aSupportedURLs.getLength() ) && !bKnownSender; ++i, ++pSupportedURLs )
            {
                if ( m_pDispatchers[i] == e.Source )
                {
                    m_pDispatchers[i]->removeStatusListener( static_cast< css::frame::XStatusListener* >( this ), *pSupportedURLs );
                    m_pDispatchers[i] = nullptr;
                    m_pStateCache[i] = false;
                    bKnownSender = true;
                }
            }
        }

        if ( !bKnownSender )
            VCLXWindow::disposing(e);
    }

    void FmXGridPeer::addModifyListener(const Reference< css::util::XModifyListener >& l)
    {
        m_aModifyListeners.addInterface( l );
    }

    void FmXGridPeer::removeModifyListener(const Reference< css::util::XModifyListener >& l)
    {
        m_aModifyListeners.removeInterface( l );
    }

    #define LAST_KNOWN_TYPE     FormComponentType::PATTERNFIELD
    Sequence< sal_Bool > SAL_CALL FmXGridPeer::queryFieldDataType( const Type& xType )
    {
        // a 'conversion table'
        static const bool bCanConvert[LAST_KNOWN_TYPE][4] =
        {
            { false, false, false, false }, //  FormComponentType::CONTROL
            { false, false, false, false }, //  FormComponentType::COMMANDBUTTON
            { false, false, false, false }, //  FormComponentType::RADIOBUTTON
            { false, false, false, false }, //  FormComponentType::IMAGEBUTTON
            { false, false, false, true  }, //  FormComponentType::CHECKBOX
            { false, false, false, false }, //  FormComponentType::LISTBOX
            { false, false, false, false }, //  FormComponentType::COMBOBOX
            { false, false, false, false }, //  FormComponentType::GROUPBOX
            { true , false, false, false }, //  FormComponentType::TEXTFIELD
            { false, false, false, false }, //  FormComponentType::FIXEDTEXT
            { false, false, false, false }, //  FormComponentType::GRIDCONTROL
            { false, false, false, false }, //  FormComponentType::FILECONTROL
            { false, false, false, false }, //  FormComponentType::HIDDENCONTROL
            { false, false, false, false }, //  FormComponentType::IMAGECONTROL
            { true , true , true , false }, //  FormComponentType::DATEFIELD
            { true , true , false, false }, //  FormComponentType::TIMEFIELD
            { true , true , false, false }, //  FormComponentType::NUMERICFIELD
            { true , true , false, false }, //  FormComponentType::CURRENCYFIELD
            { true , false, false, false }  //  FormComponentType::PATTERNFIELD
        };

        sal_Int16 nMapColumn = -1;
        switch (xType.getTypeClass())
        {
            case TypeClass_STRING           : nMapColumn = 0; break;
            case TypeClass_FLOAT:
            case TypeClass_DOUBLE           : nMapColumn = 1; break;
            case TypeClass_SHORT:
            case TypeClass_LONG:
            case TypeClass_UNSIGNED_LONG:
            case TypeClass_UNSIGNED_SHORT   : nMapColumn = 2; break;
            case TypeClass_BOOLEAN          : nMapColumn = 3; break;
            default:
                break;
        }

        Reference< XIndexContainer >  xColumns = getColumns();

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        sal_Int32 nColumns = pGrid->GetViewColCount();

        std::vector< std::unique_ptr<DbGridColumn> > const & aColumns = pGrid->GetColumns();

        Sequence<sal_Bool> aReturnSequence(nColumns);
        sal_Bool* pReturnArray = aReturnSequence.getArray();

        bool bRequestedAsAny = (xType.getTypeClass() == TypeClass_ANY);

        DbGridColumn* pCol;
        Reference< css::sdb::XColumn >  xFieldContent;
        Reference< XPropertySet >  xCurrentColumn;
        for (sal_Int32 i=0; i<nColumns; ++i)
        {
            if (bRequestedAsAny)
            {
                pReturnArray[i] = true;
                continue;
            }

            pReturnArray[i] = false;

            sal_uInt16 nModelPos = pGrid->GetModelColumnPos(pGrid->GetColumnIdFromViewPos(static_cast<sal_uInt16>(i)));
            DBG_ASSERT(nModelPos != sal_uInt16(-1), "FmXGridPeer::queryFieldDataType : no model pos !");

            pCol = aColumns[ nModelPos ].get();
            const DbGridRowRef xRow = pGrid->GetSeekRow();
            xFieldContent = (xRow.is() && xRow->HasField(pCol->GetFieldPos())) ? xRow->GetField(pCol->GetFieldPos()).getColumn() : Reference< css::sdb::XColumn > ();
            if (!xFieldContent.is())
                // can't supply anything without a field content
                // FS - 07.12.99 - 54391
                continue;

            xColumns->getByIndex(nModelPos) >>= xCurrentColumn;
            if (!::comphelper::hasProperty(FM_PROP_CLASSID, xCurrentColumn))
                continue;

            sal_Int16 nClassId = sal_Int16();
            xCurrentColumn->getPropertyValue(FM_PROP_CLASSID) >>= nClassId;
            if (nClassId>LAST_KNOWN_TYPE)
                continue;
            DBG_ASSERT(nClassId>0, "FmXGridPeer::queryFieldDataType : somebody changed the definition of the FormComponentType enum !");

            if (nMapColumn != -1)
                pReturnArray[i] = bCanConvert[nClassId-1][nMapColumn];
        }

        return aReturnSequence;
    }

    Sequence< Any > SAL_CALL FmXGridPeer::queryFieldData( sal_Int32 nRow, const Type& xType )
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        DBG_ASSERT(pGrid && pGrid->IsOpen(), "FmXGridPeer::queryFieldData : have no valid grid window !");
        if (!pGrid || !pGrid->IsOpen())
            return Sequence< Any>();

        // move the control to the specified row
        if (!pGrid->SeekRow(nRow))
        {
            throw IllegalArgumentException();
        }

        // don't use GetCurrentRow as this isn't affected by the above SeekRow
        // FS - 30.09.99 - 68644
        DbGridRowRef xPaintRow = pGrid->GetPaintRow();
        ENSURE_OR_THROW( xPaintRow.is(), "invalid paint row" );

        // I need the columns of the control for GetFieldText
        std::vector< std::unique_ptr<DbGridColumn> > const & aColumns = pGrid->GetColumns();

        // and through all the columns
        sal_Int32 nColumnCount = pGrid->GetViewColCount();

        Sequence< Any> aReturnSequence(nColumnCount);
        Any* pReturnArray = aReturnSequence.getArray();

        bool bRequestedAsAny = (xType.getTypeClass() == TypeClass_ANY);
        Reference< css::sdb::XColumn >  xFieldContent;
        for (sal_Int32 i=0; i < nColumnCount; ++i)
        {
            sal_uInt16 nModelPos = pGrid->GetModelColumnPos(pGrid->GetColumnIdFromViewPos(static_cast<sal_uInt16>(i)));
            DBG_ASSERT(nModelPos != sal_uInt16(-1), "FmXGridPeer::queryFieldData : invalid model pos !");

            // don't use GetCurrentFieldValue to determine the field content as this isn't affected by the above SeekRow
            // FS - 30.09.99 - 68644
            DbGridColumn* pCol = aColumns[ nModelPos ].get();
            xFieldContent = xPaintRow->HasField( pCol->GetFieldPos() )
                        ?   xPaintRow->GetField( pCol->GetFieldPos() ).getColumn()
                        :   Reference< XColumn > ();

            if ( !xFieldContent.is() )
                continue;

            if (bRequestedAsAny)
            {
                Reference< XPropertySet >  xFieldSet(xFieldContent, UNO_QUERY);
                pReturnArray[i] = xFieldSet->getPropertyValue(FM_PROP_VALUE);
            }
            else
            {
                switch (xType.getTypeClass())
                {
                    // Strings are dealt with directly by the GetFieldText
                    case TypeClass_STRING           :
                    {
                        OUString sText = aColumns[ nModelPos ]->GetCellText( xPaintRow.get(), pGrid->getNumberFormatter() );
                        pReturnArray[i] <<= sText;
                    }
                    break;
                    // everything else is requested in the DatabaseVariant
                    case TypeClass_FLOAT            : pReturnArray[i] <<= xFieldContent->getFloat(); break;
                    case TypeClass_DOUBLE           : pReturnArray[i] <<= xFieldContent->getDouble(); break;
                    case TypeClass_SHORT            : pReturnArray[i] <<= static_cast<sal_Int16>(xFieldContent->getShort()); break;
                    case TypeClass_LONG             : pReturnArray[i] <<= static_cast<sal_Int32>(xFieldContent->getLong()); break;
                    case TypeClass_UNSIGNED_SHORT   : pReturnArray[i] <<= static_cast<sal_uInt16>(xFieldContent->getShort()); break;
                    case TypeClass_UNSIGNED_LONG    : pReturnArray[i] <<= static_cast<sal_uInt32>(xFieldContent->getLong()); break;
                    case TypeClass_BOOLEAN          : pReturnArray[i] <<= xFieldContent->getBoolean(); break;
                    default:
                    {
                        throw IllegalArgumentException();
                    }
                }
            }
        }
        return aReturnSequence;
    }

    void FmXGridPeer::CellModified()
    {
        EventObject aEvt;
        aEvt.Source = static_cast< ::cppu::OWeakObject* >(this);
        m_aModifyListeners.notifyEach( &XModifyListener::modified, aEvt );
    }

    // XPropertyChangeListener

    void FmXGridPeer::propertyChange(const PropertyChangeEvent& evt)
    {
        SolarMutexGuard aGuard;
            // want to do a lot of VCL stuff here ...
            // this should not be (deadlock) critical, as by definition, every component should release
            // any own mutexes before notifying

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (!pGrid)
            return;

        // Database event
        if (evt.PropertyName == FM_PROP_VALUE || m_xCursor == evt.Source)
            pGrid->propertyChange(evt);
        else if (pGrid && m_xColumns.is() && m_xColumns->hasElements())
        {
            // next find which column has changed
            css::uno::Reference<css::uno::XInterface> xCurrent;
            sal_Int32 i;

            for ( i = 0; i < m_xColumns->getCount(); i++)
            {
                xCurrent.set(m_xColumns->getByIndex(i), css::uno::UNO_QUERY);
                if (evt.Source == xCurrent)
                    break;
            }

            if (i >= m_xColumns->getCount())
                // this is valid because we are listening at the cursor, too (RecordCount, -status, edit mode)
                return;

            sal_uInt16 nId = pGrid->GetColumnIdFromModelPos(static_cast<sal_uInt16>(i));
            bool bInvalidateColumn = false;

            if (evt.PropertyName == FM_PROP_LABEL)
            {
                OUString aName = ::comphelper::getString(evt.NewValue);
                if (aName != pGrid->GetColumnTitle(nId))
                    pGrid->SetColumnTitle(nId, aName);
            }
            else if (evt.PropertyName == FM_PROP_WIDTH)
            {
                sal_Int32 nWidth = 0;
                if (evt.NewValue.getValueType().getTypeClass() == TypeClass_VOID)
                    nWidth = pGrid->GetDefaultColumnWidth(pGrid->GetColumnTitle(nId));
                    // GetDefaultColumnWidth already considered the zoom factor
                else
                {
                    sal_Int32 nTest = 0;
                    if (evt.NewValue >>= nTest)
                    {
                        nWidth = pGrid->LogicToPixel(Point(nTest, 0), MapMode(MapUnit::Map10thMM)).X();
                        // take the zoom factor into account
                        nWidth = pGrid->CalcZoom(nWidth);
                    }
                }
                if (nWidth != (sal_Int32(pGrid->GetColumnWidth(nId))))
                {
                    if (pGrid->IsEditing())
                    {
                        pGrid->DeactivateCell();
                        pGrid->ActivateCell();
                    }
                    pGrid->SetColumnWidth(nId, nWidth);
                }
            }
            else if (evt.PropertyName == FM_PROP_HIDDEN)
            {
                DBG_ASSERT(evt.NewValue.getValueType().getTypeClass() == TypeClass_BOOLEAN,
                    "FmXGridPeer::propertyChange : the property 'hidden' should be of type boolean !");
                if (::comphelper::getBOOL(evt.NewValue))
                    pGrid->HideColumn(nId);
                else
                    pGrid->ShowColumn(nId);
            }
            else if (evt.PropertyName == FM_PROP_ALIGN)
            {
                // in design mode it doesn't matter
                if (!isDesignMode())
                {
                    DbGridColumn* pCol = pGrid->GetColumns()[i].get();

                    pCol->SetAlignmentFromModel(-1);
                    bInvalidateColumn = true;
                }
            }
            else if (evt.PropertyName == FM_PROP_FORMATKEY)
            {
                if (!isDesignMode())
                    bInvalidateColumn = true;
            }

            // need to invalidate the affected column ?
            if (bInvalidateColumn)
            {
                bool bWasEditing = pGrid->IsEditing();
                if (bWasEditing)
                    pGrid->DeactivateCell();

                ::tools::Rectangle aColRect = pGrid->GetFieldRect(nId);
                aColRect.SetTop( 0 );
                aColRect.SetBottom( pGrid->GetSizePixel().Height() );
                pGrid->Invalidate(aColRect);

                if (bWasEditing)
                    pGrid->ActivateCell();
            }
        }
    }

    // XBoundComponent

    void FmXGridPeer::addUpdateListener(const Reference< XUpdateListener >& l)
    {
        m_aUpdateListeners.addInterface(l);
    }

    void FmXGridPeer::removeUpdateListener(const Reference< XUpdateListener >& l)
    {
        m_aUpdateListeners.removeInterface(l);
    }

    sal_Bool FmXGridPeer::commit()
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (!m_xCursor.is() || !pGrid)
            return true;

        EventObject aEvt(static_cast< ::cppu::OWeakObject* >(this));
        ::comphelper::OInterfaceIteratorHelper2 aIter(m_aUpdateListeners);
        bool bCancel = false;
        while (aIter.hasMoreElements() && !bCancel)
            if ( !static_cast< XUpdateListener* >( aIter.next() )->approveUpdate( aEvt ) )
                bCancel = true;

        if (!bCancel)
            bCancel = !pGrid->commit();

        if (!bCancel)
            m_aUpdateListeners.notifyEach( &XUpdateListener::updated, aEvt );
        return !bCancel;
    }

    void FmXGridPeer::cursorMoved(const EventObject& _rEvent)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        // we are not interested in move to insert row only in the resetted event
        // which is fired after positioning an the insert row
        if (pGrid && pGrid->IsOpen() && !::comphelper::getBOOL(Reference< XPropertySet > (_rEvent.Source, UNO_QUERY)->getPropertyValue(FM_PROP_ISNEW)))
            pGrid->positioned();
    }

    void FmXGridPeer::rowChanged(const EventObject& /*_rEvent*/)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (pGrid && pGrid->IsOpen())
        {
            if (m_xCursor->rowUpdated() && !pGrid->IsCurrentAppending())
                pGrid->RowModified(pGrid->GetCurrentPos());
            else if (m_xCursor->rowInserted())
                pGrid->inserted();
        }
    }

    void FmXGridPeer::rowSetChanged(const EventObject& /*event*/)
    {
        // not interested in ...
        // (our parent is a form which means we get a loaded or reloaded after this rowSetChanged)
    }

    // XLoadListener

    void FmXGridPeer::loaded(const EventObject& /*rEvent*/)
    {
        updateGrid(m_xCursor);
    }

    void FmXGridPeer::unloaded(const EventObject& /*rEvent*/)
    {
        updateGrid( Reference< XRowSet > (nullptr) );
    }

    void FmXGridPeer::reloading(const EventObject& /*aEvent*/)
    {
        // empty the grid
        updateGrid( Reference< XRowSet > (nullptr) );
    }

    void FmXGridPeer::unloading(const EventObject& /*aEvent*/)
    {
        // empty the grid
        updateGrid( Reference< XRowSet > (nullptr) );
    }

    void FmXGridPeer::reloaded(const EventObject& aEvent)
    {
        {
            const sal_Int32 cnt = m_xColumns->getCount();
            for(sal_Int32 i=0; i<cnt; ++i)
            {
                Reference< XLoadListener> xll(m_xColumns->getByIndex(i), UNO_QUERY);
                if(xll.is())
                {
                    xll->reloaded(aEvent);
                }
            }
        }
        updateGrid(m_xCursor);
    }

    // XGridPeer

    Reference< XIndexContainer >  FmXGridPeer::getColumns()
    {
        return m_xColumns;
    }

    void FmXGridPeer::addColumnListeners(const Reference< XPropertySet >& xCol)
    {
        static const OUStringLiteral aPropsListenedTo[] =
        {
            FM_PROP_LABEL, FM_PROP_WIDTH, FM_PROP_HIDDEN, FM_PROP_ALIGN,
            FM_PROP_FORMATKEY
        };

        // as not all properties have to be supported by all columns we have to check this
        // before adding a listener
        Reference< XPropertySetInfo > xInfo = xCol->getPropertySetInfo();
        for (unsigned i=0; i<SAL_N_ELEMENTS(aPropsListenedTo); ++i)
        {
            if ( xInfo->hasPropertyByName( aPropsListenedTo[i] ) )
            {
                Property aPropDesc = xInfo->getPropertyByName( aPropsListenedTo[i] );
                if ( 0 != ( aPropDesc.Attributes & PropertyAttribute::BOUND ) )
                    xCol->addPropertyChangeListener( aPropsListenedTo[i], this );
            }
        }
    }

    void FmXGridPeer::removeColumnListeners(const Reference< XPropertySet >& xCol)
    {
        // the same props as in addColumnListeners ... linux has problems with global static UStrings, so
        // we have to do it this way ....
        static const OUStringLiteral aPropsListenedTo[] =
        {
            FM_PROP_LABEL, FM_PROP_WIDTH, FM_PROP_HIDDEN, FM_PROP_ALIGN,
            FM_PROP_FORMATKEY
        };

        Reference< XPropertySetInfo >  xInfo = xCol->getPropertySetInfo();
        for (const auto & i : aPropsListenedTo)
            if (xInfo->hasPropertyByName(i))
                xCol->removePropertyChangeListener(i, this);
    }

    void FmXGridPeer::setColumns(const Reference< XIndexContainer >& Columns)
    {
        SolarMutexGuard aGuard;

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();

        if (m_xColumns.is())
        {
            Reference< XPropertySet > xCol;
            for (sal_Int32 i = 0; i < m_xColumns->getCount(); i++)
            {
                xCol.set(m_xColumns->getByIndex(i), css::uno::UNO_QUERY);
                removeColumnListeners(xCol);
            }
            Reference< XContainer >  xContainer(m_xColumns, UNO_QUERY);
            xContainer->removeContainerListener(this);

            Reference< XSelectionSupplier >  xSelSupplier(m_xColumns, UNO_QUERY);
            xSelSupplier->removeSelectionChangeListener(this);

            Reference< XReset >  xColumnReset(m_xColumns, UNO_QUERY);
            if (xColumnReset.is())
                xColumnReset->removeResetListener(static_cast<XResetListener*>(this));
        }
        if (Columns.is())
        {
            Reference< XContainer >  xContainer(Columns, UNO_QUERY);
            xContainer->addContainerListener(this);

            Reference< XSelectionSupplier >  xSelSupplier(Columns, UNO_QUERY);
            xSelSupplier->addSelectionChangeListener(this);

            Reference< XPropertySet >  xCol;
            for (sal_Int32 i = 0; i < Columns->getCount(); i++)
            {
                xCol.set(Columns->getByIndex(i), css::uno::UNO_QUERY);
                addColumnListeners(xCol);
            }

            Reference< XReset >  xColumnReset(Columns, UNO_QUERY);
            if (xColumnReset.is())
                xColumnReset->addResetListener(static_cast<XResetListener*>(this));
        }
        m_xColumns = Columns;
        if (pGrid)
        {
            pGrid->InitColumnsByModels(m_xColumns);

            if (m_xColumns.is())
            {
                EventObject aEvt(m_xColumns);
                selectionChanged(aEvt);
            }
        }
    }

    void FmXGridPeer::setDesignMode(sal_Bool bOn)
    {
        if (bOn != isDesignMode())
        {
            VclPtr<vcl::Window> pWin = GetWindow();
            if (pWin)
                static_cast<FmGridControl*>(pWin.get())->SetDesignMode(bOn);
        }

        if (bOn)
            DisConnectFromDispatcher();
        else
            UpdateDispatches(); // will connect if not already connected and just update else
    }

    sal_Bool FmXGridPeer::isDesignMode()
    {
        VclPtr<vcl::Window> pWin = GetWindow();
        if (pWin)
            return static_cast<FmGridControl*>(pWin.get())->IsDesignMode();
        else
            return false;
    }

    void FmXGridPeer::elementInserted(const ContainerEvent& evt)
    {
        SolarMutexGuard aGuard;

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        // take handle column into account
        if (!pGrid || !m_xColumns.is() || pGrid->IsInColumnMove() || m_xColumns->getCount() == static_cast<sal_Int32>(pGrid->GetModelColCount()))
            return;

        Reference< XPropertySet >  xNewColumn(evt.Element, css::uno::UNO_QUERY);
        addColumnListeners(xNewColumn);

        OUString aName = ::comphelper::getString(xNewColumn->getPropertyValue(FM_PROP_LABEL));
        Any aWidth = xNewColumn->getPropertyValue(FM_PROP_WIDTH);
        sal_Int32 nWidth = 0;
        if (aWidth >>= nWidth)
            nWidth = pGrid->LogicToPixel(Point(nWidth, 0), MapMode(MapUnit::Map10thMM)).X();

        pGrid->AppendColumn(aName, static_cast<sal_uInt16>(nWidth), static_cast<sal_Int16>(::comphelper::getINT32(evt.Accessor)));

        // now set the column
        DbGridColumn* pCol = pGrid->GetColumns()[ ::comphelper::getINT32(evt.Accessor) ].get();
        pCol->setModel(xNewColumn);

        Any aHidden = xNewColumn->getPropertyValue(FM_PROP_HIDDEN);
        if (::comphelper::getBOOL(aHidden))
            pGrid->HideColumn(pCol->GetId());

        FormControlFactory( m_xContext ).initializeTextFieldLineEnds( xNewColumn );
    }

    void FmXGridPeer::elementReplaced(const ContainerEvent& evt)
    {
        SolarMutexGuard aGuard;

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();

        // take handle column into account
        if (!pGrid || !m_xColumns.is() || pGrid->IsInColumnMove())
            return;

        Reference< XPropertySet > xNewColumn(evt.Element, css::uno::UNO_QUERY);
        Reference< XPropertySet > xOldColumn(
            evt.ReplacedElement, css::uno::UNO_QUERY);

        bool bWasEditing = pGrid->IsEditing();
        if (bWasEditing)
            pGrid->DeactivateCell();

        pGrid->RemoveColumn(pGrid->GetColumnIdFromModelPos(static_cast<sal_uInt16>(::comphelper::getINT32(evt.Accessor))));

        removeColumnListeners(xOldColumn);
        addColumnListeners(xNewColumn);

        OUString aName = ::comphelper::getString(xNewColumn->getPropertyValue(FM_PROP_LABEL));
        Any aWidth = xNewColumn->getPropertyValue(FM_PROP_WIDTH);
        sal_Int32 nWidth = 0;
        if (aWidth >>= nWidth)
            nWidth = pGrid->LogicToPixel(Point(nWidth, 0), MapMode(MapUnit::Map10thMM)).X();
        sal_uInt16 nNewId = pGrid->AppendColumn(aName, static_cast<sal_uInt16>(nWidth), static_cast<sal_Int16>(::comphelper::getINT32(evt.Accessor)));
        sal_uInt16 nNewPos = pGrid->GetModelColumnPos(nNewId);

        // set the model of the new column
        DbGridColumn* pCol = pGrid->GetColumns()[ nNewPos ].get();

        // for initializing this grid column, we need the fields of the grid's data source
        Reference< XColumnsSupplier > xSuppColumns;
        CursorWrapper* pGridDataSource = pGrid->getDataSource();
        if ( pGridDataSource )
            xSuppColumns.set(Reference< XInterface >( *pGridDataSource ), css::uno::UNO_QUERY);
        Reference< XNameAccess > xColumnsByName;
        if ( xSuppColumns.is() )
            xColumnsByName = xSuppColumns->getColumns();
        Reference< XIndexAccess > xColumnsByIndex( xColumnsByName, UNO_QUERY );

        if ( xColumnsByIndex.is() )
            FmGridControl::InitColumnByField( pCol, xNewColumn, xColumnsByName, xColumnsByIndex );
        else
            // the simple version, applies when the grid is not yet connected to a data source
            pCol->setModel(xNewColumn);

        if (bWasEditing)
            pGrid->ActivateCell();
    }

    void FmXGridPeer::elementRemoved(const ContainerEvent& evt)
    {
        SolarMutexGuard aGuard;

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();

        // take handle column into account
        if (!pGrid || !m_xColumns.is() || pGrid->IsInColumnMove() || m_xColumns->getCount() == static_cast<sal_Int32>(pGrid->GetModelColCount()))
            return;

        pGrid->RemoveColumn(pGrid->GetColumnIdFromModelPos(static_cast<sal_uInt16>(::comphelper::getINT32(evt.Accessor))));

        Reference< XPropertySet > xOldColumn(evt.Element, css::uno::UNO_QUERY);
        removeColumnListeners(xOldColumn);
    }

    void FmXGridPeer::setProperty( const OUString& PropertyName, const Any& Value)
    {
        SolarMutexGuard aGuard;

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();

        bool bVoid = !Value.hasValue();

        if ( PropertyName == FM_PROP_TEXTLINECOLOR )
        {
            ::Color aTextLineColor( bVoid ? COL_TRANSPARENT : ::Color(::comphelper::getINT32( Value )) );
            if (bVoid)
            {
                pGrid->SetTextLineColor();
                pGrid->GetDataWindow().SetTextLineColor();
            }
            else
            {
                pGrid->SetTextLineColor(aTextLineColor);
                pGrid->GetDataWindow().SetTextLineColor(aTextLineColor);
            }

            // need to forward this to the columns
            std::vector< std::unique_ptr<DbGridColumn> > const & rColumns = pGrid->GetColumns();
            for (auto const & pLoop : rColumns)
            {
                FmXGridCell* pXCell = pLoop->GetCell();
                if (pXCell)
                {
                    if (bVoid)
                        pXCell->SetTextLineColor();
                    else
                        pXCell->SetTextLineColor(aTextLineColor);
                }
            }

            if (isDesignMode())
                pGrid->Invalidate();
        }
        else if ( PropertyName == FM_PROP_FONTEMPHASISMARK )
        {
            vcl::Font aGridFont = pGrid->GetControlFont();
            sal_Int16 nValue = ::comphelper::getINT16(Value);
            aGridFont.SetEmphasisMark( static_cast<FontEmphasisMark>(nValue) );
            pGrid->SetControlFont( aGridFont );
        }
        else if ( PropertyName == FM_PROP_FONTRELIEF )
        {
            vcl::Font aGridFont = pGrid->GetControlFont();
            sal_Int16 nValue = ::comphelper::getINT16(Value);
            aGridFont.SetRelief( static_cast<FontRelief>(nValue) );
            pGrid->SetControlFont( aGridFont );
        }
        else if ( PropertyName == FM_PROP_HELPURL )
        {
            OUString sHelpURL;
            OSL_VERIFY( Value >>= sHelpURL );
            INetURLObject aHID( sHelpURL );
            if ( aHID.GetProtocol() == INetProtocol::Hid )
                sHelpURL = aHID.GetURLPath();
            pGrid->SetHelpId( OUStringToOString( sHelpURL, RTL_TEXTENCODING_UTF8 ) );
        }
        else if ( PropertyName == FM_PROP_DISPLAYSYNCHRON )
        {
            pGrid->setDisplaySynchron(::comphelper::getBOOL(Value));
        }
        else if ( PropertyName == FM_PROP_CURSORCOLOR )
        {
            if (bVoid)
                pGrid->SetCursorColor(COL_TRANSPARENT);
            else
                pGrid->SetCursorColor( ::Color(::comphelper::getINT32(Value)));
            if (isDesignMode())
                pGrid->Invalidate();
        }
        else if ( PropertyName == FM_PROP_ALWAYSSHOWCURSOR )
        {
            pGrid->EnablePermanentCursor(::comphelper::getBOOL(Value));
            if (isDesignMode())
                pGrid->Invalidate();
        }
        else if ( PropertyName == FM_PROP_FONT )
        {
            if ( bVoid )
                pGrid->SetControlFont( vcl::Font() );
            else
            {
                css::awt::FontDescriptor aFont;
                if (Value >>= aFont)
                {
                    vcl::Font aNewVclFont;
                    if (aFont != ::comphelper::getDefaultFont())    // is this the default
                        aNewVclFont = ImplCreateFont( aFont );

                    // need to add relief and emphasis (they're stored in a VCL-Font, but not in a FontDescriptor
                    vcl::Font aOldVclFont = pGrid->GetControlFont();
                    aNewVclFont.SetRelief( aOldVclFont.GetRelief() );
                    aNewVclFont.SetEmphasisMark( aOldVclFont.GetEmphasisMark() );

                    // now set it ...
                    pGrid->SetControlFont( aNewVclFont );

                    // if our row-height property is void (which means "calculate it font-dependent") we have
                    // to adjust the control's row height
                    Reference< XPropertySet >  xModelSet(getColumns(), UNO_QUERY);
                    if (xModelSet.is() && ::comphelper::hasProperty(FM_PROP_ROWHEIGHT, xModelSet))
                    {
                        Any aHeight = xModelSet->getPropertyValue(FM_PROP_ROWHEIGHT);
                        if (!aHeight.hasValue())
                            pGrid->SetDataRowHeight(0);
                    }

                }
            }
        }
        else if ( PropertyName == FM_PROP_BACKGROUNDCOLOR )
        {
            if ( bVoid )
            {
                pGrid->SetControlBackground();
            }
            else
            {
                ::Color aColor( ::comphelper::getINT32(Value) );
                pGrid->SetBackground( aColor );
                pGrid->SetControlBackground( aColor );
            }
        }
        else if ( PropertyName == FM_PROP_TEXTCOLOR )
        {
            if ( bVoid )
            {
                pGrid->SetControlForeground();
            }
            else
            {
                ::Color aColor( ::comphelper::getINT32(Value) );
                pGrid->SetTextColor( aColor );
                pGrid->SetControlForeground( aColor );
            }
        }
        else if ( PropertyName == FM_PROP_ROWHEIGHT )
        {
            sal_Int32 nLogHeight(0);
            if (Value >>= nLogHeight)
            {
                sal_Int32 nHeight = pGrid->LogicToPixel(Point(0, nLogHeight), MapMode(MapUnit::Map10thMM)).Y();
                // take the zoom factor into account
                nHeight = pGrid->CalcZoom(nHeight);
                pGrid->SetDataRowHeight(nHeight);
            }
            else if (bVoid)
                pGrid->SetDataRowHeight(0);
        }
        else if ( PropertyName == FM_PROP_HASNAVIGATION )
        {
            bool bValue( true );
            OSL_VERIFY( Value >>= bValue );
            pGrid->EnableNavigationBar( bValue );
        }
        else if ( PropertyName == FM_PROP_RECORDMARKER )
        {
            bool bValue( true );
            OSL_VERIFY( Value >>= bValue );
            pGrid->EnableHandle( bValue );
        }
        else if ( PropertyName == FM_PROP_ENABLED )
        {
            bool bValue( true );
            OSL_VERIFY( Value >>= bValue );

            // In design mode, disable only the data window.
            // Else the control cannot be configured anymore.
            if (isDesignMode())
                pGrid->GetDataWindow().Enable( bValue );
            else
                pGrid->Enable( bValue );
        }
        else
            VCLXWindow::setProperty( PropertyName, Value );
    }

    Reference< XAccessibleContext > FmXGridPeer::CreateAccessibleContext()
    {
        Reference< XAccessibleContext > xContext;

        // use the AccessibleContext provided by the VCL window
        VclPtr<vcl::Window> pGrid = GetWindow();
        if ( pGrid )
        {
            Reference< XAccessible > xAcc( pGrid->GetAccessible() );
            if ( xAcc.is() )
                xContext = xAcc->getAccessibleContext();
            // TODO: this has a slight conceptual problem:

            // We know that the XAccessible and XAccessibleContext implementation of the browse
            // box is the same (the class implements both interfaces), which, speaking strictly,
            // is bad here (means when a browse box acts as UnoControl): We (the FmXGridPeer) are
            // the XAccessible here, and the browse box should be able to provide us an XAccessibleContext,
            // but it should _not_ be the XAccessible itself.
            // However, as long as no client implementation uses dirty hacks such as querying an
            // XAccessibleContext for XAccessible, this should not be a problem.
        }

        if ( !xContext.is() )
            xContext = VCLXWindow::CreateAccessibleContext( );

        return xContext;
    }

    Any FmXGridPeer::getProperty( const OUString& _rPropertyName )
    {
        Any aProp;
        if (GetWindow())
        {
            VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
            vcl::Window* pDataWindow  = &pGrid->GetDataWindow();

            if ( _rPropertyName == FM_PROP_NAME )
            {
                vcl::Font aFont = pDataWindow->GetControlFont();
                aProp <<= ImplCreateFontDescriptor( aFont );
            }
            else if ( _rPropertyName == FM_PROP_TEXTCOLOR )
            {
                aProp <<= pDataWindow->GetControlForeground();
            }
            else if ( _rPropertyName == FM_PROP_BACKGROUNDCOLOR )
            {
                aProp <<= pDataWindow->GetControlBackground();
            }
            else if ( _rPropertyName == FM_PROP_ROWHEIGHT )
            {
                sal_Int32 nPixelHeight = pGrid->GetDataRowHeight();
                // take the zoom factor into account
                nPixelHeight = pGrid->CalcReverseZoom(nPixelHeight);
                aProp <<= static_cast<sal_Int32>(pGrid->PixelToLogic(Point(0, nPixelHeight), MapMode(MapUnit::Map10thMM)).Y());
            }
            else if ( _rPropertyName == FM_PROP_HASNAVIGATION )
            {
                bool bHasNavBar = pGrid->HasNavigationBar();
                aProp <<= bHasNavBar;
            }
            else if ( _rPropertyName == FM_PROP_RECORDMARKER )
            {
                bool bHasHandle = pGrid->HasHandle();
                aProp <<= bHasHandle;
            }
            else if ( _rPropertyName == FM_PROP_ENABLED )
            {
                aProp <<= pDataWindow->IsEnabled();
            }
            else
                aProp = VCLXWindow::getProperty( _rPropertyName );
        }
        return aProp;
    }

    void FmXGridPeer::dispose()
    {
        EventObject aEvt;
        aEvt.Source = static_cast< ::cppu::OWeakObject* >(this);
        m_aModifyListeners.disposeAndClear(aEvt);
        m_aUpdateListeners.disposeAndClear(aEvt);
        m_aContainerListeners.disposeAndClear(aEvt);
        VCLXWindow::dispose();

        // release all interceptors
        Reference< XDispatchProviderInterceptor > xInterceptor( m_xFirstDispatchInterceptor );
        m_xFirstDispatchInterceptor.clear();
        while ( xInterceptor.is() )
        {
            // tell the interceptor it has a new (means no) predecessor
            xInterceptor->setMasterDispatchProvider( nullptr );

            // ask for its successor
            Reference< XDispatchProvider > xSlave = xInterceptor->getSlaveDispatchProvider();
            // and give it the new (means no) successoert
            xInterceptor->setSlaveDispatchProvider( nullptr );

            // start over with the next chain element
            xInterceptor.set(xSlave, css::uno::UNO_QUERY);
        }

        DisConnectFromDispatcher();
        setRowSet(Reference< XRowSet > ());
    }

    // XContainer

    void FmXGridPeer::addContainerListener(const Reference< XContainerListener >& l)
    {
        m_aContainerListeners.addInterface( l );
    }

    void FmXGridPeer::removeContainerListener(const Reference< XContainerListener >& l)
    {
        m_aContainerListeners.removeInterface( l );
    }

    // css::data::XDatabaseCursorSupplier

    void FmXGridPeer::startCursorListening()
    {
        if (!m_nCursorListening)
        {
            Reference< XRowSet >  xRowSet(m_xCursor, UNO_QUERY);
            if (xRowSet.is())
                xRowSet->addRowSetListener(this);

            Reference< XReset >  xReset(m_xCursor, UNO_QUERY);
            if (xReset.is())
                xReset->addResetListener(this);

            // register all listeners
            Reference< XPropertySet >  xSet(m_xCursor, UNO_QUERY);
            if (xSet.is())
            {
                xSet->addPropertyChangeListener(FM_PROP_ISMODIFIED, this);
                xSet->addPropertyChangeListener(FM_PROP_ROWCOUNT, this);
            }
        }
        m_nCursorListening++;
    }

    void FmXGridPeer::stopCursorListening()
    {
        if (!--m_nCursorListening)
        {
            Reference< XRowSet >  xRowSet(m_xCursor, UNO_QUERY);
            if (xRowSet.is())
                xRowSet->removeRowSetListener(this);

            Reference< XReset >  xReset(m_xCursor, UNO_QUERY);
            if (xReset.is())
                xReset->removeResetListener(this);

            Reference< XPropertySet >  xSet(m_xCursor, UNO_QUERY);
            if (xSet.is())
            {
                xSet->removePropertyChangeListener(FM_PROP_ISMODIFIED, this);
                xSet->removePropertyChangeListener(FM_PROP_ROWCOUNT, this);
            }
        }
    }

    void FmXGridPeer::updateGrid(const Reference< XRowSet >& _rxCursor)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (pGrid)
            pGrid->setDataSource(_rxCursor);
    }

    Reference< XRowSet >  FmXGridPeer::getRowSet()
    {
        return m_xCursor;
    }

    void FmXGridPeer::setRowSet(const Reference< XRowSet >& _rDatabaseCursor)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (!pGrid || !m_xColumns.is() || !m_xColumns->getCount())
            return;
        // unregister all listeners
        if (m_xCursor.is())
        {
            Reference< XLoadable >  xLoadable(m_xCursor, UNO_QUERY);
            // only if the form is loaded we set the rowset
            if (xLoadable.is())
            {
                stopCursorListening();
                xLoadable->removeLoadListener(this);
            }
        }

        m_xCursor = _rDatabaseCursor;

        if (pGrid)
        {
            Reference< XLoadable >  xLoadable(m_xCursor, UNO_QUERY);
            // only if the form is loaded we set the rowset
            if (xLoadable.is() && xLoadable->isLoaded())
                pGrid->setDataSource(m_xCursor);
            else
                pGrid->setDataSource(Reference< XRowSet > ());

            if (xLoadable.is())
            {
                startCursorListening();
                xLoadable->addLoadListener(this);
            }
        }
    }

    void SAL_CALL FmXGridPeer::addGridControlListener( const Reference< XGridControlListener >& _listener )
    {
        m_aGridControlListeners.addInterface( _listener );
    }

    void SAL_CALL FmXGridPeer::removeGridControlListener( const Reference< XGridControlListener >& _listener )
    {
        m_aGridControlListeners.removeInterface( _listener );
    }

    sal_Int16 FmXGridPeer::getCurrentColumnPosition()
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        return pGrid ? pGrid->GetViewColumnPos(pGrid->GetCurColumnId()) : -1;
    }

    void FmXGridPeer::setCurrentColumnPosition(sal_Int16 nPos)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (pGrid)
            pGrid->GoToColumnId(pGrid->GetColumnIdFromViewPos(nPos));
    }

    void FmXGridPeer::selectionChanged(const EventObject& evt)
    {
        SolarMutexGuard aGuard;

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (pGrid)
        {
            Reference< css::view::XSelectionSupplier >  xSelSupplier(evt.Source, UNO_QUERY);
            Any aSelection = xSelSupplier->getSelection();
            DBG_ASSERT(aSelection.getValueType().getTypeClass() == TypeClass_INTERFACE, "FmXGridPeer::selectionChanged : invalid selection !");
            Reference< XPropertySet >  xSelection;
             aSelection >>= xSelection;
            if (xSelection.is())
            {
                Reference< XPropertySet > xCol;
                sal_Int32 i = 0;
                sal_Int32 nColCount = m_xColumns->getCount();

                for (; i < nColCount; ++i)
                {
                    m_xColumns->getByIndex(i) >>= xCol;
                    if ( xCol == xSelection )
                    {
                        pGrid->markColumn(pGrid->GetColumnIdFromModelPos(static_cast<sal_uInt16>(i)));
                        break;
                    }
                }
                // The columns have to be 1-based for the VCL control.
                // If necessary, pass on the selection to the VCL control
                if ( i != pGrid->GetSelectedColumn() )
                {   // (if this does not take effect, the selectionChanged was implicitly triggered by the control itself)
                    if ( i < nColCount )
                    {
                        pGrid->SelectColumnPos(pGrid->GetViewColumnPos(pGrid->GetColumnIdFromModelPos( static_cast<sal_uInt16>(i) )) + 1);
                        // SelectColumnPos has led to an implicit ActivateCell again
                        if (pGrid->IsEditing())
                            pGrid->DeactivateCell();
                    }
                    else
                        pGrid->SetNoSelection();
                }
            }
            else
                pGrid->markColumn(USHRT_MAX);
        }
    }

    // XElementAccess

    sal_Bool FmXGridPeer::hasElements()
    {
        return getCount() != 0;
    }

    Type SAL_CALL FmXGridPeer::getElementType(  )
    {
        return cppu::UnoType<css::awt::XControl>::get();
    }

    // XEnumerationAccess

    Reference< XEnumeration >  FmXGridPeer::createEnumeration()
    {
        return new ::comphelper::OEnumerationByIndex(this);
    }

    // XIndexAccess

    sal_Int32 FmXGridPeer::getCount()
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (pGrid)
            return pGrid->GetViewColCount();
        else
            return 0;
    }

    Any FmXGridPeer::getByIndex(sal_Int32 _nIndex)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if (_nIndex < 0 ||
            _nIndex >= getCount() || !pGrid)
            throw IndexOutOfBoundsException();

        Any aElement;
        // get the columnid
        sal_uInt16 nId = pGrid->GetColumnIdFromViewPos(static_cast<sal_uInt16>(_nIndex));
        // get the list position
        sal_uInt16 nPos = pGrid->GetModelColumnPos(nId);

        if ( nPos == GRID_COLUMN_NOT_FOUND )
            return aElement;

        DbGridColumn* pCol = pGrid->GetColumns()[ nPos ].get();
        Reference< css::awt::XControl >  xControl(pCol->GetCell());
        aElement <<= xControl;

        return aElement;
    }

    // css::util::XModeSelector

    void FmXGridPeer::setMode(const OUString& Mode)
    {
        if (!supportsMode(Mode))
            throw NoSupportException();

        if (Mode == m_aMode)
            return;

        m_aMode = Mode;

        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        if ( Mode == "FilterMode" )
            pGrid->SetFilterMode(true);
        else
        {
            pGrid->SetFilterMode(false);
            pGrid->setDataSource(m_xCursor);
        }
    }

    OUString FmXGridPeer::getMode()
    {
        return m_aMode;
    }

    css::uno::Sequence<OUString> FmXGridPeer::getSupportedModes()
    {
        static css::uno::Sequence<OUString> aModes;
        if (!aModes.getLength())
        {
            aModes.realloc(2);
            OUString* pModes = aModes.getArray();
            pModes[0] = "DataMode";
            pModes[1] = "FilterMode";
        }
        return aModes;
    }

    sal_Bool FmXGridPeer::supportsMode(const OUString& Mode)
    {
        css::uno::Sequence<OUString> aModes(getSupportedModes());
        const OUString* pModes = aModes.getConstArray();
        for (sal_Int32 i = aModes.getLength(); i > 0; )
        {
            if (pModes[--i] == Mode)
                return true;
        }
        return false;
    }

    void FmXGridPeer::columnVisible(DbGridColumn const * pColumn)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();

        sal_Int32 _nIndex = pGrid->GetModelColumnPos(pColumn->GetId());
        Reference< css::awt::XControl >  xControl(pColumn->GetCell());
        ContainerEvent aEvt;
        aEvt.Source   = static_cast<XContainer*>(this);
        aEvt.Accessor <<= _nIndex;
        aEvt.Element  <<= xControl;

        m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvt );
    }

    void FmXGridPeer::columnHidden(DbGridColumn const * pColumn)
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();

        sal_Int32 _nIndex = pGrid->GetModelColumnPos(pColumn->GetId());
        Reference< css::awt::XControl >  xControl(pColumn->GetCell());
        ContainerEvent aEvt;
        aEvt.Source   = static_cast<XContainer*>(this);
        aEvt.Accessor <<= _nIndex;
        aEvt.Element  <<= xControl;

        m_aContainerListeners.notifyEach( &XContainerListener::elementRemoved, aEvt );
    }

    void FmXGridPeer::draw( sal_Int32 x, sal_Int32 y )
    {
        VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
        EditBrowseBoxFlags nOldFlags = pGrid->GetBrowserFlags();
        pGrid->SetBrowserFlags(nOldFlags | EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT);

        VCLXWindow::draw(x, y);

        pGrid->SetBrowserFlags(nOldFlags);
    }

    Reference< css::frame::XDispatch >  FmXGridPeer::queryDispatch(const css::util::URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags)
    {
        Reference< css::frame::XDispatch >  xResult;

        // first ask our interceptor chain
        if (m_xFirstDispatchInterceptor.is() && !m_bInterceptingDispatch)
        {
            m_bInterceptingDispatch = true;
            // safety against recursion : as we are master of the first chain element and slave of the last one we would
            // have an infinite loop without this if no dispatcher can fulfill the request
            xResult = m_xFirstDispatchInterceptor->queryDispatch(aURL, aTargetFrameName, nSearchFlags);
            m_bInterceptingDispatch = false;
        }

        // then ask ourself : we don't have any dispatches
        return xResult;
    }

    Sequence< Reference< css::frame::XDispatch > > FmXGridPeer::queryDispatches(const Sequence< css::frame::DispatchDescriptor>& aDescripts)
    {
        if (m_xFirstDispatchInterceptor.is())
            return m_xFirstDispatchInterceptor->queryDispatches(aDescripts);

        // then ask ourself : we don't have any dispatches
        return Sequence< Reference< css::frame::XDispatch > >();
    }

    void FmXGridPeer::registerDispatchProviderInterceptor(const Reference< css::frame::XDispatchProviderInterceptor >& _xInterceptor)
    {
        if (_xInterceptor.is())
        {
            if (m_xFirstDispatchInterceptor.is())
            {
                Reference< css::frame::XDispatchProvider > xFirstProvider(m_xFirstDispatchInterceptor, UNO_QUERY);
                // there is already an interceptor; the new one will become its master
                _xInterceptor->setSlaveDispatchProvider(xFirstProvider);
                m_xFirstDispatchInterceptor->setMasterDispatchProvider(xFirstProvider);
            }
            else
            {
                // it is the first interceptor; set ourself as slave
                _xInterceptor->setSlaveDispatchProvider(static_cast<css::frame::XDispatchProvider*>(this));
            }

            // we are the master of the chain's first interceptor
            m_xFirstDispatchInterceptor = _xInterceptor;
            m_xFirstDispatchInterceptor->setMasterDispatchProvider(static_cast<css::frame::XDispatchProvider*>(this));

            // we have a new interceptor and we're alive ?
            if (!isDesignMode())
                // -> check for new dispatchers
                UpdateDispatches();
        }
    }

    void FmXGridPeer::releaseDispatchProviderInterceptor(const Reference< css::frame::XDispatchProviderInterceptor >& _xInterceptor)
    {
        if (!_xInterceptor.is())
            return;

        Reference< css::frame::XDispatchProviderInterceptor >  xChainWalk(m_xFirstDispatchInterceptor);

        if (m_xFirstDispatchInterceptor == _xInterceptor)
        {   // our chain will have a new first element
            Reference< css::frame::XDispatchProviderInterceptor >  xSlave(m_xFirstDispatchInterceptor->getSlaveDispatchProvider(), UNO_QUERY);
            m_xFirstDispatchInterceptor = xSlave;
        }
        // do this before removing the interceptor from the chain as we won't know it's slave afterwards)

        while (xChainWalk.is())
        {
            // walk along the chain of interceptors and look for the interceptor that has to be removed
            Reference< css::frame::XDispatchProviderInterceptor >  xSlave(xChainWalk->getSlaveDispatchProvider(), UNO_QUERY);

            if (xChainWalk == _xInterceptor)
            {
                // old master may be an interceptor too
                Reference< css::frame::XDispatchProviderInterceptor >  xMaster(xChainWalk->getMasterDispatchProvider(), UNO_QUERY);

                // unchain the interceptor that has to be removed
                xChainWalk->setSlaveDispatchProvider(Reference< css::frame::XDispatchProvider > ());
                xChainWalk->setMasterDispatchProvider(Reference< css::frame::XDispatchProvider > ());

                // reconnect the chain
                if (xMaster.is())
                {
                    if (xSlave.is())
                        xMaster->setSlaveDispatchProvider(Reference< css::frame::XDispatchProvider >::query(xSlave));
                    else
                        // it's the first interceptor of the chain, set ourself as slave
                        xMaster->setSlaveDispatchProvider(static_cast<css::frame::XDispatchProvider*>(this));
                }
                else
                {
                    // the chain's first element was removed, set ourself as new master of the second one
                    if (xSlave.is())
                        xSlave->setMasterDispatchProvider(static_cast<css::frame::XDispatchProvider*>(this));
                }
            }

            xChainWalk = xSlave;
        }
        // our interceptor chain has changed and we're alive ?
        if (!isDesignMode())
            // -> check the dispatchers
            UpdateDispatches();
    }

    void FmXGridPeer::statusChanged(const css::frame::FeatureStateEvent& Event)
    {
        DBG_ASSERT(m_pStateCache, "FmXGridPeer::statusChanged : invalid call !");
        DBG_ASSERT(m_pDispatchers, "FmXGridPeer::statusChanged : invalid call !");

        Sequence< css::util::URL>& aUrls = getSupportedURLs();
        const css::util::URL* pUrls = aUrls.getConstArray();

        const std::vector<DbGridControlNavigationBarState>& aSlots = getSupportedGridSlots();

        sal_Int32 i;
        for (i=0; i<aUrls.getLength(); ++i, ++pUrls)
        {
            if (pUrls->Main == Event.FeatureURL.Main)
            {
                DBG_ASSERT(m_pDispatchers[i] == Event.Source, "FmXGridPeer::statusChanged : the event source is a little bit suspect !");
                m_pStateCache[i] = Event.IsEnabled;
                VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
                if (aSlots[i] != DbGridControlNavigationBarState::Undo)
                    pGrid->GetNavigationBar().InvalidateState(aSlots[i]);
                break;
            }
        }
        DBG_ASSERT(i<aUrls.getLength(), "FmXGridPeer::statusChanged : got a call for an unknown url !");
    }

    sal_Bool FmXGridPeer::approveReset(const EventObject& /*rEvent*/)
    {
        return true;
    }

    sal_Bool SAL_CALL FmXGridPeer::select( const Any& _rSelection )
    {
        Sequence< Any > aBookmarks;
        if ( !( _rSelection >>= aBookmarks ) )
            throw IllegalArgumentException();

        return GetAs< FmGridControl >()->selectBookmarks(aBookmarks);

        // TODO:
        // speaking strictly, we would have to adjust our model, as our ColumnSelection may have changed.
        // Our model is a XSelectionSupplier, too, it handles the selection of single columns.
        // This is somewhat strange, as selection should be a view (not a model) aspect.
        // So for a clean solution, we should handle column selection ourself, and the model shouldn't
        // deal with selection at all.
    }

    Any SAL_CALL FmXGridPeer::getSelection(  )
    {
        VclPtr< FmGridControl > pVclControl = GetAs< FmGridControl >();
        Sequence< Any > aSelectionBookmarks = pVclControl->getSelectionBookmarks();
        return makeAny(aSelectionBookmarks);
    }

    void SAL_CALL FmXGridPeer::addSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener )
    {
        m_aSelectionListeners.addInterface( _rxListener );
    }

    void SAL_CALL FmXGridPeer::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener )
    {
        m_aSelectionListeners.removeInterface( _rxListener );
    }

    void FmXGridPeer::resetted(const EventObject& rEvent)
    {
        if (m_xColumns == rEvent.Source)
        {   // my model was reset -> refresh the grid content
            SolarMutexGuard aGuard;
            VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
            if (!pGrid)
                return;
            pGrid->resetCurrentRow();
        }
        // if the cursor fired a reset event we seem to be on the insert row
        else if (m_xCursor == rEvent.Source)
        {
            SolarMutexGuard aGuard;
            VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
            if (pGrid && pGrid->IsOpen())
                pGrid->positioned();
        }
    }

    const std::vector<DbGridControlNavigationBarState>& FmXGridPeer::getSupportedGridSlots()
    {
        static const std::vector<DbGridControlNavigationBarState> aSupported {
            DbGridControlNavigationBarState::First,
            DbGridControlNavigationBarState::Prev,
            DbGridControlNavigationBarState::Next,
            DbGridControlNavigationBarState::Last,
            DbGridControlNavigationBarState::New,
            DbGridControlNavigationBarState::Undo
        };
        return aSupported;
    }

    Sequence< css::util::URL>& FmXGridPeer::getSupportedURLs()
    {
        static Sequence< css::util::URL> aSupported;
        if (aSupported.getLength() == 0)
        {
            static const char* sSupported[] = {
                FMURL_RECORD_MOVEFIRST,
                FMURL_RECORD_MOVEPREV,
                FMURL_RECORD_MOVENEXT,
                FMURL_RECORD_MOVELAST,
                FMURL_RECORD_MOVETONEW,
                FMURL_RECORD_UNDO
            };
            aSupported.realloc(SAL_N_ELEMENTS(sSupported));
            css::util::URL* pSupported = aSupported.getArray();

            for ( sal_Int32 i = 0; i < aSupported.getLength(); ++i, ++pSupported)
                pSupported->Complete = OUString::createFromAscii(sSupported[i]);

            // let an css::util::URL-transformer normalize the URLs
            Reference< css::util::XURLTransformer >  xTransformer(
                util::URLTransformer::create(::comphelper::getProcessComponentContext()) );
            for (css::util::URL & rURL : aSupported)
                xTransformer->parseStrict(rURL);
        }

        return aSupported;
    }

    void FmXGridPeer::UpdateDispatches()
    {
        if (!m_pStateCache)
        {   // we don't have any dispatchers yet -> do the initial connect
            ConnectToDispatcher();
            return;
        }

        sal_uInt16 nDispatchersGot = 0;
        const Sequence< css::util::URL>& aSupportedURLs = getSupportedURLs();
        const css::util::URL* pSupportedURLs = aSupportedURLs.getConstArray();
        Reference< css::frame::XDispatch >  xNewDispatch;
        for (sal_Int32 i=0; i<aSupportedURLs.getLength(); ++i, ++pSupportedURLs)
        {
            xNewDispatch = queryDispatch(*pSupportedURLs, OUString(), 0);
            if (xNewDispatch != m_pDispatchers[i])
            {
                if (m_pDispatchers[i].is())
                    m_pDispatchers[i]->removeStatusListener(static_cast<css::frame::XStatusListener*>(this), *pSupportedURLs);
                m_pDispatchers[i] = xNewDispatch;
                if (m_pDispatchers[i].is())
                    m_pDispatchers[i]->addStatusListener(static_cast<css::frame::XStatusListener*>(this), *pSupportedURLs);
            }
            if (m_pDispatchers[i].is())
                ++nDispatchersGot;
        }

        if (!nDispatchersGot)
        {
            m_pStateCache.reset();
            m_pDispatchers.reset();
        }
    }

    void FmXGridPeer::ConnectToDispatcher()
    {
        DBG_ASSERT((m_pStateCache != nullptr) == (m_pDispatchers != nullptr), "FmXGridPeer::ConnectToDispatcher : inconsistent !");
        if (m_pStateCache)
        {   // already connected -> just do an update
            UpdateDispatches();
            return;
        }

        const Sequence< css::util::URL>& aSupportedURLs = getSupportedURLs();

        // _before_ adding the status listeners (as the add should result in a statusChanged-call) !
        m_pStateCache.reset(new bool[aSupportedURLs.getLength()]);
        m_pDispatchers.reset(new Reference< css::frame::XDispatch > [aSupportedURLs.getLength()]);

        sal_uInt16 nDispatchersGot = 0;
        const css::util::URL* pSupportedURLs = aSupportedURLs.getConstArray();
        for (sal_Int32 i=0; i<aSupportedURLs.getLength(); ++i, ++pSupportedURLs)
        {
            m_pStateCache[i] = false;
            m_pDispatchers[i] = queryDispatch(*pSupportedURLs, OUString(), 0);
            if (m_pDispatchers[i].is())
            {
                m_pDispatchers[i]->addStatusListener(static_cast<css::frame::XStatusListener*>(this), *pSupportedURLs);
                ++nDispatchersGot;
            }
        }

        if (!nDispatchersGot)
        {
            m_pStateCache.reset();
            m_pDispatchers.reset();
        }
    }

    void FmXGridPeer::DisConnectFromDispatcher()
    {
        if (!m_pStateCache || !m_pDispatchers)
            return;
        // we're not connected

        const Sequence< css::util::URL>& aSupportedURLs = getSupportedURLs();
        const css::util::URL* pSupportedURLs = aSupportedURLs.getConstArray();
        for (sal_Int32 i=0; i<aSupportedURLs.getLength(); ++i, ++pSupportedURLs)
        {
            if (m_pDispatchers[i].is())
                m_pDispatchers[i]->removeStatusListener(static_cast<css::frame::XStatusListener*>(this), *pSupportedURLs);
        }

        m_pStateCache.reset();
        m_pDispatchers.reset();
    }

    IMPL_LINK(FmXGridPeer, OnQueryGridSlotState, DbGridControlNavigationBarState, nSlot, int)
    {
        if (!m_pStateCache)
            return -1;  // unspecified

        // search the given slot with our supported sequence
        const std::vector<DbGridControlNavigationBarState>& aSupported = getSupportedGridSlots();
        for (size_t i=0; i<aSupported.size(); ++i)
        {
            if (aSupported[i] == nSlot)
            {
                if (!m_pDispatchers[i].is())
                    return -1;  // nothing known about this slot
                else
                    return m_pStateCache[i] ? 1 : 0;
            }
        }

        return  -1;
    }

    IMPL_LINK(FmXGridPeer, OnExecuteGridSlot, DbGridControlNavigationBarState, nSlot, bool)
    {
        if (!m_pDispatchers)
            return false;   // not handled

        Sequence< css::util::URL>& aUrls = getSupportedURLs();
        const css::util::URL* pUrls = aUrls.getConstArray();

        const std::vector<DbGridControlNavigationBarState>& aSlots = getSupportedGridSlots();

        DBG_ASSERT(static_cast<sal_Int32>(aSlots.size()) == aUrls.getLength(), "FmXGridPeer::OnExecuteGridSlot : inconsistent data returned by getSupportedURLs/getSupportedGridSlots!");

        for (size_t i=0; i<aSlots.size(); ++i, ++pUrls)
        {
            if (aSlots[i] == nSlot)
            {
                if (m_pDispatchers[i].is())
                {
                    // commit any changes done so far, if it's not the undoRecord URL
                    if ( pUrls->Complete == FMURL_RECORD_UNDO || commit() )
                        m_pDispatchers[i]->dispatch(*pUrls, Sequence< PropertyValue>());

                    return true;   // handled
                }
            }
        }

        return false;   // not handled
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V670 The uninitialized class member 'm_aMutex' is used to initialize the 'm_aModifyListeners' member. Remember that members are initialized in the order of their declarations inside a class.

↑ V670 The uninitialized class member 'm_aMutex' is used to initialize the 'm_aUpdateListeners' member. Remember that members are initialized in the order of their declarations inside a class.

↑ V670 The uninitialized class member 'm_aMutex' is used to initialize the 'm_aContainerListeners' member. Remember that members are initialized in the order of their declarations inside a class.

↑ V670 The uninitialized class member 'm_aMutex' is used to initialize the 'm_aSelectionListeners' member. Remember that members are initialized in the order of their declarations inside a class.

↑ V670 The uninitialized class member 'm_aMutex' is used to initialize the 'm_aGridControlListeners' member. Remember that members are initialized in the order of their declarations inside a class.

↑ V519 The 'mbDesignMode' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 731, 737.