/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx
Warning:	line 480, column 26 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name fmgridif.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SVXCORE_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium/public -D COMPONENT_BUILD -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/svx/sdi -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx

/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#include <sal/config.h>

22#include <string_view>

24#include <svx/fmgridif.hxx>
25#include <fmprop.hxx>
26#include <fmservs.hxx>
27#include <svx/fmtools.hxx>
28#include <fmurl.hxx>
29#include <formcontrolfactory.hxx>
30#include <gridcell.hxx>
31#include <sdbdatacolumn.hxx>
32#include <svx/fmgridcl.hxx>
33#include <tools/urlobj.hxx>

35#include <com/sun/star/awt/PosSize.hpp>
36#include <com/sun/star/beans/PropertyAttribute.hpp>
37#include <com/sun/star/form/FormComponentType.hpp>
38#include <com/sun/star/form/XFormComponent.hpp>
39#include <com/sun/star/form/XLoadable.hpp>
40#include <com/sun/star/form/XReset.hpp>
41#include <com/sun/star/lang/DisposedException.hpp>
42#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
43#include <com/sun/star/lang/NoSupportException.hpp>
44#include <com/sun/star/sdbc/ResultSetType.hpp>
45#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
46#include <com/sun/star/util/URLTransformer.hpp>
47#include <com/sun/star/util/XURLTransformer.hpp>
48#include <com/sun/star/view/XSelectionSupplier.hpp>
49#include <com/sun/star/sdbcx/XRowLocate.hpp>

51#include <comphelper/enumhelper.hxx>
52#include <comphelper/processfactory.hxx>
53#include <comphelper/property.hxx>
54#include <comphelper/sequence.hxx>
55#include <comphelper/types.hxx>
56#include <cppuhelper/supportsservice.hxx>
57#include <cppuhelper/queryinterface.hxx>
58#include <vcl/unohelp.hxx>
59#include <vcl/svapp.hxx>
60#include <tools/debug.hxx>
61#include <tools/diagnose_ex.h>
62#include <sal/macros.h>

64using namespace ::svxform;
65using namespace ::com::sun::star::container;
66using namespace ::com::sun::star::sdb;
67using namespace ::com::sun::star::sdbc;
68using namespace ::com::sun::star::uno;
69using namespace ::com::sun::star::view;
70using namespace ::com::sun::star::beans;
71using namespace ::com::sun::star::lang;
72using namespace ::com::sun::star::form;
73using namespace ::com::sun::star::util;
74using namespace ::com::sun::star;

76using ::com::sun::star::sdbcx::XColumnsSupplier;
77using ::com::sun::star::frame::XDispatchProviderInterceptor;
78using ::com::sun::star::frame::XDispatchProvider;
79using ::com::sun::star::accessibility::XAccessible;
80using ::com::sun::star::accessibility::XAccessibleContext;
81using ::com::sun::star::sdb::XRowSetSupplier;
82using ::com::sun::star::awt::XVclWindowPeer;


85static css::awt::FontDescriptor ImplCreateFontDescriptor( const vcl::Font& rFont )
86{
  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;
105}


108static vcl::Font ImplCreateFont( const css::awt::FontDescriptor& rDescr )
109{
  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;
126}

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


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

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

  return aReturn;
146}


149void FmXModifyMultiplexer::disposing(const EventObject& )
150{
151}


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

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


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

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

  return aReturn;
179}


182void FmXUpdateMultiplexer::disposing(const EventObject& )
183{
184}


187sal_Bool FmXUpdateMultiplexer::approveUpdate(const EventObject &e)
188{
  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;
201}


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

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


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

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

  return aReturn;
229}


232void FmXSelectionMultiplexer::disposing(const EventObject& )
233{
234}


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

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


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

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

  return aReturn;
262}


265void FmXContainerMultiplexer::disposing(const EventObject& )
266{
267}

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


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


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

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


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

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

  return aReturn;
309}


312void FmXGridControlMultiplexer::disposing( const EventObject& )
313{
314}


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


325//= FmXGridControl


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

333FmXGridControl::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)
342{
343}


346FmXGridControl::~FmXGridControl()
347{
348}


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

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


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


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

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

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

383css::uno::Sequence<OUString> SAL_CALL FmXGridControl::getSupportedServiceNames()
384{
  return { FM_SUN_CONTROL_GRIDCONTROL"com.sun.star.form.control.GridControl", "com.sun.star.awt.UnoControl" };
386}


389void SAL_CALL FmXGridControl::dispose()
390{
  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();
400}


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


409sal_Bool SAL_CALL FmXGridControl::setModel(const Reference< css::awt::XControlModel >& rModel)
410{
  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;
423}


426FmXGridPeer* FmXGridControl::imp_CreatePeer(vcl::Window* pParent)
427{
  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"Border")))
              nStyle |= WB_BORDER;
      }
      catch(const Exception&)
      {
          OSL_FAIL("Can not get style")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "442" ": "), "%s", "Can not get style"); } } while (false
);
      }
  }

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


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

  DBG_ASSERT(/*(0 == m_nPeerCreationLevel) && */!mbCreatingPeer, "FmXGridControl::createPeer : recursion!")do { if (true && (!(!mbCreatingPeer))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "456" ": "), "%s", "FmXGridControl::createPeer : recursion!"
); } } while (false);
2
←
Assuming field 'mbCreatingPeer' is false→
3
←
Taking false branch→
4
←
Loop condition is false.  Exiting loop→
      // 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())
5
←
Taking false branch→
      return;

  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())
6
←
Taking true branch→
  {
      VCLXWindow* pParent = comphelper::getUnoTunnelImplementation<VCLXWindow>(rParentPeer);
      if (pParent)
7
←
Assuming 'pParent' is non-null→
8
←
Taking true branch→
          pParentWin = pParent->GetWindow().get();
9
←
Calling 'VCLXWindow::GetWindow'→
18
←
Returning from 'VCLXWindow::GetWindow'→
19
←
Calling implicit destructor for 'VclPtr<vcl::Window>'→
20
←
Calling '~Reference'→
27
←
Returning from '~Reference'→
28
←
Returning from destructor for 'VclPtr<vcl::Window>'→
  }

  FmXGridPeer* pPeer = imp_CreatePeer(pParentWin);
29
←
Use of memory after it is freed
  DBG_ASSERT(pPeer != nullptr, "FmXGridControl::createPeer : imp_CreatePeer didn't return a peer !")do { if (true && (!(pPeer != nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "481" ": "), "%s", "FmXGridControl::createPeer : imp_CreatePeer didn't return a peer !"
); } } while (false);
  setPeer( pPeer );

  // reading the properties from the model
485//      ++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.
495//      if (--m_nPeerCreationLevel == 0)
  {
      DBG_ASSERT(getPeer().is(), "FmXGridControl::createPeer : something went wrong ... no top level peer !")do { if (true && (!(getPeer().is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "497" ": "), "%s", "FmXGridControl::createPeer : something went wrong ... no top level peer !"
); } } while (false);
      pPeer = comphelper::getUnoTunnelImplementation<FmXGridPeer>(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 a 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_THROW)->getCount())
                  {
                      // we get only a new bookmark if the resultset is not forwardonly
                      if (::comphelper::getINT32(Reference< XPropertySet > (xForm, UNO_QUERY_THROW)->getPropertyValue(FM_PROP_RESULTSET_TYPE"ResultSetType")) != 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
                          if ( !xForm->isBeforeFirst() && !xForm->isAfterLast() )
                          {
                              try
                              {
                                  aOldCursorBookmark = Reference< css::sdbcx::XRowLocate > (xForm, UNO_QUERY_THROW)->getBookmark();
                              }
                              catch( const Exception& )
                              {
                                  DBG_UNHANDLED_EXCEPTION("svx")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "572" ": ", "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")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "594" ": ", "svx" );;
      }

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


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


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


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


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


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


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

  return Sequence<sal_Bool>();
664}


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

  return Sequence< Any>();
677}


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


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


700void SAL_CALL FmXGridControl::setDesignMode(sal_Bool bOn)
701{
  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);
              }
          }

          // Avoid infinite recursion when calling XVclWindowPeer::setDesignMode below
          mbDesignMode = bOn;

          Reference< XVclWindowPeer >  xVclWindowPeer( getPeer(), UNO_QUERY );
          if (xVclWindowPeer.is())
              xVclWindowPeer->setDesignMode(bOn);
      }
      else
      {
          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 ? std::u16string_view( u"design" ) : std::u16string_view( u"alive" );
  }

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

754// XBoundComponent

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


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


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

787// XContainer

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


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


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


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


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


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


847void SAL_CALL FmXGridControl::addGridControlListener( const Reference< XGridControlListener >& _listener )
848{
  ::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 );
  }
858}


861void SAL_CALL FmXGridControl::removeGridControlListener( const Reference< XGridControlListener >& _listener )
862{
  ::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 );
873}


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


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

893// XElementAccess

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


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

907// XEnumerationAccess

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

918// XIndexAccess

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


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

  return xPeer->getByIndex(_nIndex);
934}

936// css::util::XModeSelector

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

  xPeer->setMode(Mode);
945}


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


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


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

968void SAL_CALL FmXGridControl::setFocus()
969{
  FmXGridPeer* pPeer = comphelper::getUnoTunnelImplementation<FmXGridPeer>(getPeer());
  if (pPeer)
  {
      VclPtr<FmGridControl> xGrid = pPeer->GetAs<FmGridControl>();
      bool bAlreadyHasFocus = xGrid->HasChildPathFocus() || xGrid->ControlHasFocus();
      // if the focus is already in the control don't grab focus again which
      // would grab focus away from any native widgets hosted in the control
      if (bAlreadyHasFocus)
          return;
  }
  UnoControl::setFocus();
981}

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

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

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


999FmXGridPeer::GridListenerDelegator::GridListenerDelegator(FmXGridPeer* _pPeer)
  :m_pPeer(_pPeer)
1001{
  DBG_ASSERT(m_pPeer, "GridListenerDelegator::GridListenerDelegator")do { if (true && (!(m_pPeer))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1002" ": "), "%s", "GridListenerDelegator::GridListenerDelegator"
); } } while (false);
1003}

1005FmXGridPeer::GridListenerDelegator::~GridListenerDelegator()
1006{
1007}


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


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

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


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


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


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


1058void FmXGridPeer::Create(vcl::Window* pParent, WinBits nStyle)
1059{
  VclPtr<FmGridControl> pWin = imp_CreateControl(pParent, nStyle);
  DBG_ASSERT(pWin != nullptr, "FmXGridPeer::Create : imp_CreateControl didn't return a control !")do { if (true && (!(pWin != nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1061" ": "), "%s", "FmXGridPeer::Create : imp_CreateControl didn't return a control !"
); } } while (false);

  pWin->SetStateProvider(LINK(this, FmXGridPeer, OnQueryGridSlotState)::tools::detail::makeLink( ::tools::detail::castTo<FmXGridPeer
 *>(this), &FmXGridPeer::LinkStubOnQueryGridSlotState));
  pWin->SetSlotExecutor(LINK(this, FmXGridPeer, OnExecuteGridSlot)::tools::detail::makeLink( ::tools::detail::castTo<FmXGridPeer
 *>(this), &FmXGridPeer::LinkStubOnExecuteGridSlot));

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

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

  getSupportedURLs();
1074}

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

1082UNO3_GETIMPLEMENTATION2_IMPL(FmXGridPeer, VCLXWindow)namespace { class theFmXGridPeerUnoTunnelId : public rtl::Static
< UnoTunnelIdInit, theFmXGridPeerUnoTunnelId> {}; } const
 css::uno::Sequence< sal_Int8 > & FmXGridPeer::getUnoTunnelId
() throw() { return theFmXGridPeerUnoTunnelId::get().getSeq()
; }sal_Int64 FmXGridPeer::getSomething( const css::uno::Sequence
< sal_Int8 >& rId ) { if( isUnoTunnelId<FmXGridPeer
>(rId) ) { return sal::static_int_cast<sal_Int64>(reinterpret_cast
<sal_IntPtr>(this)); } else { return VCLXWindow::getSomething
( rId ); } };

1084// XEventListener

1086void FmXGridPeer::disposing(const EventObject& e)
1087{
  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);
1124}


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


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


1139#define LAST_KNOWN_TYPEFormComponentType::PATTERNFIELD     FormComponentType::PATTERNFIELD
1140Sequence< sal_Bool > SAL_CALL FmXGridPeer::queryFieldDataType( const Type& xType )
1141{
  // a 'conversion table'
  static const bool bCanConvert[LAST_KNOWN_TYPEFormComponentType::PATTERNFIELD][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 !")do { if (true && (!(nModelPos != sal_uInt16(-1)))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1208" ": "), "%s", "FmXGridPeer::queryFieldDataType : no model pos !"
); } } while (false);

      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"ClassId", xCurrentColumn))
          continue;

      sal_Int16 nClassId = sal_Int16();
      xCurrentColumn->getPropertyValue(FM_PROP_CLASSID"ClassId") >>= nClassId;
      if (nClassId>LAST_KNOWN_TYPEFormComponentType::PATTERNFIELD)
          continue;
      DBG_ASSERT(nClassId>0, "FmXGridPeer::queryFieldDataType : somebody changed the definition of the FormComponentType enum !")do { if (true && (!(nClassId>0))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1226" ": "), "%s", "FmXGridPeer::queryFieldDataType : somebody changed the definition of the FormComponentType enum !"
); } } while (false);

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

  return aReturnSequence;
1233}


1236Sequence< Any > SAL_CALL FmXGridPeer::queryFieldData( sal_Int32 nRow, const Type& xType )
1237{
  VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
  DBG_ASSERT(pGrid && pGrid->IsOpen(), "FmXGridPeer::queryFieldData : have no valid grid window !")do { if (true && (!(pGrid && pGrid->IsOpen
()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1239" ": "), "%s", "FmXGridPeer::queryFieldData : have no valid grid window !"
); } } while (false);
  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" )if( !(xPaintRow.is()) ){ do { if (true && (!(xPaintRow
.is()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1252" ": "), "%s", "invalid paint row"); } } while (false
); throw css::uno::RuntimeException( __func__ + OUStringLiteral
(u",\n" "invalid paint row"), css::uno::Reference< css::uno
::XInterface >() ); };

  // 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 !")do { if (true && (!(nModelPos != sal_uInt16(-1)))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1268" ": "), "%s", "FmXGridPeer::queryFieldData : invalid model pos !"
); } } while (false);

      // 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"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] <<= 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;
1312}


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

1322// XPropertyChangeListener

1324void FmXGridPeer::propertyChange(const PropertyChangeEvent& evt)
1325{
  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"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"Label")
      {
          OUString aName = ::comphelper::getString(evt.NewValue);
          if (aName != pGrid->GetColumnTitle(nId))
              pGrid->SetColumnTitle(nId, aName);
      }
      else if (evt.PropertyName == FM_PROP_WIDTH"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"Hidden")
      {
          DBG_ASSERT(evt.NewValue.getValueType().getTypeClass() == TypeClass_BOOLEAN,do { if (true && (!(evt.NewValue.getValueType().getTypeClass
() == TypeClass_BOOLEAN))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1393" ": "), "%s", "FmXGridPeer::propertyChange : the property 'hidden' should be of type boolean !"
); } } while (false)
              "FmXGridPeer::propertyChange : the property 'hidden' should be of type boolean !")do { if (true && (!(evt.NewValue.getValueType().getTypeClass
() == TypeClass_BOOLEAN))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1393" ": "), "%s", "FmXGridPeer::propertyChange : the property 'hidden' should be of type boolean !"
); } } while (false);
          if (::comphelper::getBOOL(evt.NewValue))
              pGrid->HideColumn(nId);
          else
              pGrid->ShowColumn(nId);
      }
      else if (evt.PropertyName == FM_PROP_ALIGN"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"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();
      }
  }
1432}

1434// XBoundComponent

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


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


1448sal_Bool FmXGridPeer::commit()
1449{
  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;
1467}


1470void FmXGridPeer::cursorMoved(const EventObject& _rEvent)
1471{
  VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
  // we are not interested in moving to insert row only in the reset event
  // which is fired after positioning and the insert row
  if (pGrid && pGrid->IsOpen() && !::comphelper::getBOOL(Reference< XPropertySet > (_rEvent.Source, UNO_QUERY_THROW)->getPropertyValue(FM_PROP_ISNEW"IsNew")))
      pGrid->positioned();
1477}


1480void FmXGridPeer::rowChanged(const EventObject& /*_rEvent*/)
1481{
  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();
  }
1490}


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

1499// XLoadListener

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


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


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


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


1527void FmXGridPeer::reloaded(const EventObject& aEvent)
1528{
  {
      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);
1541}

1543// XGridPeer

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


1551void FmXGridPeer::addColumnListeners(const Reference< XPropertySet >& xCol)
1552{
  static const std::u16string_view aPropsListenedTo[] =
  {
      u"" FM_PROP_LABEL"Label", u"" FM_PROP_WIDTH"Width", u"" FM_PROP_HIDDEN"Hidden", u"" FM_PROP_ALIGN"Align",
      u"" FM_PROP_FORMATKEY"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 (size_t i=0; i<SAL_N_ELEMENTS(aPropsListenedTo)(sizeof(sal_n_array_size(aPropsListenedTo))); ++i)
  {
      if ( xInfo->hasPropertyByName( aPropsListenedTo[i] ) )
      {
          Property aPropDesc = xInfo->getPropertyByName( aPropsListenedTo[i] );
          if ( 0 != ( aPropDesc.Attributes & PropertyAttribute::BOUND ) )
              xCol->addPropertyChangeListener( aPropsListenedTo[i], this );
      }
  }
1571}


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

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


1591void FmXGridPeer::setColumns(const Reference< XIndexContainer >& Columns)
1592{
  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);
      }
  }
1645}


1648void FmXGridPeer::setDesignMode(sal_Bool bOn)
1649{
  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
1661}


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


1674void FmXGridPeer::elementInserted(const ContainerEvent& evt)
1675{
  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"Label"));
  Any aWidth = xNewColumn->getPropertyValue(FM_PROP_WIDTH"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"Hidden");
  if (::comphelper::getBOOL(aHidden))
      pGrid->HideColumn(pCol->GetId());

  FormControlFactory( m_xContext ).initializeTextFieldLineEnds( xNewColumn );
1703}


1706void FmXGridPeer::elementReplaced(const ContainerEvent& evt)
1707{
  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"Label"));
  Any aWidth = xNewColumn->getPropertyValue(FM_PROP_WIDTH"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();
1758}


1761void FmXGridPeer::elementRemoved(const ContainerEvent& evt)
1762{
  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);
1775}


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

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

  bool bVoid = !Value.hasValue();

  if ( PropertyName == FM_PROP_TEXTLINECOLOR"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"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"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"HelpURL" )
  {
      OUString sHelpURL;
      OSL_VERIFY( Value >>= sHelpURL )do { if (!(Value >>= sHelpURL)) do { if (true &&
 (!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1834" ": "), "OSL_ASSERT: %s", "0"); } } while (false);
 } while (0);
      INetURLObject aHID( sHelpURL );
      if ( aHID.GetProtocol() == INetProtocol::Hid )
          sHelpURL = aHID.GetURLPath();
      pGrid->SetHelpId( OUStringToOString( sHelpURL, RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76)) ) );
  }
  else if ( PropertyName == FM_PROP_DISPLAYSYNCHRON"DisplayIsSynchron" )
  {
      pGrid->setDisplaySynchron(::comphelper::getBOOL(Value));
  }
  else if ( PropertyName == FM_PROP_CURSORCOLOR"CursorColor" )
  {
      if (bVoid)
          pGrid->SetCursorColor(COL_TRANSPARENT);
      else
          pGrid->SetCursorColor( ::Color(::comphelper::getINT32(Value)));
      if (isDesignMode())
          pGrid->Invalidate();
  }
  else if ( PropertyName == FM_PROP_ALWAYSSHOWCURSOR"AlwaysShowCursor" )
  {
      pGrid->EnablePermanentCursor(::comphelper::getBOOL(Value));
      if (isDesignMode())
          pGrid->Invalidate();
  }
  else if ( PropertyName == FM_PROP_FONT"FontDescriptor" )
  {
      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"RowHeight", xModelSet))
              {
                  Any aHeight = xModelSet->getPropertyValue(FM_PROP_ROWHEIGHT"RowHeight");
                  if (!aHeight.hasValue())
                      pGrid->SetDataRowHeight(0);
              }

          }
      }
  }
  else if ( PropertyName == FM_PROP_BACKGROUNDCOLOR"BackgroundColor" )
  {
      if ( bVoid )
      {
          pGrid->SetControlBackground();
      }
      else
      {
          ::Color aColor( ::comphelper::getINT32(Value) );
          pGrid->SetBackground( aColor );
          pGrid->SetControlBackground( aColor );
      }
  }
  else if ( PropertyName == FM_PROP_TEXTCOLOR"TextColor" )
  {
      if ( bVoid )
      {
          pGrid->SetControlForeground();
      }
      else
      {
          ::Color aColor( ::comphelper::getINT32(Value) );
          pGrid->SetTextColor( aColor );
          pGrid->SetControlForeground( aColor );
      }
  }
  else if ( PropertyName == FM_PROP_ROWHEIGHT"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"HasNavigationBar" )
  {
      bool bValue( true );
      OSL_VERIFY( Value >>= bValue )do { if (!(Value >>= bValue)) do { if (true && (
!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1935" ": "), "OSL_ASSERT: %s", "0"); } } while (false);
 } while (0);
      pGrid->EnableNavigationBar( bValue );
  }
  else if ( PropertyName == FM_PROP_RECORDMARKER"HasRecordMarker" )
  {
      bool bValue( true );
      OSL_VERIFY( Value >>= bValue )do { if (!(Value >>= bValue)) do { if (true && (
!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1941" ": "), "OSL_ASSERT: %s", "0"); } } while (false);
 } while (0);
      pGrid->EnableHandle( bValue );
  }
  else if ( PropertyName == FM_PROP_ENABLED"Enabled" )
  {
      bool bValue( true );
      OSL_VERIFY( Value >>= bValue )do { if (!(Value >>= bValue)) do { if (true && (
!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "1947" ": "), "OSL_ASSERT: %s", "0"); } } while (false);
 } while (0);

      // 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 );
1958}


1961Reference< XAccessibleContext > FmXGridPeer::CreateAccessibleContext()
1962{
  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;
1987}


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

      if ( _rPropertyName == FM_PROP_NAME"Name" )
      {
          vcl::Font aFont = pDataWindow->GetControlFont();
          aProp <<= ImplCreateFontDescriptor( aFont );
      }
      else if ( _rPropertyName == FM_PROP_TEXTCOLOR"TextColor" )
      {
          aProp <<= pDataWindow->GetControlForeground();
      }
      else if ( _rPropertyName == FM_PROP_BACKGROUNDCOLOR"BackgroundColor" )
      {
          aProp <<= pDataWindow->GetControlBackground();
      }
      else if ( _rPropertyName == FM_PROP_ROWHEIGHT"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"HasNavigationBar" )
      {
          bool bHasNavBar = pGrid->HasNavigationBar();
          aProp <<= bHasNavBar;
      }
      else if ( _rPropertyName == FM_PROP_RECORDMARKER"HasRecordMarker" )
      {
          bool bHasHandle = pGrid->HasHandle();
          aProp <<= bHasHandle;
      }
      else if ( _rPropertyName == FM_PROP_ENABLED"Enabled" )
      {
          aProp <<= pDataWindow->IsEnabled();
      }
      else
          aProp = VCLXWindow::getProperty( _rPropertyName );
  }
  return aProp;
2036}


2039void FmXGridPeer::dispose()
2040{
  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 > ());
2067}

2069// XContainer

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

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

2081// css::data::XDatabaseCursorSupplier

2083void FmXGridPeer::startCursorListening()
2084{
  if (!m_nCursorListening)
  {
      if (m_xCursor.is())
          m_xCursor->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"IsModified", this);
          xSet->addPropertyChangeListener(FM_PROP_ROWCOUNT"RowCount", this);
      }
  }
  m_nCursorListening++;
2103}


2106void FmXGridPeer::stopCursorListening()
2107{
  if (--m_nCursorListening)
      return;

  if (m_xCursor.is())
      m_xCursor->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"IsModified", this);
      xSet->removePropertyChangeListener(FM_PROP_ROWCOUNT"RowCount", this);
  }
2124}


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


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


2141void FmXGridPeer::setRowSet(const Reference< XRowSet >& _rDatabaseCursor)
2142{
  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)
      return;

  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);
  }
2175}


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


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


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


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


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

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

  Reference< css::view::XSelectionSupplier >  xSelSupplier(evt.Source, UNO_QUERY);
  Any aSelection = xSelSupplier->getSelection();
  DBG_ASSERT(aSelection.getValueType().getTypeClass() == TypeClass_INTERFACE, "FmXGridPeer::selectionChanged : invalid selection !")do { if (true && (!(aSelection.getValueType().getTypeClass
() == TypeClass_INTERFACE))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "2215" ": "), "%s", "FmXGridPeer::selectionChanged : invalid selection !"
); } } while (false);
  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(32767 *2 +1));
2250}

2252// XElementAccess

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


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

2265// XEnumerationAccess

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

2272// XIndexAccess

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


2284Any FmXGridPeer::getByIndex(sal_Int32 _nIndex)
2285{
  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((sal_uInt16) 0xFFFF) )
      return aElement;

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

  return aElement;
2305}

2307// css::util::XModeSelector

2309void FmXGridPeer::setMode(const OUString& Mode)
2310{
  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);
  }
2327}


2330OUString FmXGridPeer::getMode()
2331{
  return m_aMode;
2333}


2336css::uno::Sequence<OUString> FmXGridPeer::getSupportedModes()
2337{
  static css::uno::Sequence<OUString> const aModes
  {
      "DataMode",
      "FilterMode"
  };
  return aModes;
2344}


2347sal_Bool FmXGridPeer::supportsMode(const OUString& Mode)
2348{
  css::uno::Sequence<OUString> aModes(getSupportedModes());
  return comphelper::findValue(aModes, Mode) != -1;
2351}


2354void FmXGridPeer::columnVisible(DbGridColumn const * pColumn)
2355{
  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 );
2366}


2369void FmXGridPeer::columnHidden(DbGridColumn const * pColumn)
2370{
  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 );
2381}


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

  VCLXWindow::draw(x, y);

  pGrid->SetBrowserFlags(nOldFlags);
2393}


2396Reference< css::frame::XDispatch >  FmXGridPeer::queryDispatch(const css::util::URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags)
2397{
  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;
2412}


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

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


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

  if (m_xFirstDispatchInterceptor.is())
  {
      // there is already an interceptor; the new one will become its master
      _xInterceptor->setSlaveDispatchProvider(m_xFirstDispatchInterceptor);
      m_xFirstDispatchInterceptor->setMasterDispatchProvider(m_xFirstDispatchInterceptor);
  }
  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();
2450}


2453void FmXGridPeer::releaseDispatchProviderInterceptor(const Reference< css::frame::XDispatchProviderInterceptor >& _xInterceptor)
2454{
  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();
2504}


2507void FmXGridPeer::statusChanged(const css::frame::FeatureStateEvent& Event)
2508{
  DBG_ASSERT(m_pStateCache, "FmXGridPeer::statusChanged : invalid call !")do { if (true && (!(m_pStateCache))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "2509" ": "), "%s", "FmXGridPeer::statusChanged : invalid call !"
); } } while (false);
  DBG_ASSERT(m_pDispatchers, "FmXGridPeer::statusChanged : invalid call !")do { if (true && (!(m_pDispatchers))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "2510" ": "), "%s", "FmXGridPeer::statusChanged : invalid call !"
); } } while (false);

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

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

  auto pUrl = std::find_if(aUrls.begin(), aUrls.end(),
      [&Event](const css::util::URL& rUrl) { return rUrl.Main == Event.FeatureURL.Main; });
  if (pUrl != aUrls.end())
  {
      auto i = static_cast<sal_uInt32>(std::distance(aUrls.begin(), pUrl));
      DBG_ASSERT(m_pDispatchers[i] == Event.Source, "FmXGridPeer::statusChanged : the event source is a little bit suspect !")do { if (true && (!(m_pDispatchers[i] == Event.Source
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "2521" ": "), "%s", "FmXGridPeer::statusChanged : the event source is a little bit suspect !"
); } } while (false);
      m_pStateCache[i] = Event.IsEnabled;
      VclPtr< FmGridControl > pGrid = GetAs< FmGridControl >();
      if (aSlots[i] != DbGridControlNavigationBarState::Undo)
          pGrid->GetNavigationBar().InvalidateState(aSlots[i]);
  }
  DBG_ASSERT(pUrl != aUrls.end(), "FmXGridPeer::statusChanged : got a call for an unknown url !")do { if (true && (!(pUrl != aUrls.end()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "2527" ": "), "%s", "FmXGridPeer::statusChanged : got a call for an unknown url !"
); } } while (false);
2528}


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


2537sal_Bool SAL_CALL FmXGridPeer::select( const Any& _rSelection )
2538{
  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.
2551}


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


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


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


2574void FmXGridPeer::resetted(const EventObject& rEvent)
2575{
  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();
  }
2592}


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


2609Sequence< css::util::URL>& FmXGridPeer::getSupportedURLs()
2610{
  static Sequence< css::util::URL> aSupported = [&]()
  {
      static const char* sSupported[] = {
          FMURL_RECORD_MOVEFIRST".uno:FormController/moveToFirst",
          FMURL_RECORD_MOVEPREV".uno:FormController/moveToPrev",
          FMURL_RECORD_MOVENEXT".uno:FormController/moveToNext",
          FMURL_RECORD_MOVELAST".uno:FormController/moveToLast",
          FMURL_RECORD_MOVETONEW".uno:FormController/moveToNew",
          FMURL_RECORD_UNDO".uno:FormController/undoRecord"
      };
      Sequence< css::util::URL> tmp(SAL_N_ELEMENTS(sSupported)(sizeof(sal_n_array_size(sSupported))));
      css::util::URL* pSupported = tmp.getArray();

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

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

  return aSupported;
2636}


2639void FmXGridPeer::UpdateDispatches()
2640{
  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();
  }
2671}


2674void FmXGridPeer::ConnectToDispatcher()
2675{
  DBG_ASSERT((m_pStateCache != nullptr) == (m_pDispatchers != nullptr), "FmXGridPeer::ConnectToDispatcher : inconsistent !")do { if (true && (!((m_pStateCache != nullptr) == (m_pDispatchers
 != nullptr)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "2676" ": "), "%s", "FmXGridPeer::ConnectToDispatcher : inconsistent !"
); } } while (false);
  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();
  }
2707}


2710void FmXGridPeer::DisConnectFromDispatcher()
2711{
  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();
2726}


2729IMPL_LINK(FmXGridPeer, OnQueryGridSlotState, DbGridControlNavigationBarState, nSlot, int)int FmXGridPeer::LinkStubOnQueryGridSlotState(void * instance
, DbGridControlNavigationBarState data) { return static_cast<
FmXGridPeer *>(instance)->OnQueryGridSlotState(data); }
 int FmXGridPeer::OnQueryGridSlotState(DbGridControlNavigationBarState
 nSlot)
2730{
  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;
2748}


2751IMPL_LINK(FmXGridPeer, OnExecuteGridSlot, DbGridControlNavigationBarState, nSlot, bool)bool FmXGridPeer::LinkStubOnExecuteGridSlot(void * instance, DbGridControlNavigationBarState
 data) { return static_cast<FmXGridPeer *>(instance)->
OnExecuteGridSlot(data); } bool FmXGridPeer::OnExecuteGridSlot
(DbGridControlNavigationBarState nSlot)
2752{
  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!")do { if (true && (!(static_cast<sal_Int32>(aSlots
.size()) == aUrls.getLength()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/fmcomp/fmgridif.cxx"
 ":" "2761" ": "), "%s", "FmXGridPeer::OnExecuteGridSlot : inconsistent data returned by getSupportedURLs/getSupportedGridSlots!"
); } } while (false);

  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".uno:FormController/undoRecord" || commit() )
                  m_pDispatchers[i]->dispatch(*pUrls, Sequence< PropertyValue>());

              return true;   // handled
          }
      }
  }

  return false;   // not handled
2779}

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

←

/home/maarten/src/libreoffice/core/include/toolkit/awt/vclxwindow.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_TOOLKIT_AWT_VCLXWINDOW_HXX
21#define INCLUDED_TOOLKIT_AWT_VCLXWINDOW_HXX

23#include <toolkit/dllapi.h>
24#include <toolkit/awt/vclxdevice.hxx>
25#include <vcl/window.hxx>

27#include <com/sun/star/awt/XWindow2.hpp>
28#include <com/sun/star/awt/XVclWindowPeer.hpp>
29#include <com/sun/star/awt/XLayoutConstrains.hpp>
30#include <com/sun/star/awt/XView.hpp>
31#include <com/sun/star/beans/XPropertySetInfo.hpp>
32#include <com/sun/star/accessibility/XAccessible.hpp>
33#include <com/sun/star/awt/XDockableWindow.hpp>
34#include <com/sun/star/awt/XStyleSettingsSupplier.hpp>

36#include <comphelper/servicehelper.hxx>
37#include <cppuhelper/implbase.hxx>

39#include <tools/gen.hxx>
40#include <tools/link.hxx>

42#include <memory>
43#include <vector>
44#include <functional>

46namespace comphelper { class OInterfaceContainerHelper2; }
47namespace com::sun::star::accessibility { class XAccessibleContext; }

49class VclWindowEvent;

51namespace toolkit
52{
  class IAccessibleFactory;
54}


57class UnoPropertyArrayHelper;
58class VCLXWindowImpl;
59typedef cppu::ImplInheritanceHelper< VCLXDevice,
                                   css::awt::XWindow2,
                                   css::awt::XVclWindowPeer,
                                   css::awt::XLayoutConstrains,
                                   css::awt::XView,
                                   css::awt::XDockableWindow,
                                   css::accessibility::XAccessible,
                                   css::lang::XEventListener,
                                   css::beans::XPropertySetInfo,
                                   css::awt::XStyleSettingsSupplier
                                 > VCLXWindow_Base;

71class TOOLKIT_DLLPUBLIC__attribute__ ((visibility("default"))) VCLXWindow : public VCLXWindow_Base
72{
73private:
  std::unique_ptr<VCLXWindowImpl>  mpImpl;

  UnoPropertyArrayHelper *GetPropHelper();

78protected:
  Size            ImplCalcWindowSize( const Size& rOutSz ) const;
  DECL_LINK(WindowEventListener, VclWindowEvent&, void )static void LinkStubWindowEventListener(void *, VclWindowEvent
&); void WindowEventListener(VclWindowEvent&);

  virtual void    ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent );
  virtual css::uno::Reference< css::accessibility::XAccessibleContext >
                  CreateAccessibleContext();

  void            SetSynthesizingVCLEvent( bool b );
  bool            IsSynthesizingVCLEvent() const;

  void        SetSystemParent_Impl( const css::uno::Any& rHandle );

  ::toolkit::IAccessibleFactory&  getAccessibleFactory();

  // helper ...
  static void     PushPropertyIds( std::vector< sal_uInt16 > &aIds, int nFirstId, ...);
  // for use in controls/
  static void     ImplGetPropertyIds( std::vector< sal_uInt16 > &aIds,
                                      bool bWithDefaults = false );
  virtual void    GetPropertyIds( std::vector< sal_uInt16 > &aIds );

  ::comphelper::OInterfaceContainerHelper2&  GetContainerListeners();
  ::comphelper::OInterfaceContainerHelper2&  GetTopWindowListeners();

103public:
  typedef ::std::function<void ()>  Callback;

106protected:
  /** executes the given callback asynchronously

      At the moment the callback is called, the Solar Mutex is not locked. In particular, this implies that
      you cannot rely on |this| not being disposed. However, you *can* rely on |this| being still alive (i.e.
      having a ref count > 0).

      As a consequence, this can be used for doing listener notifications, using event multiplexers. Those multiplexers
      care for the disposed state themself, and are alive as long as |this| is alive.
  */
  void    ImplExecuteAsyncWithoutSolarLock(
              const Callback& i_callback
          );

120public:
  VCLXWindow( bool bWithDefaultProps = false );
  virtual ~VCLXWindow() override;

  virtual void SetWindow( const VclPtr< vcl::Window > &pWindow );
  template< class derived_type > VclPtr< derived_type > GetAs() const {
      return VclPtr< derived_type >( static_cast< derived_type * >( GetOutputDevice().get() ) ); }
11
←
Calling constructor for 'VclPtr<vcl::Window>'→
16
←
Returning from constructor for 'VclPtr<vcl::Window>'→
  template< class derived_type > VclPtr< derived_type > GetAsDynamic() const {
      return VclPtr< derived_type >( dynamic_cast< derived_type * >( GetOutputDevice().get() ) ); }
  VclPtr<vcl::Window> GetWindow() const { return GetAs<vcl::Window>(); }
10
←
Calling 'VCLXWindow::GetAs'→
17
←
Returning from 'VCLXWindow::GetAs'→

  void    suspendVclEventListening( );
  void    resumeVclEventListening( );

  void    notifyWindowRemoved( vcl::Window const & _rWindow );

  // css::lang::XUnoTunnel
  UNO3_GETIMPLEMENTATION_DECL(VCLXWindow)static const css::uno::Sequence< sal_Int8 > & getUnoTunnelId
() throw(); virtual sal_Int64 getSomething( const css::uno::Sequence
< sal_Int8 >& aIdentifier ) override;

  // css::lang::XEventListener
  virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;

  // css::lang::XComponent
  void SAL_CALL dispose(  ) override;
  void SAL_CALL addEventListener( const css::uno::Reference< css::lang::XEventListener >& rxListener ) override;
  void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener >& rxListener ) override;

  // css::awt::XWindow
  void SAL_CALL setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, sal_Int16 Flags ) override;
  css::awt::Rectangle SAL_CALL getPosSize(  ) override;
  void SAL_CALL setVisible( sal_Bool Visible ) override;
  void SAL_CALL setEnable( sal_Bool Enable ) override;
  void SAL_CALL setFocus(  ) override;
  void SAL_CALL addWindowListener( const css::uno::Reference< css::awt::XWindowListener >& rrxListener ) override;
  void SAL_CALL removeWindowListener( const css::uno::Reference< css::awt::XWindowListener >& rrxListener ) override;
  void SAL_CALL addFocusListener( const css::uno::Reference< css::awt::XFocusListener >& rrxListener ) override;
  void SAL_CALL removeFocusListener( const css::uno::Reference< css::awt::XFocusListener >& rrxListener ) override;
  void SAL_CALL addKeyListener( const css::uno::Reference< css::awt::XKeyListener >& rrxListener ) override;
  void SAL_CALL removeKeyListener( const css::uno::Reference< css::awt::XKeyListener >& rrxListener ) override;
  void SAL_CALL addMouseListener( const css::uno::Reference< css::awt::XMouseListener >& rrxListener ) override;
  void SAL_CALL removeMouseListener( const css::uno::Reference< css::awt::XMouseListener >& rrxListener ) override;
  void SAL_CALL addMouseMotionListener( const css::uno::Reference< css::awt::XMouseMotionListener >& rrxListener ) override;
  void SAL_CALL removeMouseMotionListener( const css::uno::Reference< css::awt::XMouseMotionListener >& rrxListener ) override;
  void SAL_CALL addPaintListener( const css::uno::Reference< css::awt::XPaintListener >& rrxListener ) override;
  void SAL_CALL removePaintListener( const css::uno::Reference< css::awt::XPaintListener >& rrxListener ) override;

  // css::awt::XWindowPeer
  css::uno::Reference< css::awt::XToolkit > SAL_CALL getToolkit(  ) override;
  void SAL_CALL setPointer( const css::uno::Reference< css::awt::XPointer >& Pointer ) override;
  void SAL_CALL setBackground( sal_Int32 Color ) override;
  void SAL_CALL invalidate( sal_Int16 Flags ) override;
  void SAL_CALL invalidateRect( const css::awt::Rectangle& Rect, sal_Int16 Flags ) override;

  // css::awt::XVclWindowPeer
  sal_Bool SAL_CALL isChild( const css::uno::Reference< css::awt::XWindowPeer >& Peer ) override;
  void SAL_CALL setDesignMode( sal_Bool bOn ) override;
  sal_Bool SAL_CALL isDesignMode(  ) override;
  void SAL_CALL enableClipSiblings( sal_Bool bClip ) override;
  void SAL_CALL setForeground( sal_Int32 Color ) override;
  void SAL_CALL setControlFont( const css::awt::FontDescriptor& aFont ) override;
  void SAL_CALL getStyles( sal_Int16 nType, css::awt::FontDescriptor& Font, sal_Int32& ForegroundColor, sal_Int32& BackgroundColor ) override;
  void SAL_CALL setProperty( const OUString& PropertyName, const css::uno::Any& Value ) override;
  css::uno::Any SAL_CALL getProperty( const OUString& PropertyName ) override;

  // css::awt::XLayoutConstrains
  css::awt::Size SAL_CALL getMinimumSize(  ) override;
  css::awt::Size SAL_CALL getPreferredSize(  ) override;
  css::awt::Size SAL_CALL calcAdjustedSize( const css::awt::Size& aNewSize ) override;

  // css::awt::XView
  sal_Bool SAL_CALL setGraphics( const css::uno::Reference< css::awt::XGraphics >& aDevice ) override;
  css::uno::Reference< css::awt::XGraphics > SAL_CALL getGraphics(  ) override;
  css::awt::Size SAL_CALL getSize(  ) override;
  void SAL_CALL draw( sal_Int32 nX, sal_Int32 nY ) override;
  void SAL_CALL setZoom( float fZoomX, float fZoomY ) override;

  // css::accessibility::XAccessible
  css::uno::Reference< css::accessibility::XAccessibleContext > SAL_CALL getAccessibleContext(  ) override;

  // css::awt::XDockableWindow
  void SAL_CALL addDockableWindowListener( const css::uno::Reference< css::awt::XDockableWindowListener >& xListener ) override;
  void SAL_CALL removeDockableWindowListener( const css::uno::Reference< css::awt::XDockableWindowListener >& xListener ) override;
  void SAL_CALL enableDocking( sal_Bool bEnable ) override;
  sal_Bool SAL_CALL isFloating(  ) override;
  void SAL_CALL setFloatingMode( sal_Bool bFloating ) override;
  void SAL_CALL lock(  ) override;
  void SAL_CALL unlock(  ) override;
  sal_Bool SAL_CALL isLocked(  ) override;
  void SAL_CALL startPopupMode( const css::awt::Rectangle& WindowRect ) override;
  sal_Bool SAL_CALL isInPopupMode(  ) override;

  // css::awt::XWindow2
  void SAL_CALL setOutputSize( const css::awt::Size& aSize ) override;
  css::awt::Size SAL_CALL getOutputSize(  ) override;
  sal_Bool SAL_CALL isVisible(  ) override;
  sal_Bool SAL_CALL isActive(  ) override;
  sal_Bool SAL_CALL isEnabled(  ) override;
  sal_Bool SAL_CALL hasFocus(  ) override;

  // css::beans::XPropertySetInfo
  css::uno::Sequence< css::beans::Property > SAL_CALL getProperties(  ) override;
  css::beans::Property SAL_CALL getPropertyByName( const OUString& aName ) override;
  sal_Bool SAL_CALL hasPropertyByName( const OUString& Name ) override;

  // XStyleSettingsSupplier
  virtual css::uno::Reference< css::awt::XStyleSettings > SAL_CALL getStyleSettings() override;
226};

228#endif // INCLUDED_TOOLKIT_AWT_VCLXWINDOW_HXX

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

←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
12
←
Calling constructor for 'Reference<vcl::Window>'→
15
←
Returning from constructor for 'Reference<vcl::Window>'→
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
  }

  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
    */
  reference_type * get() const
  {
      return m_rInnerRef.get();
  }

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
      if (aTmp.get()) {
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

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

←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
13
←
Assuming field 'm_pBody' is non-null→
14
←
Taking true branch→
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody20.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
21
←
Taking true branch→
          m_pBody->release();
22
←
Calling 'VclReferenceBase::release'→
26
←
Returning; memory was released→
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody)
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

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

←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 *   Licensed to the Apache Software Foundation (ASF) under one or more
12 *   contributor license agreements. See the NOTICE file distributed
13 *   with this work for additional information regarding copyright
14 *   ownership. The ASF licenses this file to you under the Apache
15 *   License, Version 2.0 (the "License"); you may not use this file
16 *   except in compliance with the License. You may obtain a copy of
17 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
23
←
Assuming the condition is true→
24
←
Taking true branch→
40            delete this;
25
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif