/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx
Warning:	line 1844, column 5 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 vclxtoolkit.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 -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 TOOLKIT_DLLIMPLEMENTATION -D SVT_DLL_NAME="libsvtlo.so" -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -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/toolkit/inc -I /home/maarten/src/libreoffice/core/toolkit/source -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -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/toolkit/source/awt/vclxtoolkit.cxx

/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.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#ifdef _WIN32
25#include <prewin.h>
26#include <postwin.h>
27#endif
28#include <config_features.h>
29#include <com/sun/star/awt/WindowAttribute.hpp>
30#include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
31#include <com/sun/star/awt/WindowClass.hpp>
32#include <com/sun/star/awt/MessageBoxButtons.hpp>
33#include <com/sun/star/lang/XMultiServiceFactory.hpp>
34#include <com/sun/star/lang/SystemDependent.hpp>
35#include <com/sun/star/awt/FocusEvent.hpp>
36#include <com/sun/star/awt/KeyEvent.hpp>
37#include <com/sun/star/awt/KeyModifier.hpp>
38#include <com/sun/star/lang/EventObject.hpp>
39#include <com/sun/star/uno/Reference.hxx>
40#include <com/sun/star/uno/Sequence.hxx>
41#include <com/sun/star/uno/XComponentContext.hpp>
42#include <com/sun/star/uno/XInterface.hpp>
43#include <com/sun/star/beans/NamedValue.hpp>
44#include <com/sun/star/beans/XPropertyChangeListener.hpp>
45#include <com/sun/star/beans/XPropertySet.hpp>
46#include <com/sun/star/datatransfer/clipboard/SystemClipboard.hpp>
47#include <com/sun/star/lang/XServiceInfo.hpp>
48#include <com/sun/star/awt/XToolkitExperimental.hpp>
49#include <com/sun/star/awt/XToolkitRobot.hpp>

51#include <cppuhelper/bootstrap.hxx>
52#include <cppuhelper/compbase.hxx>
53#include <cppuhelper/supportsservice.hxx>
54#include <osl/conditn.hxx>
55#include <osl/module.h>
56#include <osl/thread.hxx>
57#include <osl/mutex.hxx>
58#include <rtl/process.h>
59#include <sal/log.hxx>
60#include <tools/link.hxx>
61#include <tools/wintypes.hxx>

63#ifdef MACOSX
64#include <premac.h>
65#include <Cocoa/Cocoa.h>
66#include <postmac.h>
67#endif

69#include <vcl/sysdata.hxx>
70#include <vcl/textrectinfo.hxx>
71#include <vcl/toolkit/vclmedit.hxx>

73#include <toolkit/awt/vclxwindows.hxx>
74#include <awt/vclxsystemdependentwindow.hxx>
75#include <awt/vclxregion.hxx>
76#include <awt/vclxtabpagecontainer.hxx>

78#include <awt/animatedimagespeer.hxx>
79#include <toolkit/awt/vclxtopwindow.hxx>
80#include <toolkit/awt/vclxwindow.hxx>
81#include <toolkit/helper/vclunohelper.hxx>
82#include <toolkit/helper/property.hxx>

84#include <toolkit/helper/convert.hxx>
85#include <controls/filectrl.hxx>
86#include <controls/svmedit.hxx>
87#include <controls/treecontrolpeer.hxx>
88#include <vcl/toolkit/button.hxx>
89#include <vcl/toolkit/calendar.hxx>
90#include <vcl/toolkit/combobox.hxx>
91#include <vcl/ctrl.hxx>
92#include <vcl/toolkit/dialog.hxx>
93#include <vcl/dockingarea.hxx>
94#include <vcl/dockwin.hxx>
95#include <vcl/toolkit/edit.hxx>
96#include <vcl/event.hxx>
97#include <vcl/toolkit/field.hxx>
98#include <vcl/toolkit/fixed.hxx>
99#include <vcl/toolkit/fixedhyper.hxx>
100#include <vcl/floatwin.hxx>
101#include <vcl/toolkit/fmtfield.hxx>
102#include <vcl/toolkit/prgsbar.hxx>
103#include <vcl/scheduler.hxx>
104#include <vcl/toolkit/lstbox.hxx>
105#include <vcl/toolkit/longcurr.hxx>
106#include <vcl/menubtn.hxx>
107#include <vcl/stdtext.hxx>
108#include <vcl/scrbar.hxx>
109#include <vcl/split.hxx>
110#include <vcl/splitwin.hxx>
111#include <vcl/status.hxx>
112#include <vcl/svapp.hxx>
113#include <vcl/syschild.hxx>
114#include <vcl/tabctrl.hxx>
115#include <vcl/tabpage.hxx>
116#include <vcl/toolbox.hxx>
117#include <vcl/virdev.hxx>
118#include <vcl/window.hxx>
119#include <vcl/wrkwin.hxx>
120#include <vcl/toolkit/group.hxx>
121#include <vcl/toolkit/imgctrl.hxx>
122#include <vcl/toolkit/morebtn.hxx>
123#include <vcl/toolkit/roadmap.hxx>
124#include <vcl/toolkit/spin.hxx>
125#include <vcl/toolkit/tabdlg.hxx>
126#include <vcl/toolkit/throbber.hxx>
127#if HAVE_FEATURE_OPENGL1
128#include <vcl/opengl/OpenGLWrapper.hxx>
129#endif
130#include <awt/vclxspinbutton.hxx>
131#include <tools/debug.hxx>
132#include <tools/diagnose_ex.h>
133#include <comphelper/processfactory.hxx>
134#include <comphelper/profilezone.hxx>

136#include <helper/msgbox.hxx>
137#include <helper/scrollabledialog.hxx>
138#include <helper/unowrapper.hxx>

140#if defined(_WIN32)
141#define SYSTEM_DEPENDENT_TYPEcss::lang::SystemDependent::SYSTEM_XWINDOW css::lang::SystemDependent::SYSTEM_WIN32
142#elif defined(MACOSX)
143#define SYSTEM_DEPENDENT_TYPEcss::lang::SystemDependent::SYSTEM_XWINDOW css::lang::SystemDependent::SYSTEM_MAC
144#elif defined(UNX1)
145#define SYSTEM_DEPENDENT_TYPEcss::lang::SystemDependent::SYSTEM_XWINDOW css::lang::SystemDependent::SYSTEM_XWINDOW
146#endif

148void MessBox::ImplInitButtons()
149{
  ButtonDialogFlags nOKFlags = ButtonDialogFlags::OK;
  ButtonDialogFlags nCancelFlags = ButtonDialogFlags::Cancel;
  ButtonDialogFlags nRetryFlags = ButtonDialogFlags::NONE;
  ButtonDialogFlags nYesFlags = ButtonDialogFlags::NONE;
  ButtonDialogFlags nNoFlags = ButtonDialogFlags::NONE;

  if ( mnMessBoxStyle & MessBoxStyle::OkCancel )
  {
      if ( mnMessBoxStyle & MessBoxStyle::DefaultCancel )
          nCancelFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      else // MessBoxStyle::DefaultOk
          nOKFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;

      AddButton( StandardButtonType::OK, RET_OK, nOKFlags );
      AddButton( StandardButtonType::Cancel, RET_CANCEL, nCancelFlags );
  }
  else if ( mnMessBoxStyle & MessBoxStyle::YesNo )
  {
      if ( mnMessBoxStyle & MessBoxStyle::DefaultYes )
          nYesFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      else // MessBoxStyle::DefaultNo
          nNoFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      nNoFlags |= ButtonDialogFlags::Cancel;

      AddButton( StandardButtonType::Yes, RET_YES, nYesFlags );
      AddButton( StandardButtonType::No, RET_NO, nNoFlags );
  }
  else if ( mnMessBoxStyle & MessBoxStyle::YesNoCancel )
  {
      if ( mnMessBoxStyle & MessBoxStyle::DefaultYes )
          nYesFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      else if ( mnMessBoxStyle & MessBoxStyle::DefaultNo )
          nNoFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      else
          nCancelFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;

      AddButton( StandardButtonType::Yes, RET_YES, nYesFlags );
      AddButton( StandardButtonType::No, RET_NO, nNoFlags );
      AddButton( StandardButtonType::Cancel, RET_CANCEL, nCancelFlags );
  }
  else if ( mnMessBoxStyle & MessBoxStyle::RetryCancel )
  {
      if ( mnMessBoxStyle & MessBoxStyle::DefaultCancel )
          nCancelFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      else // MessBoxStyle::DefaultRetry
          nRetryFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;

      AddButton( StandardButtonType::Retry, RET_RETRY, nRetryFlags );
      AddButton( StandardButtonType::Cancel, RET_CANCEL, nCancelFlags );
  }
  else if ( mnMessBoxStyle & MessBoxStyle::AbortRetryIgnore )
  {
      ButtonDialogFlags nAbortFlags = ButtonDialogFlags::NONE;
      ButtonDialogFlags nIgnoreFlags = ButtonDialogFlags::NONE;

      if ( mnMessBoxStyle & MessBoxStyle::DefaultCancel )
          nAbortFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      else if ( mnMessBoxStyle & MessBoxStyle::DefaultRetry )
          nRetryFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;
      else if ( mnMessBoxStyle & MessBoxStyle::DefaultIgnore )
          nIgnoreFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;

      AddButton( StandardButtonType::Abort, RET_CANCEL, nAbortFlags );
      AddButton( StandardButtonType::Retry, RET_RETRY, nRetryFlags );
      AddButton( StandardButtonType::Ignore, RET_IGNORE, nIgnoreFlags );
  }
  else if ( mnMessBoxStyle & MessBoxStyle::Ok )
  {
      nOKFlags |= ButtonDialogFlags::Default | ButtonDialogFlags::Focus;

      AddButton( StandardButtonType::OK, RET_OK, nOKFlags );
  }
222}

224MessBox::MessBox(vcl::Window* pParent, MessBoxStyle nMessBoxStyle, WinBits nWinBits,
               const OUString& rTitle, const OUString& rMessage) :
  ButtonDialog( WindowType::MESSBOX ),
  mbHelpBtn( false ),
  mnMessBoxStyle( nMessBoxStyle ),
  maMessText( rMessage )
230{
  ImplLOKNotifier(pParent);
  ImplInitDialog(pParent, nWinBits | WB_MOVEABLE | WB_HORZ | WB_CENTER);
  ImplInitButtons();

  if ( !rTitle.isEmpty() )
      SetText( rTitle );
237}

239MessBox::~MessBox()
240{
  disposeOnce();
242}

244void MessBox::dispose()
245{
  mpVCLMultiLineEdit.disposeAndClear();
  mpFixedImage.disposeAndClear();
  ButtonDialog::dispose();
249}

251void MessBox::ImplPosControls()
252{
  if ( !GetHelpId().isEmpty() )
  {
      if ( !mbHelpBtn )
      {
          AddButton( StandardButtonType::Help, RET_HELP, ButtonDialogFlags::Help, 3 );
          mbHelpBtn = true;
      }
  }
  else
  {
      if ( mbHelpBtn )
      {
          RemoveButton( RET_HELP );
          mbHelpBtn = false;
      }
  }

  TextRectInfo    aTextInfo;
  tools::Rectangle       aRect( 0, 0, 30000, 30000 );
  tools::Rectangle       aFormatRect;
  Point           aTextPos( IMPL_DIALOG_OFFSET5, IMPL_DIALOG_OFFSET5+IMPL_MSGBOX_OFFSET_EXTRA_Y2 );
  Size            aImageSize;
  Size            aPageSize;
  Size            aMEditSize;
  long            nTitleWidth;
  long            nButtonSize = ImplGetButtonSize();
  long            nMaxLineWidth;
  long            nWidth;
  WinBits         nWinStyle = WB_LEFT | WB_NOLABEL;
  DrawTextFlags   nTextStyle = DrawTextFlags::MultiLine | DrawTextFlags::Top | DrawTextFlags::Left;

  mpVCLMultiLineEdit.disposeAndClear();
  mpFixedImage.disposeAndClear();

  // Clean up message text with tabs
  OUString aMessText(maMessText.replaceAll("\t", "    "));

  //If window too small, we make dialog box be wider
  long nMaxWidth = 630 * GetDPIScaleFactor();

  // MessagBox should be at least as wide as to see the title
  // Extra-Width for Close button, because Close button is set after this call
  nTitleWidth = CalcTitleWidth();

  nMaxWidth -= (IMPL_DIALOG_OFFSET5*2)+(IMPL_MSGBOX_OFFSET_EXTRA_X0*2);

  // for an image, get its size, create a suitable control and position it
  aImageSize = maImage.GetSizePixel();
  if ( aImageSize.Width() )
  {
      aImageSize.AdjustWidth(4 );
      aImageSize.AdjustHeight(4 );
      aTextPos.AdjustX(aImageSize.Width()+IMPL_SEP_MSGBOX_IMAGE8 );
      mpFixedImage = VclPtr<FixedImage>::Create( this );
      mpFixedImage->SetPosSizePixel( Point( IMPL_DIALOG_OFFSET5-2+IMPL_MSGBOX_OFFSET_EXTRA_X0,
                                            IMPL_DIALOG_OFFSET5-2+IMPL_MSGBOX_OFFSET_EXTRA_Y2 ),
                                     aImageSize );
      mpFixedImage->SetImage( maImage );
      mpFixedImage->Show();
      nMaxWidth -= aImageSize.Width()+IMPL_SEP_MSGBOX_IMAGE8;
  }
  else
      aTextPos.AdjustX(IMPL_MSGBOX_OFFSET_EXTRA_X0 );

  // Determine maximum line length without wordbreak
  aFormatRect = GetTextRect( aRect, aMessText, nTextStyle, &aTextInfo );
  nMaxLineWidth = aFormatRect.GetWidth();
  nTextStyle |= DrawTextFlags::WordBreak;

  // Determine the width for text formatting
  if ( nMaxLineWidth > 450 )
      nWidth = 450;
  else if ( nMaxLineWidth > 300 )
      nWidth = nMaxLineWidth+5;
  else
      nWidth = 300;

  nWidth *= GetDPIScaleFactor();

  if ( nButtonSize > nWidth )
      nWidth = nButtonSize-(aTextPos.X()-IMPL_DIALOG_OFFSET5);
  if ( nWidth > nMaxWidth )
      nWidth = nMaxWidth;

  aRect.SetRight( nWidth );
  aFormatRect = GetTextRect( aRect, aMessText, nTextStyle, &aTextInfo );
  if ( aTextInfo.GetMaxLineWidth() > nWidth )
  {
      nWidth = aTextInfo.GetMaxLineWidth()+8;
      aRect.SetRight( nWidth );
      aFormatRect = GetTextRect( aRect, aMessText, nTextStyle, &aTextInfo );
  }

  // get Style for VCLMultiLineEdit
  aMEditSize.setWidth( aTextInfo.GetMaxLineWidth()+1 );
  aMEditSize.setHeight( aFormatRect.GetHeight() );
  aPageSize.setWidth( aImageSize.Width() );
  if ( aMEditSize.Height() < aImageSize.Height() )
  {
      nWinStyle |= WB_VCENTER;
      aPageSize.setHeight( aImageSize.Height() );
      aMEditSize.setHeight( aImageSize.Height() );
  }
  else
  {
      nWinStyle |= WB_TOP;
      aPageSize.setHeight( aMEditSize.Height() );
  }
  if ( aImageSize.Width() )
      aPageSize.AdjustWidth(IMPL_SEP_MSGBOX_IMAGE8 );
  aPageSize.AdjustWidth((IMPL_DIALOG_OFFSET5*2)+(IMPL_MSGBOX_OFFSET_EXTRA_X0*2) );
  aPageSize.AdjustWidth(aMEditSize.Width()+1 );
  aPageSize.AdjustHeight((IMPL_DIALOG_OFFSET5*2)+(IMPL_MSGBOX_OFFSET_EXTRA_Y2*2) );

  if ( aPageSize.Width() < IMPL_MINSIZE_MSGBOX_WIDTH150 )
      aPageSize.setWidth( IMPL_MINSIZE_MSGBOX_WIDTH150 );
  if ( aPageSize.Width() < nTitleWidth )
      aPageSize.setWidth( nTitleWidth );

  mpVCLMultiLineEdit = VclPtr<VclMultiLineEdit>::Create( this, nWinStyle );
  mpVCLMultiLineEdit->SetText( aMessText );
  mpVCLMultiLineEdit->SetPosSizePixel( aTextPos, aMEditSize );
  mpVCLMultiLineEdit->Show();
  mpVCLMultiLineEdit->SetPaintTransparent(true);
  mpVCLMultiLineEdit->EnableCursor(false);
  SetPageSizePixel( aPageSize );
379}

381void MessBox::StateChanged( StateChangedType nType )
382{
  if ( nType == StateChangedType::InitShow )
  {
      ImplPosControls();
  }
  ButtonDialog::StateChanged( nType );
388}

390Size MessBox::GetOptimalSize() const
391{
  // FIXME: base me on the font size ?
  return Size( 250, 100 );
394}


397namespace {

399extern "C" typedef vcl::Window* (*FN_SvtCreateWindow)(
      VCLXWindow** ppNewComp,
      const css::awt::WindowDescriptor* pDescriptor,
      vcl::Window* pParent,
      WinBits nWinBits );

405class Pause : public Idle
406{
407public:
  explicit Pause(sal_Int32 nPauseMilliseconds) :
      Idle("pause"),
      m_nPauseMilliseconds(nPauseMilliseconds)
  {
      SetPriority(TaskPriority::HIGHEST);
      Start();
  }

  virtual void Invoke() override
  {
      SolarMutexGuard aSolarGuard;
      osl::Thread::wait(std::chrono::milliseconds(m_nPauseMilliseconds));
      Stop();
      delete this;
  }

  sal_Int32 m_nPauseMilliseconds;
425};

427class VCLXToolkitMutexHelper
428{
429protected:
  ::osl::Mutex    maMutex;
431};

433class VCLXToolkit : public VCLXToolkitMutexHelper,
                  public cppu::WeakComponentImplHelper<
                  css::awt::XToolkitExperimental,
                  css::awt::XToolkitRobot,
                  css::lang::XServiceInfo >
438{
  css::uno::Reference< css::datatransfer::clipboard::XClipboard > mxClipboard;
  css::uno::Reference< css::datatransfer::clipboard::XClipboard > mxSelection;

  oslModule           hSvToolsLib;
  FN_SvtCreateWindow  fnSvtCreateWindow;

  ::comphelper::OInterfaceContainerHelper2 m_aTopWindowListeners;
  ::comphelper::OInterfaceContainerHelper2 m_aKeyHandlers;
  ::comphelper::OInterfaceContainerHelper2 m_aFocusListeners;
  ::Link<VclSimpleEvent&,void> m_aEventListenerLink;
  ::Link<VclWindowEvent&,bool> m_aKeyListenerLink;
  bool m_bEventListener;
  bool m_bKeyListener;

  DECL_LINK(eventListenerHandler, ::VclSimpleEvent&, void)static void LinkStubeventListenerHandler(void *, ::VclSimpleEvent
&); void eventListenerHandler(::VclSimpleEvent&);

  DECL_LINK(keyListenerHandler, ::VclWindowEvent&, bool)static bool LinkStubkeyListenerHandler(void *, ::VclWindowEvent
&); bool keyListenerHandler(::VclWindowEvent&);

  void callTopWindowListeners(
      ::VclSimpleEvent const * pEvent,
      void (SAL_CALL css::awt::XTopWindowListener::* pFn)(
          css::lang::EventObject const &));

  bool callKeyHandlers(::VclSimpleEvent const * pEvent, bool bPressed);

  void callFocusListeners(::VclSimpleEvent const * pEvent, bool bGained);

466protected:
  ::osl::Mutex&   GetMutex() { return maMutex; }

  virtual void SAL_CALL disposing() override;

  static vcl::Window* ImplCreateWindow( VCLXWindow** ppNewComp, const css::awt::WindowDescriptor& rDescriptor, vcl::Window* pParent,
                           WinBits nWinBits, MessBoxStyle nMessBoxStyle );
  css::uno::Reference< css::awt::XWindowPeer > ImplCreateWindow( const css::awt::WindowDescriptor& Descriptor,
                           MessBoxStyle nForceMessBoxStyle );

476public:

  VCLXToolkit();

  // css::awt::XToolkitExperimental
  virtual void SAL_CALL processEventsToIdle() override;

  virtual sal_Int64 SAL_CALL getOpenGLBufferSwapCounter() override;

  virtual void SAL_CALL setDeterministicScheduling(sal_Bool bDeterministicMode) override;

  virtual void SAL_CALL pause(sal_Int32 nMilliseconds) override;

  virtual void SAL_CALL startRecording() override;

  virtual void SAL_CALL stopRecording() override;

  css::uno::Sequence< OUString > SAL_CALL getRecordingAndClear() override;

  // css::awt::XToolkit
  css::uno::Reference< css::awt::XWindowPeer >  SAL_CALL getDesktopWindow(  ) override;
  css::awt::Rectangle                                        SAL_CALL getWorkArea(  ) override;
  css::uno::Reference< css::awt::XWindowPeer >  SAL_CALL createWindow( const css::awt::WindowDescriptor& Descriptor ) override;
  css::uno::Sequence< css::uno::Reference< css::awt::XWindowPeer > > SAL_CALL createWindows( const css::uno::Sequence< css::awt::WindowDescriptor >& Descriptors ) override;
  css::uno::Reference< css::awt::XDevice >      SAL_CALL createScreenCompatibleDevice( sal_Int32 Width, sal_Int32 Height ) override;
  css::uno::Reference< css::awt::XRegion >      SAL_CALL createRegion(  ) override;

  // css::awt::XSystemChildFactory
  css::uno::Reference< css::awt::XWindowPeer > SAL_CALL createSystemChild( const css::uno::Any& Parent, const css::uno::Sequence< sal_Int8 >& ProcessId, sal_Int16 SystemType ) override;

  // css::awt::XMessageBoxFactory
  virtual css::uno::Reference< css::awt::XMessageBox > SAL_CALL createMessageBox( const css::uno::Reference< css::awt::XWindowPeer >& aParent, css::awt::MessageBoxType eType, ::sal_Int32 aButtons, const OUString& aTitle, const OUString& aMessage ) override;

  // css::awt::XDataTransfer
  css::uno::Reference< css::datatransfer::dnd::XDragGestureRecognizer > SAL_CALL getDragGestureRecognizer( const css::uno::Reference< css::awt::XWindow >& window ) override;
  css::uno::Reference< css::datatransfer::dnd::XDragSource > SAL_CALL getDragSource( const css::uno::Reference< css::awt::XWindow >& window ) override;
  css::uno::Reference< css::datatransfer::dnd::XDropTarget > SAL_CALL getDropTarget( const css::uno::Reference< css::awt::XWindow >& window ) override;
  css::uno::Reference< css::datatransfer::clipboard::XClipboard > SAL_CALL getClipboard( const OUString& clipboardName ) override;

  // css::lang::XServiceInfo
  OUString SAL_CALL getImplementationName(  ) override;
  sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
  css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;

  // css::awt::XExtendedToolkit:

  virtual ::sal_Int32 SAL_CALL getTopWindowCount() override;

  virtual css::uno::Reference< css::awt::XTopWindow >
  SAL_CALL getTopWindow(::sal_Int32 nIndex) override;

  virtual css::uno::Reference< css::awt::XTopWindow >
  SAL_CALL getActiveTopWindow() override;

  virtual void SAL_CALL addTopWindowListener(
      css::uno::Reference<
      css::awt::XTopWindowListener > const & rListener) override;

  virtual void SAL_CALL removeTopWindowListener(
      css::uno::Reference<
      css::awt::XTopWindowListener > const & rListener) override;

  virtual void SAL_CALL addKeyHandler(
      css::uno::Reference<
      css::awt::XKeyHandler > const & rHandler) override;

  virtual void SAL_CALL removeKeyHandler(
      css::uno::Reference<
      css::awt::XKeyHandler > const & rHandler) override;

  virtual void SAL_CALL addFocusListener(
      css::uno::Reference<
      css::awt::XFocusListener > const & rListener) override;

  virtual void SAL_CALL removeFocusListener(
      css::uno::Reference<
      css::awt::XFocusListener > const & rListener) override;

  virtual void SAL_CALL fireFocusGained(
      css::uno::Reference<
      css::uno::XInterface > const & source) override;

  virtual void SAL_CALL fireFocusLost(
      css::uno::Reference<
      css::uno::XInterface > const & source) override;

  // css::awt::XReschedule:
  virtual void SAL_CALL reschedule() override;

  // css:awt:XToolkitRobot
  virtual void SAL_CALL keyPress( const css::awt::KeyEvent & aKeyEvent ) override;

  virtual void SAL_CALL keyRelease( const css::awt::KeyEvent & aKeyEvent ) override;

  virtual void SAL_CALL mousePress( const css::awt::MouseEvent & aMouseEvent ) override;

  virtual void SAL_CALL mouseRelease( const css::awt::MouseEvent & aMouseEvent ) override;

  virtual void SAL_CALL mouseMove( const css::awt::MouseEvent & aMouseEvent ) override;

576};

578std::pair<WinBits,MessBoxStyle> ImplGetWinBits( sal_uInt32 nComponentAttribs, WindowType nCompType )
579{
  WinBits nWinBits = 0;
  MessBoxStyle nStyle = MessBoxStyle::NONE;

  bool bMessBox = false;
  if ( ( nCompType == WindowType::INFOBOX ) ||
       ( nCompType == WindowType::MESSBOX ) ||
       ( nCompType == WindowType::QUERYBOX ) ||
       ( nCompType == WindowType::WARNINGBOX ) ||
       ( nCompType == WindowType::ERRORBOX ) )
  {
      bMessBox = true;
  }

  bool bDecoratedWindow = false;
  if  (   bMessBox
      ||  ( nCompType == WindowType::DIALOG )
      ||  ( nCompType == WindowType::MODELESSDIALOG )
      ||  ( nCompType == WindowType::DOCKINGWINDOW )
      ||  ( nCompType == WindowType::TABDIALOG )
      ||  ( nCompType == WindowType::BUTTONDIALOG )
      ||  ( nCompType == WindowType::SYSTEMCHILDWINDOW )
      )
  {
      bDecoratedWindow = true;
  }

  if( nComponentAttribs & css::awt::WindowAttribute::BORDER )
      nWinBits |= WB_BORDER;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::NOBORDER )
      nWinBits |= WB_NOBORDER;
  if( nComponentAttribs & css::awt::WindowAttribute::SIZEABLE )
      nWinBits |= WB_SIZEABLE;
  if( nComponentAttribs & css::awt::WindowAttribute::MOVEABLE )
      nWinBits |= WB_MOVEABLE;
  if( nComponentAttribs & css::awt::WindowAttribute::CLOSEABLE )
      nWinBits |= WB_CLOSEABLE;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::HSCROLL )
      nWinBits |= WB_HSCROLL;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::VSCROLL )
      nWinBits |= WB_VSCROLL;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::LEFT )
      nWinBits |= WB_LEFT;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::CENTER )
      nWinBits |= WB_CENTER;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::RIGHT )
      nWinBits |= WB_RIGHT;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::SPIN )
      nWinBits |= WB_SPIN;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::SORT )
      nWinBits |= WB_SORT;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::DROPDOWN )
      nWinBits |= WB_DROPDOWN;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::DEFBUTTON )
      nWinBits |= WB_DEFBUTTON;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::READONLY )
      nWinBits |= WB_READONLY;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::CLIPCHILDREN )
      nWinBits |= WB_CLIPCHILDREN;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::GROUP )
      nWinBits |= WB_GROUP;
  if( nComponentAttribs & css::awt::VclWindowPeerAttribute::NOLABEL ) //added for issue79712
      nWinBits |= WB_NOLABEL;

  // These bits are not unique
  if ( bMessBox )
  {
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::OK )
          nStyle |= MessBoxStyle::Ok;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::OK_CANCEL )
          nStyle |= MessBoxStyle::OkCancel;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::YES_NO )
          nStyle |= MessBoxStyle::YesNo;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::YES_NO_CANCEL )
          nStyle |= MessBoxStyle::YesNoCancel;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::RETRY_CANCEL )
          nStyle |= MessBoxStyle::RetryCancel;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::DEF_OK )
          nStyle |= MessBoxStyle::DefaultOk;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::DEF_CANCEL )
          nStyle |= MessBoxStyle::DefaultCancel;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::DEF_RETRY )
          nStyle |= MessBoxStyle::DefaultRetry;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::DEF_YES )
          nStyle |= MessBoxStyle::DefaultYes;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::DEF_NO )
          nStyle |= MessBoxStyle::DefaultNo;
  }
  if ( nCompType == WindowType::MULTILINEEDIT || nCompType == WindowType::DIALOG || nCompType == WindowType::GROUPBOX )
  {
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::AUTOHSCROLL )
          nWinBits |= WB_AUTOHSCROLL;
      if( nComponentAttribs & css::awt::VclWindowPeerAttribute::AUTOVSCROLL )
          nWinBits |= WB_AUTOVSCROLL;
  }


  if ( bDecoratedWindow )
  {
      if( nComponentAttribs & css::awt::WindowAttribute::NODECORATION )
      {
          // No decoration removes several window attributes and must
          // set WB_NOBORDER!
          nWinBits &= ~WB_BORDER;
          nWinBits &= ~WB_SIZEABLE;
          nWinBits &= ~WB_MOVEABLE;
          nWinBits &= ~WB_CLOSEABLE;
          nWinBits |= WB_NOBORDER;
      }
  }

  return { nWinBits, nStyle };
691}

693struct ComponentInfo
694{
  std::u16string_view sName;
  WindowType      nWinType;
697};

699ComponentInfo const aComponentInfos [] =
700{
  { std::u16string_view(u"animatedimages"),     WindowType::CONTROL },
  { std::u16string_view(u"buttondialog"),       WindowType::BUTTONDIALOG },
  { std::u16string_view(u"cancelbutton"),       WindowType::CANCELBUTTON },
  { std::u16string_view(u"checkbox"),           WindowType::CHECKBOX },
  { std::u16string_view(u"combobox"),           WindowType::COMBOBOX },
  { std::u16string_view(u"control"),            WindowType::CONTROL },
  { std::u16string_view(u"currencybox"),        WindowType::CURRENCYBOX },
  { std::u16string_view(u"currencyfield"),      WindowType::CURRENCYFIELD },
  { std::u16string_view(u"datebox"),            WindowType::DATEBOX },
  { std::u16string_view(u"datefield"),          WindowType::CONTROL },
  { std::u16string_view(u"dialog"),             WindowType::DIALOG },
  { std::u16string_view(u"dockingarea"),        WindowType::DOCKINGAREA },
  { std::u16string_view(u"dockingwindow"),      WindowType::DOCKINGWINDOW },
  { std::u16string_view(u"edit"),               WindowType::EDIT },
  { std::u16string_view(u"errorbox"),           WindowType::ERRORBOX },
  { std::u16string_view(u"filecontrol"),        WindowType::CONTROL },
  { std::u16string_view(u"fixedbitmap"),        WindowType::FIXEDBITMAP },
  { std::u16string_view(u"fixedhyperlink"),     WindowType::CONTROL },
  { std::u16string_view(u"fixedimage"),         WindowType::FIXEDIMAGE },
  { std::u16string_view(u"fixedline"),          WindowType::FIXEDLINE },
  { std::u16string_view(u"fixedtext"),          WindowType::FIXEDTEXT },
  { std::u16string_view(u"floatingwindow"),     WindowType::FLOATINGWINDOW },
  { std::u16string_view(u"formattedfield"),     WindowType::CONTROL },
  { std::u16string_view(u"frame"),              WindowType::GROUPBOX },
  { std::u16string_view(u"framewindow"),        WindowType::TOOLKIT_FRAMEWINDOW },
  { std::u16string_view(u"groupbox"),           WindowType::GROUPBOX },
  { std::u16string_view(u"helpbutton"),         WindowType::HELPBUTTON },
  { std::u16string_view(u"imagebutton"),        WindowType::IMAGEBUTTON },
  { std::u16string_view(u"infobox"),            WindowType::INFOBOX },
  { std::u16string_view(u"listbox"),            WindowType::LISTBOX },
  { std::u16string_view(u"longcurrencybox"),    WindowType::LONGCURRENCYBOX },
  { std::u16string_view(u"longcurrencyfield"),  WindowType::CONTROL },
  { std::u16string_view(u"menubutton"),         WindowType::MENUBUTTON },
  { std::u16string_view(u"messbox"),            WindowType::MESSBOX },
  { std::u16string_view(u"metricbox"),          WindowType::METRICBOX },
  { std::u16string_view(u"metricfield"),        WindowType::METRICFIELD },
  { std::u16string_view(u"modelessdialog"),     WindowType::MODELESSDIALOG },
  { std::u16string_view(u"morebutton"),         WindowType::MOREBUTTON },
  { std::u16string_view(u"multilineedit"),      WindowType::MULTILINEEDIT },
  { std::u16string_view(u"multilistbox"),       WindowType::MULTILISTBOX },
  { std::u16string_view(u"numericbox"),         WindowType::NUMERICBOX },
  { std::u16string_view(u"numericfield"),       WindowType::CONTROL },
  { std::u16string_view(u"okbutton"),           WindowType::OKBUTTON },
  { std::u16string_view(u"patternbox"),         WindowType::PATTERNBOX },
  { std::u16string_view(u"patternfield"),       WindowType::PATTERNFIELD },
  { std::u16string_view(u"progressbar"),        WindowType::CONTROL },
  { std::u16string_view(u"pushbutton"),         WindowType::PUSHBUTTON },
  { std::u16string_view(u"querybox"),           WindowType::QUERYBOX },
  { std::u16string_view(u"radiobutton"),        WindowType::RADIOBUTTON },
  { std::u16string_view(u"roadmap"),            WindowType::CONTROL },
  { std::u16string_view(u"scrollbar"),          WindowType::SCROLLBAR },
  { std::u16string_view(u"scrollbarbox"),       WindowType::SCROLLBARBOX },
  { std::u16string_view(u"spinbutton"),         WindowType::SPINBUTTON },
  { std::u16string_view(u"spinfield"),          WindowType::SPINFIELD },
  { std::u16string_view(u"splitter"),           WindowType::SPLITTER },
  { std::u16string_view(u"splitwindow"),        WindowType::SPLITWINDOW },
  { std::u16string_view(u"statusbar"),          WindowType::STATUSBAR },
  { std::u16string_view(u"systemchildwindow"),  WindowType::TOOLKIT_SYSTEMCHILDWINDOW },
  { std::u16string_view(u"tabcontrol"),         WindowType::TABCONTROL },
  { std::u16string_view(u"tabdialog"),          WindowType::TABDIALOG },
  { std::u16string_view(u"tabpage"),            WindowType::TABPAGE },
  { std::u16string_view(u"tabpagecontainer"),   WindowType::CONTROL },
  { std::u16string_view(u"tabpagemodel"),       WindowType::TABPAGE },
  { std::u16string_view(u"timebox"),            WindowType::TIMEBOX },
  { std::u16string_view(u"timefield"),          WindowType::TIMEFIELD },
  { std::u16string_view(u"toolbox"),            WindowType::TOOLBOX },
  { std::u16string_view(u"tree"),               WindowType::CONTROL },
  { std::u16string_view(u"tristatebox"),        WindowType::TRISTATEBOX },
  { std::u16string_view(u"warningbox"),         WindowType::WARNINGBOX },
  { std::u16string_view(u"window"),             WindowType::WINDOW },
  { std::u16string_view(u"workwindow"),         WindowType::WORKWINDOW }
772};

774bool ComponentInfoFindCompare( const ComponentInfo & lhs, const OUString & s)
775{
  return rtl_ustr_compareIgnoreAsciiCase_WithLength(s.pData->buffer, s.pData->length,
              lhs.sName.data(), lhs.sName.size()) > 0;
778}

780WindowType ImplGetComponentType( const OUString& rServiceName )
781{
  static bool bSorted = false;
  if( !bSorted )
  {
      assert( std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos),(static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__))
                  [](const ComponentInfo & lhs, const ComponentInfo & rhs) {(static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__))
                      return(static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__))
                          rtl_ustr_compare_WithLength((static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__))
                              lhs.sName.data(), lhs.sName.size(), rhs.sName.data(),(static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__))
                              rhs.sName.size())(static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__))
                          < 0;(static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__))
                  } ) )(static_cast <bool> (std::is_sorted( std::begin(aComponentInfos
), std::end(aComponentInfos), [](const ComponentInfo & lhs
, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength
( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName
.size()) < 0; } )) ? void (0) : __assert_fail ("std::is_sorted( std::begin(aComponentInfos), std::end(aComponentInfos), [](const ComponentInfo & lhs, const ComponentInfo & rhs) { return rtl_ustr_compare_WithLength( lhs.sName.data(), lhs.sName.size(), rhs.sName.data(), rhs.sName.size()) < 0; } )"
, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
, 792, __extension__ __PRETTY_FUNCTION__));
      bSorted = true;
  }

  OUString sSearch;
  if ( !rServiceName.isEmpty() )
      sSearch = rServiceName;
  else
      sSearch = "window";

  auto it = std::lower_bound( std::begin(aComponentInfos), std::end(aComponentInfos), sSearch,
                              ComponentInfoFindCompare );
  if (it != std::end(aComponentInfos) &&
      rtl_ustr_compareIgnoreAsciiCase_WithLength(sSearch.pData->buffer, sSearch.pData->length, it->sName.data(), it->sName.size()) == 0)
      return it->nWinType;
  return WindowType::NONE;
808}

810struct MessageBoxTypeInfo
811{
  css::awt::MessageBoxType eType;
  const char              *pName;
  sal_Int32                nLen;
815};

817const MessageBoxTypeInfo aMessageBoxTypeInfo[] =
818{
  { css::awt::MessageBoxType_MESSAGEBOX,      RTL_CONSTASCII_STRINGPARAM("messbox")(&("messbox")[0]), ((sal_Int32)(sizeof(sal_n_array_size("messbox"
)))-1) },
  { css::awt::MessageBoxType_INFOBOX,         RTL_CONSTASCII_STRINGPARAM("infobox")(&("infobox")[0]), ((sal_Int32)(sizeof(sal_n_array_size("infobox"
)))-1) },
  { css::awt::MessageBoxType_WARNINGBOX,      RTL_CONSTASCII_STRINGPARAM("warningbox")(&("warningbox")[0]), ((sal_Int32)(sizeof(sal_n_array_size
("warningbox")))-1) },
  { css::awt::MessageBoxType_ERRORBOX,        RTL_CONSTASCII_STRINGPARAM("errorbox")(&("errorbox")[0]), ((sal_Int32)(sizeof(sal_n_array_size(
"errorbox")))-1) },
  { css::awt::MessageBoxType_QUERYBOX,        RTL_CONSTASCII_STRINGPARAM("querybox")(&("querybox")[0]), ((sal_Int32)(sizeof(sal_n_array_size(
"querybox")))-1) },
  { css::awt::MessageBoxType::MessageBoxType_MAKE_FIXED_SIZE, nullptr, 0 }
825};

827bool lcl_convertMessageBoxType(
  OUString &sType,
  css::awt::MessageBoxType eType )
830{
  const MessageBoxTypeInfo *pMap = aMessageBoxTypeInfo;
  css::awt::MessageBoxType eVal = css::awt::MessageBoxType::MessageBoxType_MAKE_FIXED_SIZE;

  while ( pMap->pName )
  {
      if ( pMap->eType == eType )
      {
          eVal = eType;
          sType = OUString( pMap->pName, pMap->nLen, RTL_TEXTENCODING_ASCII_US(((rtl_TextEncoding) 11)) );
          break;
      }
      pMap++;
  }

  return ( eVal != css::awt::MessageBoxType::MessageBoxType_MAKE_FIXED_SIZE );
846}

848#ifndef IOS

850sal_Int32                            nVCLToolkitInstanceCount = 0;
851bool                                 bInitedByVCLToolkit = false;

853osl::Mutex & getInitMutex()
854{
  static osl::Mutex aMutex;
  return aMutex;
857}

859osl::Condition & getInitCondition()
860{
  static osl::Condition aCondition;
  return aCondition;
863}

865extern "C"
866{
867static void ToolkitWorkerFunction( void* pArgs )
868{
  osl_setThreadName("VCLXToolkit VCL main thread");

  css::uno::Reference<css::lang::XMultiServiceFactory> xServiceManager;
  try
  {
      xServiceManager = ::comphelper::getProcessServiceFactory();
  }
  catch (const css::uno::DeploymentException&)
  {
  }
  if (!xServiceManager.is())
  {
      css::uno::Reference<css::uno::XComponentContext> xContext =
          ::cppu::defaultBootstrap_InitialComponentContext();

      xServiceManager.set( xContext->getServiceManager(), css::uno::UNO_QUERY_THROW );
      // set global process service factory used by unotools config helpers
      ::comphelper::setProcessServiceFactory( xServiceManager );
  }

  VCLXToolkit * pTk = static_cast<VCLXToolkit *>(pArgs);
  bInitedByVCLToolkit = !IsVCLInit() && InitVCL();
  if( bInitedByVCLToolkit )
  {
      UnoWrapper* pUnoWrapper = new UnoWrapper( pTk );
      UnoWrapperBase::SetUnoWrapper( pUnoWrapper );
  }
  getInitCondition().set();
  if( bInitedByVCLToolkit )
  {
      {
          SolarMutexGuard aGuard;
          Application::Execute();
      }
      try
      {
          pTk->dispose();
      }
      catch( css::uno::Exception & )
      {
      }
      DeInitVCL();
  }
  else
  {
      // having the thread join itself is pretty stupid.
      // but we can't get the osl_Thread to destroy here so just leak it.
  }
917}
918}

920#endif

922// constructor, which might initialize VCL
923VCLXToolkit::VCLXToolkit():
  cppu::WeakComponentImplHelper<
  css::awt::XToolkitExperimental,
  css::awt::XToolkitRobot,
  css::lang::XServiceInfo>( GetMutex() ),
  m_aTopWindowListeners(rBHelper.rMutex),
  m_aKeyHandlers(rBHelper.rMutex),
  m_aFocusListeners(rBHelper.rMutex),
  m_aEventListenerLink(LINK(this, VCLXToolkit, eventListenerHandler)::tools::detail::makeLink( ::tools::detail::castTo<VCLXToolkit
 *>(this), &VCLXToolkit::LinkStubeventListenerHandler)),
  m_aKeyListenerLink(LINK(this, VCLXToolkit, keyListenerHandler)::tools::detail::makeLink( ::tools::detail::castTo<VCLXToolkit
 *>(this), &VCLXToolkit::LinkStubkeyListenerHandler)),
  m_bEventListener(false),
  m_bKeyListener(false)
935{
  hSvToolsLib = nullptr;
  fnSvtCreateWindow = nullptr;

939#ifndef IOS
  osl::Guard< osl::Mutex > aGuard( getInitMutex() );
  nVCLToolkitInstanceCount++;
  if( ( nVCLToolkitInstanceCount == 1 ) && ( !Application::IsInMain() ) )
  {
      // setup execute thread
      CreateMainLoopThread( ToolkitWorkerFunction, this );
      getInitCondition().wait();
  }
948#endif
949}

951void SAL_CALL VCLXToolkit::disposing()
952{
953#ifndef DISABLE_DYNLOADING
  if ( hSvToolsLib )
  {
      osl_unloadModule( hSvToolsLib );
      hSvToolsLib = nullptr;
      fnSvtCreateWindow = nullptr;
  }
960#endif

962#ifndef IOS
  {
      osl::Guard< osl::Mutex > aGuard( getInitMutex() );
      if( --nVCLToolkitInstanceCount == 0 )
      {
          if( bInitedByVCLToolkit )
          {
              Application::Quit();
              JoinMainLoopThread();
              bInitedByVCLToolkit = false;
          }
      }
  }
975#endif
  if (m_bEventListener)
  {
      ::Application::RemoveEventListener(m_aEventListenerLink);
      m_bEventListener = false;
  }
  if (m_bKeyListener)
  {
      ::Application::RemoveKeyListener(m_aKeyListenerLink);
      m_bKeyListener = false;
  }
  css::lang::EventObject aEvent(
      static_cast< ::cppu::OWeakObject * >(this));
  m_aTopWindowListeners.disposeAndClear(aEvent);
  m_aKeyHandlers.disposeAndClear(aEvent);
  m_aFocusListeners.disposeAndClear(aEvent);
991}


994css::uno::Reference< css::awt::XWindowPeer > VCLXToolkit::getDesktopWindow(  )
995{
  css::uno::Reference< css::awt::XWindowPeer > xRef;
  // 07/00: AppWindow doesn't exist anymore...
  return xRef;
999}

1001css::awt::Rectangle VCLXToolkit::getWorkArea(  )
1002{
  sal_Int32 nDisplay = Application::GetDisplayBuiltInScreen();
  tools::Rectangle aWorkRect = Application::GetScreenPosSizePixel( nDisplay );
  css::awt::Rectangle aNotherRect;
  aNotherRect.X = aWorkRect.getX();
  aNotherRect.Y = aWorkRect.getY();
  aNotherRect.Width = aWorkRect.getWidth();
  aNotherRect.Height = aWorkRect.getHeight();
  return aNotherRect;
1011}

1013css::uno::Reference< css::awt::XWindowPeer > VCLXToolkit::createWindow( const css::awt::WindowDescriptor& rDescriptor )
1014{
  return ImplCreateWindow( rDescriptor, MessBoxStyle::NONE );
1016}

1018css::uno::Reference< css::awt::XDevice > VCLXToolkit::createScreenCompatibleDevice( sal_Int32 Width, sal_Int32 Height )
1019{
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  css::uno::Reference< css::awt::XDevice > xRef;
  VCLXVirtualDevice* pVDev = new VCLXVirtualDevice;

  SolarMutexGuard aSolarGuard;

  VclPtrInstance<VirtualDevice> pV;
  pV->SetOutputSizePixel( Size( Width, Height ) );
  pVDev->SetVirtualDevice( pV );

  xRef = pVDev;
  return xRef;
1033}

1035css::uno::Reference< css::awt::XRegion > VCLXToolkit::createRegion(  )
1036{
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  css::uno::Reference< css::awt::XRegion >  xRef = new VCLXRegion;
  return xRef;
1041}

1043class InfoBox : public MessBox
1044{
1045public:
  InfoBox(vcl::Window* pParent, const OUString& rMessage)
      : MessBox(pParent, MessBoxStyle::Ok | MessBoxStyle::DefaultOk, 0, OUString(), rMessage)
  {
      // Default Text is the display title from the application
      if (GetText().isEmpty())
          SetText(GetStandardInfoBoxText());
      SetImage(GetStandardInfoBoxImage());
  }
1054};

1056class ErrorBox : public MessBox
1057{
1058public:
  ErrorBox(vcl::Window* pParent, MessBoxStyle nStyle, WinBits nWinBits, const OUString& rMessage)
      : MessBox(pParent, nStyle, nWinBits, OUString(), rMessage)
  {
      // Default Text is the display title from the application
      if (GetText().isEmpty())
          SetText(GetStandardErrorBoxText());
      SetImage(GetStandardErrorBoxImage());
  }
1067};

1069class QueryBox : public MessBox
1070{
1071public:
  QueryBox(vcl::Window* pParent, MessBoxStyle nStyle, WinBits nWinBits, const OUString& rMessage)
      : MessBox(pParent, nStyle, nWinBits, OUString(), rMessage)
  {
      // Default Text is the display title from the application
      if (GetText().isEmpty())
          SetText(GetStandardQueryBoxText());
      SetImage(GetStandardQueryBoxImage());
  }
1080};

1082class WarningBox : public MessBox
1083{
1084public:
  WarningBox(vcl::Window* pParent, MessBoxStyle nStyle, WinBits nWinBits, const OUString& rMessage)
      : MessBox(pParent, nStyle, nWinBits, OUString(), rMessage)
  {
      // Default Text is the display title from the application
      if (GetText().isEmpty())
          SetText(GetStandardWarningBoxText());
      SetImage(GetStandardWarningBoxImage());
  }
1093};


1096struct RMItemData
1097{
  bool            b_Enabled;
  sal_Int32           n_ID;
  OUString     Label;
1101};

1103typedef ::cppu::ImplInheritanceHelper  <   VCLXGraphicControl
                                      ,   css::container::XContainerListener
                                      ,   css::beans::XPropertyChangeListener
                                      ,   css::awt::XItemEventBroadcaster
                                      >   SVTXRoadmap_Base;
1108class SVTXRoadmap final : public SVTXRoadmap_Base
1109{
1110public:
  SVTXRoadmap();

  void SAL_CALL disposing( const css::lang::EventObject& Source ) override { VCLXWindow::disposing( Source ); }

  // css::awt::XVclWindowPeer
  void SAL_CALL setProperty( const OUString& PropertyName, const css::uno::Any& Value ) override;

  css::uno::Any SAL_CALL getProperty( const OUString& PropertyName ) override;

  // XContainerListener
  void SAL_CALL elementInserted( const css::container::ContainerEvent& rEvent ) override;
  void SAL_CALL elementRemoved( const css::container::ContainerEvent& rEvent ) override;
  void SAL_CALL elementReplaced( const css::container::ContainerEvent& rEvent ) override;

  // XItemEventBroadcaster
  virtual void SAL_CALL addItemListener( const css::uno::Reference< css::awt::XItemListener >& l ) override;
  virtual void SAL_CALL removeItemListener( const css::uno::Reference< css::awt::XItemListener >& l ) override;

  // XPropertyChangeListener
  virtual void SAL_CALL propertyChange( const css::beans::PropertyChangeEvent& evt ) override;

1132private:

  // VCLXGraphicControl overridables
  virtual void    ImplSetNewImage() override;

  static void     ImplGetPropertyIds( std::vector< sal_uInt16 > &aIds );
  virtual void    GetPropertyIds( std::vector< sal_uInt16 > &aIds ) override { return ImplGetPropertyIds( aIds ); }

  static RMItemData GetRMItemData( const css::container::ContainerEvent& _rEvent );

  virtual void ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) override;

  virtual ~SVTXRoadmap() override;

  ItemListenerMultiplexer     maItemListeners;
1147};




1152SVTXRoadmap::SVTXRoadmap() : maItemListeners( *this )
1153{
1154}

1156SVTXRoadmap::~SVTXRoadmap()
1157{
1158}

1160void SVTXRoadmap::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1161{
  switch ( rVclWindowEvent.GetId() )
  {
      case VclEventId::RoadmapItemSelected:
      {
          SolarMutexGuard aGuard;
          VclPtr<::vcl::ORoadmap> pField = GetAs< vcl::ORoadmap >();
          if ( pField )
          {
              sal_Int16 CurItemID = pField->GetCurrentRoadmapItemID();
              css::awt::ItemEvent aEvent;
              aEvent.Selected = CurItemID;
              aEvent.Highlighted = CurItemID;
              aEvent.ItemId = CurItemID;
              maItemListeners.itemStateChanged( aEvent );
          }
      }
      break;
      default:
          SVTXRoadmap_Base::ProcessWindowEvent( rVclWindowEvent );
          break;
  }
1183}

1185void SVTXRoadmap::propertyChange( const css::beans::PropertyChangeEvent& evt )
1186{
  SolarMutexGuard aGuard;
  VclPtr<::vcl::ORoadmap> pField = GetAs< vcl::ORoadmap >();
  if ( !pField )
      return;

  css::uno::Reference< css::uno::XInterface > xRoadmapItem = evt.Source;
  sal_Int32 nID = 0;
  css::uno::Reference< css::beans::XPropertySet > xPropertySet( xRoadmapItem, css::uno::UNO_QUERY );
  css::uno::Any aValue = xPropertySet->getPropertyValue("ID");
  aValue >>= nID;

  OUString sPropertyName = evt.PropertyName;
  if ( sPropertyName == "Enabled" )
  {
      bool bEnable = false;
      evt.NewValue >>= bEnable;
      pField->EnableRoadmapItem( static_cast<vcl::RoadmapTypes::ItemId>(nID) , bEnable );
  }
  else if ( sPropertyName == "Label" )
  {
      OUString sLabel;
      evt.NewValue >>= sLabel;
      pField->ChangeRoadmapItemLabel( static_cast<vcl::RoadmapTypes::ItemId>(nID) , sLabel );
  }
  else if  ( sPropertyName == "ID" )
  {
      sal_Int32 nNewID = 0;
      evt.NewValue >>= nNewID;
      evt.OldValue >>= nID;
      pField->ChangeRoadmapItemID( static_cast<vcl::RoadmapTypes::ItemId>(nID), static_cast<vcl::RoadmapTypes::ItemId>(nNewID) );
  }
1218//    else
      // TODO handle Interactive appropriately
1220}

1222void SVTXRoadmap::addItemListener( const css::uno::Reference< css::awt::XItemListener >& l )
1223{
  maItemListeners.addInterface( l );
1225}

1227void SVTXRoadmap::removeItemListener( const css::uno::Reference< css::awt::XItemListener >& l )
1228{
  maItemListeners.removeInterface( l );
1230}

1232RMItemData SVTXRoadmap::GetRMItemData( const css::container::ContainerEvent& _rEvent )
1233{
  RMItemData aCurRMItemData;
  css::uno::Reference< css::uno::XInterface > xRoadmapItem;
  _rEvent.Element >>= xRoadmapItem;
  css::uno::Reference< css::beans::XPropertySet > xPropertySet( xRoadmapItem, css::uno::UNO_QUERY );
  if ( xPropertySet.is() )
  {
      css::uno::Any aValue = xPropertySet->getPropertyValue("Label");
      aValue >>= aCurRMItemData.Label;
      aValue = xPropertySet->getPropertyValue("ID");
      aValue >>= aCurRMItemData.n_ID;
      aValue = xPropertySet->getPropertyValue("Enabled");
      aValue >>= aCurRMItemData.b_Enabled;
  }
  else
  {
      aCurRMItemData.b_Enabled = false;
      aCurRMItemData.n_ID = 0;
  }
  return aCurRMItemData;
1253}

1255void SVTXRoadmap::elementInserted( const css::container::ContainerEvent& _rEvent )
1256{
  SolarMutexGuard aGuard;
  VclPtr<::vcl::ORoadmap> pField = GetAs< vcl::ORoadmap >();
  if ( pField )
  {
      RMItemData CurItemData = GetRMItemData(  _rEvent );
      sal_Int32 InsertIndex = 0;
      _rEvent.Accessor >>= InsertIndex;
      pField->InsertRoadmapItem( InsertIndex, CurItemData.Label, static_cast<vcl::RoadmapTypes::ItemId>(CurItemData.n_ID), CurItemData.b_Enabled );
  }
1266}

1268void SVTXRoadmap::elementRemoved( const css::container::ContainerEvent& _rEvent )
1269{
  SolarMutexGuard aGuard;
  VclPtr<::vcl::ORoadmap> pField = GetAs< vcl::ORoadmap >();
  if ( pField )
  {
      sal_Int32 DelIndex = 0;
      _rEvent.Accessor >>= DelIndex;
      pField->DeleteRoadmapItem(DelIndex);
  }
1278}

1280void SVTXRoadmap::elementReplaced( const css::container::ContainerEvent& _rEvent )
1281{
  SolarMutexGuard aGuard;
  VclPtr<::vcl::ORoadmap> pField = GetAs< vcl::ORoadmap >();
  if ( pField )
  {
      RMItemData CurItemData = GetRMItemData(  _rEvent );
      sal_Int32 ReplaceIndex = 0;
      _rEvent.Accessor >>= ReplaceIndex;
      pField->ReplaceRoadmapItem( ReplaceIndex, CurItemData.Label, static_cast<vcl::RoadmapTypes::ItemId>(CurItemData.n_ID), CurItemData.b_Enabled );
  }
1291}

1293void SVTXRoadmap::setProperty( const OUString& PropertyName, const css::uno::Any& Value)
1294{
  SolarMutexGuard aGuard;

  VclPtr<::vcl::ORoadmap> pField = GetAs< vcl::ORoadmap >();
  if ( pField )
  {
      sal_uInt16 nPropType = GetPropertyId( PropertyName );
      switch (nPropType)
      {
          case BASEPROPERTY_COMPLETE106:
          {
              bool b = false;
              Value >>= b;
              pField->SetRoadmapComplete( b);
          }
          break;

          case BASEPROPERTY_ACTIVATED105:
          {
              bool b = false;
              Value >>= b;
              pField->SetRoadmapInteractive( b);
          }
          break;

          case BASEPROPERTY_CURRENTITEMID107:
          {
              sal_Int32 nId = 0;
              Value >>= nId;
              pField->SelectRoadmapItemByID( static_cast<vcl::RoadmapTypes::ItemId>(nId) );
          }
          break;

          case BASEPROPERTY_TEXT1:
          {
              OUString aStr;
              Value >>= aStr;
              pField->SetText( aStr );
              pField->Invalidate();
          }
          break;

          default:
              SVTXRoadmap_Base::setProperty( PropertyName, Value );
              break;
      }

  }
  else
      SVTXRoadmap_Base::setProperty( PropertyName, Value );
1344}


1347css::uno::Any SVTXRoadmap::getProperty( const OUString& PropertyName )
1348{
  SolarMutexGuard aGuard;

  css::uno::Any aReturn;

  VclPtr<::vcl::ORoadmap> pField = GetAs< vcl::ORoadmap >();
  if ( pField )
  {
      sal_uInt16 nPropType = GetPropertyId( PropertyName );
      switch (nPropType)
      {
          case BASEPROPERTY_COMPLETE106:
              aReturn <<= pField->IsRoadmapComplete();
              break;
          case BASEPROPERTY_ACTIVATED105:
              aReturn <<= pField->IsRoadmapInteractive();
              break;
          case BASEPROPERTY_CURRENTITEMID107:
              aReturn <<= pField->GetCurrentRoadmapItemID();
              break;
          default:
              aReturn = SVTXRoadmap_Base::getProperty(PropertyName);
              break;
      }
  }
  return aReturn;
1374}

1376void SVTXRoadmap::ImplSetNewImage()
1377{
  OSL_PRECOND( GetWindow(), "SVTXRoadmap::ImplSetNewImage: window is required to be not-NULL!" )do { if (true && (!(GetWindow()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1378" ": "), "%s", "SVTXRoadmap::ImplSetNewImage: window is required to be not-NULL!"
); } } while (false);
  VclPtr< ::vcl::ORoadmap > pButton = GetAs< ::vcl::ORoadmap >();
  pButton->SetRoadmapBitmap( GetImage().GetBitmapEx() );
1381}

1383void SVTXRoadmap::ImplGetPropertyIds( std::vector< sal_uInt16 > &rIds )
1384{
  PushPropertyIds( rIds,
                   BASEPROPERTY_COMPLETE106,
                   BASEPROPERTY_ACTIVATED105,
                   BASEPROPERTY_CURRENTITEMID107,
                   BASEPROPERTY_TEXT1,
                   0);
  VCLXWindow::ImplGetPropertyIds( rIds, true );
  VCLXGraphicControl::ImplGetPropertyIds( rIds );
1393}

1395vcl::Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
  const css::awt::WindowDescriptor& rDescriptor,
  vcl::Window* pParent, WinBits nWinBits, MessBoxStyle nMessBoxStyle )
1398{
  OUString aServiceName = rDescriptor.WindowServiceName.toAsciiLowerCase();

  VclPtr<vcl::Window> pNewWindow;
  WindowType nType = ImplGetComponentType( aServiceName );
  bool bFrameControl = false;
  if ( aServiceName == "frame" )
1
Assuming the condition is false→
2
←
Taking false branch→
      bFrameControl = true;
  if ( aServiceName == "tabcontrolnotabs" )
3
←
Taking false branch→
  {
      nWinBits |= WB_NOBORDER;
      nType = ImplGetComponentType( "tabcontrol" );
  }
  if ( !pParent )
4
←
Assuming 'pParent' is non-null→
5
←
Taking false branch→
  {
      // If the component needs a parent, then return NULL,
      // some time later css::uno::Exception...
      bool bException = true;
      if  (   ( nType == WindowType::DIALOG )
          ||  ( nType == WindowType::MODELESSDIALOG )
          ||  ( nType == WindowType::MESSBOX )
          ||  ( nType == WindowType::INFOBOX )
          ||  ( nType == WindowType::WARNINGBOX )
          ||  ( nType == WindowType::ERRORBOX )
          ||  ( nType == WindowType::QUERYBOX )
          )
          bException = false;
      else if ( ( nType == WindowType::WINDOW ) ||
                ( nType == WindowType::WORKWINDOW ) ||
                ( nType == WindowType::TOOLKIT_FRAMEWINDOW ) )
      {
          if ( rDescriptor.Type == css::awt::WindowClass_TOP )
              bException = false;
      }

      if ( bException )
      {
          *ppNewComp = nullptr;
          return nullptr;
      }
  }

  if ( nType != WindowType::NONE )
6
←
Assuming 'nType' is not equal to NONE→
7
←
Taking true branch→
  {
      SolarMutexGuard aVclGuard;
      switch ( nType )
8
←
Control jumps to 'case TOOLKIT_FRAMEWINDOW:'  at line 1678→
      {
          case WindowType::CANCELBUTTON:
              pNewWindow = VclPtr<CancelButton>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXButton;
          break;
          case WindowType::CHECKBOX:
               pNewWindow = VclPtr<CheckBox>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXCheckBox;
          break;
          case WindowType::COMBOBOX:
              pNewWindow = VclPtr<ComboBox>::Create( pParent, nWinBits|WB_AUTOHSCROLL );
              static_cast<ComboBox*>(pNewWindow.get())->EnableAutoSize( false );
              *ppNewComp = new VCLXComboBox;
          break;
          case WindowType::CURRENCYBOX:
              pNewWindow = VclPtr<CurrencyBox>::Create( pParent, nWinBits );
          break;
          case WindowType::CURRENCYFIELD:
              pNewWindow = VclPtr<CurrencyField>::Create( pParent, nWinBits );
              static_cast<CurrencyField*>(pNewWindow.get())->EnableEmptyFieldValue( true );
              *ppNewComp = new VCLXNumericField;
              static_cast<VCLXFormattedSpinField*>(*ppNewComp)->SetFormatter( static_cast<FormatterBase*>(static_cast<CurrencyField*>(pNewWindow.get())) );
          break;
          case WindowType::DATEBOX:
              pNewWindow = VclPtr<DateBox>::Create( pParent, nWinBits );
          break;
          case WindowType::DOCKINGAREA:
              pNewWindow = VclPtr<DockingAreaWindow>::Create( pParent );
          break;
          case WindowType::MULTILINEEDIT:
              pNewWindow = VclPtr<MultiLineEdit>::Create(pParent, nWinBits|WB_IGNORETAB);
              static_cast<MultiLineEdit*>(pNewWindow.get())->DisableSelectionOnFocus();
              *ppNewComp = new VCLXMultiLineEdit;
          break;
          case WindowType::EDIT:
              pNewWindow = VclPtr<Edit>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXEdit;
          break;
          case WindowType::ERRORBOX:
              pNewWindow = VclPtr<ErrorBox>::Create( pParent, nMessBoxStyle, nWinBits, OUString() );
              *ppNewComp = new VCLXMessageBox;
          break;
          case WindowType::FIXEDBITMAP:
              pNewWindow = VclPtr<FixedBitmap>::Create( pParent, nWinBits );
          break;
          case WindowType::FIXEDIMAGE:
              pNewWindow = VclPtr<ImageControl>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXImageControl;
          break;
          case WindowType::FIXEDLINE:
              pNewWindow = VclPtr<FixedLine>::Create( pParent, nWinBits );
          break;
          case WindowType::FIXEDTEXT:
              pNewWindow = VclPtr<FixedText>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXFixedText;
          break;
          case WindowType::FLOATINGWINDOW:
              pNewWindow = VclPtr<FloatingWindow>::Create( pParent, nWinBits );
          break;
          case WindowType::GROUPBOX:
              pNewWindow = VclPtr<GroupBox>::Create( pParent, nWinBits );
              if ( bFrameControl )
              {
                  GroupBox* pGroupBox =  static_cast< GroupBox* >( pNewWindow.get() );
                  *ppNewComp = new VCLXFrame;
                  // Frame control needs to receive
                  // Mouse events
                  pGroupBox->SetMouseTransparent( false );
              }
          break;
          case WindowType::HELPBUTTON:
              pNewWindow = VclPtr<HelpButton>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXButton;
          break;
          case WindowType::IMAGEBUTTON:
               pNewWindow = VclPtr<ImageButton>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXButton;
          break;
          case WindowType::INFOBOX:
              pNewWindow = VclPtr<InfoBox>::Create( pParent, OUString() );
              *ppNewComp = new VCLXMessageBox;
          break;
          case WindowType::LISTBOX:
              pNewWindow = VclPtr<ListBox>::Create( pParent, nWinBits|WB_SIMPLEMODE|WB_AUTOHSCROLL );
              static_cast<ListBox*>(pNewWindow.get())->EnableAutoSize( false );
              *ppNewComp = new VCLXListBox;
          break;
          case WindowType::LONGCURRENCYBOX:
              pNewWindow = VclPtr<LongCurrencyBox>::Create( pParent, nWinBits );
          break;
          case WindowType::MENUBUTTON:
              pNewWindow = VclPtr<MenuButton>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXButton;
          break;
          case WindowType::MESSBOX:
              pNewWindow = VclPtr<MessBox>::Create( pParent, nMessBoxStyle, nWinBits, OUString(), OUString() );
              *ppNewComp = new VCLXMessageBox;
          break;
          case WindowType::METRICBOX:
              pNewWindow = VclPtr<MetricBox>::Create( pParent, nWinBits );
          break;
          case WindowType::METRICFIELD:
              pNewWindow = VclPtr<MetricField>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXMetricField;
              static_cast<VCLXFormattedSpinField*>(*ppNewComp)->SetFormatter( static_cast<FormatterBase*>(static_cast<MetricField*>(pNewWindow.get())) );
          break;
          case WindowType::DIALOG:
          case WindowType::MODELESSDIALOG:
          {
              // Modal/Modeless only via Show/Execute
              if ( (pParent == nullptr ) && ( rDescriptor.ParentIndex == -1 ) )
                  pNewWindow = VclPtr<toolkit::ScrollableDialog>::Create( nullptr, nWinBits, Dialog::InitFlag::NoParent );
              else
                  pNewWindow = VclPtr<toolkit::ScrollableDialog>::Create( pParent, nWinBits );
              // #i70217# Don't always create a new component object. It's possible that VCL has called
              // GetComponentInterface( sal_True ) in the Dialog ctor itself (see Window::IsTopWindow() )
              // which creates a component object.
              css::uno::Reference< css::awt::XWindowPeer > xWinPeer = pNewWindow->GetComponentInterface( false );
              if ( xWinPeer.is() )
                  *ppNewComp = dynamic_cast< VCLXDialog* >( xWinPeer.get() );
              else
                  *ppNewComp = new VCLXDialog;
          }
          break;
          case WindowType::MOREBUTTON:
              pNewWindow = VclPtr<MoreButton>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXButton;
          break;
          case WindowType::MULTILISTBOX:
              pNewWindow = VclPtr<MultiListBox>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXListBox;
          break;
          case WindowType::NUMERICBOX:
              pNewWindow = VclPtr<NumericBox>::Create( pParent, nWinBits );
          break;
          case WindowType::OKBUTTON:
              pNewWindow = VclPtr<OKButton>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXButton;
          break;
          case WindowType::PATTERNBOX:
              pNewWindow = VclPtr<PatternBox>::Create( pParent, nWinBits );
          break;
          case WindowType::PATTERNFIELD:
              pNewWindow = VclPtr<PatternField>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXPatternField;
              static_cast<VCLXFormattedSpinField*>(*ppNewComp)->SetFormatter( static_cast<FormatterBase*>(static_cast<PatternField*>(pNewWindow.get())) );
          break;
          case WindowType::PUSHBUTTON:
              pNewWindow = VclPtr<PushButton>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXButton;
          break;
          case WindowType::QUERYBOX:
              pNewWindow = VclPtr<QueryBox>::Create( pParent, nMessBoxStyle, nWinBits, OUString() );
              *ppNewComp = new VCLXMessageBox;
          break;
          case WindowType::RADIOBUTTON:
              pNewWindow = VclPtr<RadioButton>::Create(pParent, false, nWinBits);
              *ppNewComp = new VCLXRadioButton;

              // by default, disable RadioCheck
              // Since the VCLXRadioButton really cares for its RadioCheck settings, this is important:
              // if we enable it, the VCLXRadioButton will use RadioButton::Check instead of RadioButton::SetState
              // This leads to a strange behaviour if the control is newly created: when settings the initial
              // state to "checked", the RadioButton::Check (called because RadioCheck=sal_True) will uncheck
              // _all_other_ radio buttons in the same group. However, at this moment the grouping of the controls
              // is not really valid: the controls are grouped after they have been created, but we're still in
              // the creation process, so the RadioButton::Check relies on invalid grouping information.
              // 07.08.2001 - #87254# - frank.schoenheit@sun.com
              static_cast<RadioButton*>(pNewWindow.get())->EnableRadioCheck( false );
          break;
          case WindowType::SCROLLBAR:
              pNewWindow = VclPtr<ScrollBar>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXScrollBar;
          break;
          case WindowType::SCROLLBARBOX:
              pNewWindow = VclPtr<ScrollBarBox>::Create( pParent, nWinBits );
          break;
          case WindowType::SPINBUTTON:
              pNewWindow = VclPtr<SpinButton>::Create( pParent, nWinBits );
              *ppNewComp = new ::toolkit::VCLXSpinButton;
          break;
          case WindowType::SPINFIELD:
              pNewWindow = VclPtr<SpinField>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXNumericField;
          break;
          case WindowType::SPLITTER:
              pNewWindow = VclPtr<Splitter>::Create( pParent, nWinBits );
          break;
          case WindowType::SPLITWINDOW:
              pNewWindow = VclPtr<SplitWindow>::Create( pParent, nWinBits );
          break;
          case WindowType::STATUSBAR:
              pNewWindow = VclPtr<StatusBar>::Create( pParent, nWinBits );
          break;
          case WindowType::TOOLKIT_SYSTEMCHILDWINDOW:
              pNewWindow = VclPtr<SystemChildWindow>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXSystemDependentWindow();
          break;
          case WindowType::TABCONTROL:
              pNewWindow = VclPtr<TabControl>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXMultiPage;
          break;
          case WindowType::TABDIALOG:
              pNewWindow = VclPtr<TabDialog>::Create( pParent, nWinBits );
          break;
          case WindowType::TABPAGE:
              {
                  pNewWindow = VclPtr<TabPage>::Create( pParent, nWinBits );
                  *ppNewComp = new VCLXTabPage;
              }
          break;
          case WindowType::TIMEBOX:
              pNewWindow = VclPtr<TimeBox>::Create( pParent, nWinBits );
          break;
          case WindowType::TIMEFIELD:
              pNewWindow = VclPtr<TimeField>::Create( pParent, nWinBits );
              static_cast<TimeField*>(pNewWindow.get())->EnableEmptyFieldValue( true );
              *ppNewComp = new VCLXTimeField;
              static_cast<VCLXFormattedSpinField*>(*ppNewComp)->SetFormatter( static_cast<FormatterBase*>(static_cast<TimeField*>(pNewWindow.get())) );
          break;
          case WindowType::TOOLBOX:
              pNewWindow = VclPtr<ToolBox>::Create( pParent, nWinBits );
              *ppNewComp = new VCLXToolBox;
          break;
          case WindowType::TRISTATEBOX:
              pNewWindow = VclPtr<CheckBox>::Create( pParent, nWinBits );
              static_cast<CheckBox*>(pNewWindow.get())->EnableTriState(true);
          break;
          case WindowType::WARNINGBOX:
              pNewWindow = VclPtr<WarningBox>::Create( pParent, nMessBoxStyle, nWinBits, OUString() );
              *ppNewComp = new VCLXMessageBox;
          break;
          case WindowType::WORKWINDOW:
          case WindowType::WINDOW:
          case WindowType::TOOLKIT_FRAMEWINDOW:
          case WindowType::DOCKINGWINDOW:
              if ( rDescriptor.Type == css::awt::WindowClass_TOP )
9
←
Assuming 'WindowClass_TOP' is not equal to field 'Type'→
10
←
Taking false branch→
              {
                  if (nType == WindowType::DOCKINGWINDOW )
                      pNewWindow = VclPtr<DockingWindow>::Create( pParent, nWinBits );
                  else
                  {
                      if ((pParent == nullptr) && rDescriptor.Parent.is())
                      {
                          // try to get a system dependent window handle
                          css::uno::Reference< css::awt::XSystemDependentWindowPeer > xSystemDepParent(rDescriptor.Parent, css::uno::UNO_QUERY);

                          if (xSystemDepParent.is())
                          {
                              sal_Int8 processID[16];

                              rtl_getGlobalProcessId( reinterpret_cast<sal_uInt8*>(processID) );

                              // coverity[overrun-buffer-arg : FALSE] - coverity has difficulty with css::uno::Sequence
                              css::uno::Sequence<sal_Int8> processIdSeq(processID, 16);

                              css::uno::Any anyHandle = xSystemDepParent->getWindowHandle(processIdSeq, SYSTEM_DEPENDENT_TYPEcss::lang::SystemDependent::SYSTEM_XWINDOW);

                              // use sal_Int64 here to accommodate all int types
                              // uno::Any shift operator whill upcast if necessary
                              sal_Int64 nWindowHandle = 0;
                              bool bXEmbed = false;

                              bool bUseParentData = true;
                              if( ! (anyHandle >>= nWindowHandle) )
                              {
                                  css::uno::Sequence< css::beans::NamedValue > aProps;
                                  if( anyHandle >>= aProps )
                                  {
                                      for( const css::beans::NamedValue& rProp : std::as_const(aProps) )
                                      {
                                          if ( rProp.Name == "WINDOW" )
                                              rProp.Value >>= nWindowHandle;
                                          else if ( rProp.Name == "XEMBED" )
                                              rProp.Value >>= bXEmbed;
                                      }
                                  }
                                  else
                                      bUseParentData = false;
                              }

                              if( bUseParentData )
                              {
                                  SystemParentData aParentData;
                                  aParentData.nSize   = sizeof( aParentData );
                                  #if defined MACOSX
                                  aParentData.pView   = reinterpret_cast<NSView*>(nWindowHandle);
                                  #elif defined ANDROID
                                  // Nothing
                                  #elif defined IOS
                                  // Nothing
                                  #elif defined UNX1
                                  aParentData.aWindow = nWindowHandle;
                                  aParentData.bXEmbedSupport = bXEmbed;
                                  #elif defined _WIN32
                                  aParentData.hWnd = reinterpret_cast<HWND>(nWindowHandle);
                                  #endif
                                  pNewWindow = VclPtr<WorkWindow>::Create( &aParentData );
                              }
                          }
                      }

                      if (!pNewWindow)
                          pNewWindow = VclPtr<WorkWindow>::Create( pParent, nWinBits );
                  }

                  *ppNewComp = new VCLXTopWindow();
              }
              else if ( rDescriptor.Type == css::awt::WindowClass_CONTAINER )
11
←
Assuming 'WindowClass_CONTAINER' is not equal to field 'Type'→
12
←
Taking false branch→
              {
                  if (nType == WindowType::DOCKINGWINDOW )
                      pNewWindow = VclPtr<DockingWindow>::Create( pParent, nWinBits );
                  else
                      pNewWindow = VclPtr<vcl::Window>::Create( pParent, nWinBits );
                  *ppNewComp = new VCLXContainer;
              }
              else
              {
                  if (nType12.1
'nType' is not equal to DOCKINGWINDOW
1
'nType' is not equal to DOCKINGWINDOW
1
'nType' is not equal to DOCKINGWINDOW
1
'nType' is not equal to DOCKINGWINDOW
 == WindowType::DOCKINGWINDOW )
13
←
Taking false branch→
                      pNewWindow = VclPtr<DockingWindow>::Create( pParent, nWinBits );
                  else
                      pNewWindow = VclPtr<vcl::Window>::Create( pParent, nWinBits );
14
←
Calling 'VclPtr::Create'→
16
←
Returned allocated memory→
                  *ppNewComp = new VCLXWindow;
              }
          break;
17
←
 Execution continues on line 141→
          case WindowType::CONTROL:
              if ( aServiceName == "tabpagecontainer" )
              {
                  // TabControl has a special case for tabs without border: they are displayed
                  // in a different way, so we need to ensure that this style is not set, so
                  // we can guarantee normal tab behavior
                  pNewWindow = VclPtr<TabControl>::Create( pParent, nWinBits & (~WB_NOBORDER));
                  *ppNewComp = new VCLXTabPageContainer;
              }
              else if ( aServiceName == "animatedimages" )
              {
                  pNewWindow = VclPtr<Throbber>::Create( pParent, nWinBits );
                  *ppNewComp = new ::toolkit::AnimatedImagesPeer;
              }
              else if (aServiceName == "roadmap")
              {
                  pNewWindow = VclPtr<::vcl::ORoadmap>::Create( pParent, WB_TABSTOP );
                  *ppNewComp = new SVTXRoadmap;
              }
              else if (aServiceName == "fixedhyperlink")
              {
                  pNewWindow = VclPtr<FixedHyperlink>::Create( pParent, nWinBits );
                  *ppNewComp = new VCLXFixedHyperlink;
              }
              else if (aServiceName == "progressbar")
              {
                  pNewWindow = VclPtr<ProgressBar>::Create( pParent, nWinBits );
                  *ppNewComp = new VCLXProgressBar;
              }
              else if (aServiceName == "filecontrol")
              {
                  pNewWindow = VclPtr<FileControl>::Create( pParent, nWinBits );
                  *ppNewComp = new VCLXFileControl;
              }
              else if (aServiceName == "tree")
              {
                  TreeControlPeer* pPeer = new TreeControlPeer;
                  *ppNewComp = pPeer;
                  pNewWindow = pPeer->createVclControl( pParent, nWinBits );
              }
              else if (aServiceName == "formattedfield")
              {
                  pNewWindow = VclPtr<FormattedField>::Create( pParent, nWinBits );
                  *ppNewComp = new SVTXFormattedField;
              }
              else if (aServiceName == "numericfield")
              {
                  pNewWindow = VclPtr<DoubleNumericField>::Create( pParent, nWinBits );
                  *ppNewComp = new SVTXNumericField;
              }
              else if (aServiceName == "longcurrencyfield")
              {
                  pNewWindow = VclPtr<DoubleCurrencyField>::Create( pParent, nWinBits );
                  *ppNewComp = new SVTXCurrencyField;
              }
              else if (aServiceName == "datefield")
              {
                  pNewWindow = VclPtr<CalendarField>::Create(pParent, nWinBits);
                  static_cast<CalendarField*>(pNewWindow.get())->EnableToday();
                  static_cast<CalendarField*>(pNewWindow.get())->EnableNone();
                  static_cast<CalendarField*>(pNewWindow.get())->EnableEmptyFieldValue( true );
                  SVTXDateField * newComp = new SVTXDateField;
                  *ppNewComp = newComp;
                  newComp->SetFormatter( static_cast<FormatterBase*>(static_cast<DateField*>(pNewWindow.get())) );
              }
          break;
          default:
              OSL_ENSURE( false, "VCLXToolkit::ImplCreateWindow: unknown window type!" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1836" ": "), "%s", "VCLXToolkit::ImplCreateWindow: unknown window type!"
); } } while (false);
              break;
      }
  }

  // tdf#126717 default that formcontrols show accelerators
  if (Control* pControl17.1
'pControl' is non-null
1
'pControl' is non-null
1
'pControl' is non-null
1
'pControl' is non-null
 = dynamic_cast<Control*>(pNewWindow.get()))
18
←
Taking true branch→
      pControl->SetShowAccelerator(true);
  return pNewWindow;
19
←
Calling implicit destructor for 'VclPtr<vcl::Window>'→
20
←
Calling '~Reference'→
27
←
Returning from '~Reference'→
28
←
Returning from destructor for 'VclPtr<vcl::Window>'→
29
←
Use of memory after it is freed
1845}

1847#ifndef DISABLE_DYNLOADING

1849extern "C" { static void thisModule() {} }

1851#else

1853extern "C" vcl::Window* SAL_CALL CreateWindow( VCLXWindow** ppNewComp, const css::awt::WindowDescriptor* pDescriptor, vcl::Window* pParent, WinBits nWinBits );

1855#endif

1857css::uno::Reference< css::awt::XWindowPeer > VCLXToolkit::ImplCreateWindow(
  const css::awt::WindowDescriptor& rDescriptor,
  MessBoxStyle nForceMessBoxStyle )
1860{
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  SolarMutexGuard aSolarGuard;

  css::uno::Reference< css::awt::XWindowPeer > xRef;

  VclPtr<vcl::Window> pParent;
  if ( rDescriptor.Parent.is() )
  {
      VCLXWindow* pParentComponent = comphelper::getUnoTunnelImplementation<VCLXWindow>( rDescriptor.Parent );

      // #103939# Don't throw assertion, may be it's a system dependent window, used in ImplCreateWindow.
      // DBG_ASSERT( pParentComponent, "ParentComponent not valid" );

      if ( pParentComponent )
          pParent = pParentComponent->GetWindow();
  }
  std::pair<WinBits, MessBoxStyle> aPair = ImplGetWinBits( rDescriptor.WindowAttributes,
      ImplGetComponentType( rDescriptor.WindowServiceName ) );
  WinBits nWinBits = aPair.first;
  aPair.second |= nForceMessBoxStyle;

  VCLXWindow* pNewComp = nullptr;

  vcl::Window* pNewWindow = nullptr;
  // Try to create the window with SvTools
  // (do this _before_ creating it on our own: The old mechanism (extended toolkit in SvTools) did it this way,
  // and we need to stay compatible)
  // try to load the lib
  if ( !fnSvtCreateWindow
1891#ifndef DISABLE_DYNLOADING
       && !hSvToolsLib
1893#endif
       )
  {
1896#ifndef DISABLE_DYNLOADING
      OUString aLibName(SVT_DLL_NAME"libsvtlo.so");
      hSvToolsLib = osl_loadModuleRelative(
          &thisModule, aLibName.pData, SAL_LOADMODULE_DEFAULT0x00000 );
      if ( hSvToolsLib )
      {
          OUString aFunctionName( "CreateWindow" );
          fnSvtCreateWindow = reinterpret_cast<FN_SvtCreateWindow>(osl_getFunctionSymbol( hSvToolsLib, aFunctionName.pData ));
      }
1905#else
      fnSvtCreateWindow = CreateWindow;
1907#endif
  }
  // ask the SvTool creation function
  if ( fnSvtCreateWindow )
      pNewWindow = fnSvtCreateWindow( &pNewComp, &rDescriptor, pParent, nWinBits );

  // if SvTools could not provide a window, create it ourself
  if ( !pNewWindow )
      pNewWindow = ImplCreateWindow( &pNewComp, rDescriptor, pParent, nWinBits, aPair.second );

  DBG_ASSERT( pNewWindow, "createWindow: Unknown Component!" )do { if (true && (!(pNewWindow))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1917" ": "), "%s", "createWindow: Unknown Component!");
 } } while (false);
  SAL_INFO_IF( !pNewComp, "toolkit", "createWindow: No special Interface!" )do { if (true && (!pNewComp)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_INFO, "toolkit")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "createWindow: No special Interface!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("toolkit"
), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1918" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "createWindow: No special Interface!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "createWindow: No special Interface!"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("toolkit"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1918" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "createWindow: No special Interface!") == 1) { ::
sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("toolkit"), (
"/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1918" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "createWindow: No special Interface!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "createWindow: No special Interface!"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("toolkit"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1918" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

  if ( pNewWindow )
  {
      pNewWindow->SetCreatedWithToolkit( true );
      //pNewWindow->SetPosPixel( Point() ); // do not force (0,0) position, keep default pos instead

      if ( rDescriptor.WindowAttributes & css::awt::WindowAttribute::MINSIZE )
      {
          pNewWindow->SetSizePixel( Size() );
      }
      else if ( rDescriptor.WindowAttributes & css::awt::WindowAttribute::FULLSIZE )
      {
          if ( pParent )
              pNewWindow->SetSizePixel( pParent->GetOutputSizePixel() );
      }
      else if ( !VCLUnoHelper::IsZero( rDescriptor.Bounds ) )
      {
          tools::Rectangle aRect = VCLRectangle( rDescriptor.Bounds );
          pNewWindow->SetPosSizePixel( aRect.TopLeft(), aRect.GetSize() );
      }

      if ( !pNewComp )
      {
          // Default-Interface
          xRef = pNewWindow->GetComponentInterface();
      }
      else
      {
          xRef = pNewComp;
          pNewWindow->SetComponentInterface( xRef );
      }
      DBG_ASSERT( pNewWindow->GetComponentInterface( false ) == xRef,do { if (true && (!(pNewWindow->GetComponentInterface
( false ) == xRef))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1951" ": "), "%s", "VCLXToolkit::createWindow: did #133706# resurge?"
); } } while (false)
          "VCLXToolkit::createWindow: did #133706# resurge?" )do { if (true && (!(pNewWindow->GetComponentInterface
( false ) == xRef))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "1951" ": "), "%s", "VCLXToolkit::createWindow: did #133706# resurge?"
); } } while (false);

      if ( rDescriptor.WindowAttributes & css::awt::WindowAttribute::SHOW )
          pNewWindow->Show();
  }

  return xRef;
1958}

1960css::uno::Sequence< css::uno::Reference< css::awt::XWindowPeer > > VCLXToolkit::createWindows( const css::uno::Sequence< css::awt::WindowDescriptor >& rDescriptors )
1961{
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  sal_uInt32 nComponents = rDescriptors.getLength();
  css::uno::Sequence< css::uno::Reference< css::awt::XWindowPeer > > aSeq( nComponents );
  for ( sal_uInt32 n = 0; n < nComponents; n++ )
  {
      css::awt::WindowDescriptor aDescr = rDescriptors.getConstArray()[n];

      if ( aDescr.ParentIndex == -1 )
          aDescr.Parent = nullptr;
      else if ( ( aDescr.ParentIndex >= 0 ) && ( aDescr.ParentIndex < static_cast<short>(n) ) )
          aDescr.Parent = aSeq.getConstArray()[aDescr.ParentIndex];
      aSeq.getArray()[n] = createWindow( aDescr );
  }
  return aSeq;
1977}

1979// css::awt::XSystemChildFactory
1980css::uno::Reference< css::awt::XWindowPeer > VCLXToolkit::createSystemChild( const css::uno::Any& Parent, const css::uno::Sequence< sal_Int8 >& /*ProcessId*/, sal_Int16 nSystemType )
1981{
  VclPtr<vcl::Window> pChildWindow;
  if ( nSystemType == SYSTEM_DEPENDENT_TYPEcss::lang::SystemDependent::SYSTEM_XWINDOW )
  {
      // use sal_Int64 here to accommodate all int types
      // uno::Any shift operator whill upcast if necessary
      sal_Int64 nWindowHandle = 0;
      bool bXEmbed = false;

      bool bUseParentData = true;
      if( ! (Parent >>= nWindowHandle) )
      {
          css::uno::Sequence< css::beans::NamedValue > aProps;
          if( Parent >>= aProps )
          {
              for( const css::beans::NamedValue& rProp : std::as_const(aProps) )
              {
                  if ( rProp.Name == "WINDOW" )
                      rProp.Value >>= nWindowHandle;
                  else if ( rProp.Name == "XEMBED" )
                      rProp.Value >>= bXEmbed;
              }
          }
          else
              bUseParentData = false;
      }

      if( bUseParentData )
      {
          SystemParentData aParentData;
          aParentData.nSize   = sizeof( aParentData );
          #if defined MACOSX
          aParentData.pView   = reinterpret_cast<NSView*>(nWindowHandle);
          #elif defined ANDROID
          // Nothing
          #elif defined IOS
          // Nothing
          #elif defined UNX1
          aParentData.aWindow = nWindowHandle;
          aParentData.bXEmbedSupport = bXEmbed;
          #elif defined _WIN32
          aParentData.hWnd = reinterpret_cast<HWND>(nWindowHandle);
          #endif
          SolarMutexGuard aGuard;
          try
          {
              pChildWindow.reset( VclPtr<WorkWindow>::Create( &aParentData ) );
          }
          catch ( const css::uno::RuntimeException & )
          {
              // system child window could not be created
              DBG_UNHANDLED_EXCEPTION("toolkit")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "2032" ": ", "toolkit" );;
              pChildWindow.clear();
          }
      }
  }
  else if (nSystemType == css::lang::SystemDependent::SYSTEM_JAVA)
  {
      SolarMutexGuard aGuard;
      pChildWindow.reset(VclPtr<WorkWindow>::Create(nullptr, Parent));
  }

  css::uno::Reference< css::awt::XWindowPeer > xPeer;
  if ( pChildWindow )
  {
      VCLXTopWindow* pPeer = new VCLXTopWindow;
      SolarMutexGuard aGuard;
      pPeer->SetWindow( pChildWindow );
      xPeer = pPeer;
  }

  return xPeer;
2053}

2055// css::awt::XMessageBoxFactory
2056css::uno::Reference< css::awt::XMessageBox > SAL_CALL VCLXToolkit::createMessageBox(
  const css::uno::Reference< css::awt::XWindowPeer >& aParent,
  css::awt::MessageBoxType eType,
  ::sal_Int32 aButtons,
  const OUString& aTitle,
  const OUString& aMessage )
2062{
  css::awt::WindowDescriptor aDescriptor;

  sal_Int32 nWindowAttributes = css::awt::WindowAttribute::BORDER|css::awt::WindowAttribute::MOVEABLE|css::awt::WindowAttribute::CLOSEABLE;

  // Map button definitions to window attributes
  if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_OK )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::OK;
  else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_OK_CANCEL )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::OK_CANCEL;
  else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_YES_NO )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::YES_NO;
  else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_YES_NO_CANCEL )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::YES_NO_CANCEL;
  else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_RETRY_CANCEL )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::RETRY_CANCEL;

  // Map default button definitions to window attributes
  if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_OK )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_OK;
  else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_CANCEL )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_CANCEL;
  else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_YES )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_YES;
  else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_NO )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_NO;
  else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_RETRY )
      nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_RETRY;

  // No more bits for VclWindowPeerAttribute possible. Mapping must be
  // done explicitly using VCL methods
  MessBoxStyle nAddWinBits = MessBoxStyle::NONE;
  if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_ABORT_IGNORE_RETRY )
      nAddWinBits |= MessBoxStyle::AbortRetryIgnore;
  if ( sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_IGNORE )
      nAddWinBits |= MessBoxStyle::DefaultIgnore;

  OUString aType;
  lcl_convertMessageBoxType( aType, eType );

  aDescriptor.Type              = css::awt::WindowClass_MODALTOP;
  aDescriptor.WindowServiceName = aType;
  aDescriptor.ParentIndex       = -1;
  aDescriptor.Parent            = aParent;
  aDescriptor.WindowAttributes  = nWindowAttributes;
  css::uno::Reference< css::awt::XMessageBox > xMsgBox(
      ImplCreateWindow( aDescriptor, nAddWinBits ), css::uno::UNO_QUERY );
  css::uno::Reference< css::awt::XWindow > xWindow( xMsgBox, css::uno::UNO_QUERY );
  if ( xMsgBox.is() && xWindow.is() )
  {
      VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
      if ( pWindow )
      {
          SolarMutexGuard aGuard;
          xMsgBox->setCaptionText( aTitle );
          xMsgBox->setMessageText( aMessage );
      }
  }

  return xMsgBox;
2122}

2124css::uno::Reference< css::datatransfer::dnd::XDragGestureRecognizer > SAL_CALL VCLXToolkit::getDragGestureRecognizer( const css::uno::Reference< css::awt::XWindow >& window )
2125{
  SolarMutexGuard g;

  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( window );

  if( pWindow )
      return pWindow->GetDragGestureRecognizer();

  return css::uno::Reference< css::datatransfer::dnd::XDragGestureRecognizer >();
2134}

2136css::uno::Reference< css::datatransfer::dnd::XDragSource > SAL_CALL VCLXToolkit::getDragSource( const css::uno::Reference< css::awt::XWindow >& window )
2137{
  SolarMutexGuard g;

  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( window );

  if( pWindow )
      return pWindow->GetDragSource();

  return css::uno::Reference< css::datatransfer::dnd::XDragSource >();
2146}

2148css::uno::Reference< css::datatransfer::dnd::XDropTarget > SAL_CALL VCLXToolkit::getDropTarget( const css::uno::Reference< css::awt::XWindow >& window )
2149{
  SolarMutexGuard g;

  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( window );

  if( pWindow )
      return pWindow->GetDropTarget();

  return css::uno::Reference< css::datatransfer::dnd::XDropTarget >();
2158}

2160css::uno::Reference< css::datatransfer::clipboard::XClipboard > SAL_CALL VCLXToolkit::getClipboard( const OUString& clipboardName )
2161{
  if( clipboardName.isEmpty() )
  {
      if( !mxClipboard.is() )
      {
          // remember clipboard here
          mxClipboard = css::datatransfer::clipboard::SystemClipboard::create(
              comphelper::getProcessComponentContext());
      }

      return mxClipboard;
  }

  else if( clipboardName == "Selection" )
  {
      return mxSelection;
  }

  return css::uno::Reference< css::datatransfer::clipboard::XClipboard >();
2180}

2182// XServiceInfo
2183OUString VCLXToolkit::getImplementationName()
2184{
  return "stardiv.Toolkit.VCLXToolkit";
2186}

2188sal_Bool VCLXToolkit::supportsService( const OUString& rServiceName )
2189{
  return cppu::supportsService(this, rServiceName);
2191}

2193css::uno::Sequence< OUString > VCLXToolkit::getSupportedServiceNames()
2194{
  return css::uno::Sequence<OUString>{
      "com.sun.star.awt.Toolkit", "stardiv.vcl.VclToolkit"};
2197}

2199// css::awt::XExtendedToolkit:

2201// virtual
:sal_Int32 SAL_CALL VCLXToolkit::getTopWindowCount()
2203{
  return static_cast< ::sal_Int32 >(::Application::GetTopWindowCount());
      // XXX  numeric overflow
2206}

2208// virtual
2209css::uno::Reference< css::awt::XTopWindow > SAL_CALL
2210VCLXToolkit::getTopWindow(::sal_Int32 nIndex)
2211{
  vcl::Window * p = ::Application::GetTopWindow(static_cast< long >(nIndex));
      // XXX  numeric overflow
  return css::uno::Reference< css::awt::XTopWindow >(
      p == nullptr ? nullptr : static_cast< css::awt::XWindow * >(p->GetWindowPeer()),
      css::uno::UNO_QUERY);
2217}

2219// virtual
2220css::uno::Reference< css::awt::XTopWindow > SAL_CALL
2221VCLXToolkit::getActiveTopWindow()
2222{
  vcl::Window * p = ::Application::GetActiveTopWindow();
  return css::uno::Reference< css::awt::XTopWindow >(
      p == nullptr ? nullptr : static_cast< css::awt::XWindow * >(p->GetWindowPeer()),
      css::uno::UNO_QUERY);
2227}

2229// virtual
2230void SAL_CALL VCLXToolkit::addTopWindowListener(
  css::uno::Reference< css::awt::XTopWindowListener > const & rListener)
2232{
  OSL_ENSURE(rListener.is(), "Null rListener")do { if (true && (!(rListener.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "2233" ": "), "%s", "Null rListener"); } } while (false);
  ::osl::ClearableMutexGuard aGuard(rBHelper.rMutex);
  if (rBHelper.bDisposed || rBHelper.bInDispose)
  {
      aGuard.clear();
      rListener->disposing(
          css::lang::EventObject(
              static_cast< ::cppu::OWeakObject * >(this)));
  }
  else if (m_aTopWindowListeners.addInterface(rListener) == 1
           && !m_bEventListener)
  {
      m_bEventListener = true;
      ::Application::AddEventListener(m_aEventListenerLink);
  }
2248}

2250// virtual
2251void SAL_CALL VCLXToolkit::removeTopWindowListener(
  css::uno::Reference< css::awt::XTopWindowListener > const & rListener)
2253{
  ::osl::MutexGuard aGuard(rBHelper.rMutex);
  if (!(rBHelper.bDisposed || rBHelper.bInDispose)
      && m_aTopWindowListeners.removeInterface(rListener) == 0
      && m_aFocusListeners.getLength() == 0 && m_bEventListener)
  {
      ::Application::RemoveEventListener(m_aEventListenerLink);
      m_bEventListener = false;
  }
2262}

2264// virtual
2265void SAL_CALL VCLXToolkit::addKeyHandler(
  css::uno::Reference< css::awt::XKeyHandler > const & rHandler)
2267{
  OSL_ENSURE(rHandler.is(), "Null rHandler")do { if (true && (!(rHandler.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "2268" ": "), "%s", "Null rHandler"); } } while (false);
  ::osl::ClearableMutexGuard aGuard(rBHelper.rMutex);
  if (rBHelper.bDisposed || rBHelper.bInDispose)
  {
      aGuard.clear();
      rHandler->disposing(
          css::lang::EventObject(
              static_cast< ::cppu::OWeakObject * >(this)));
  }
  else if (m_aKeyHandlers.addInterface(rHandler) == 1 && !m_bKeyListener)
  {
      m_bKeyListener = true;
      ::Application::AddKeyListener(m_aKeyListenerLink);
  }
2282}

2284// virtual
2285void SAL_CALL VCLXToolkit::removeKeyHandler(
  css::uno::Reference< css::awt::XKeyHandler > const & rHandler)
2287{
  ::osl::MutexGuard aGuard(rBHelper.rMutex);
  if (!(rBHelper.bDisposed || rBHelper.bInDispose)
      && m_aKeyHandlers.removeInterface(rHandler) == 0 && m_bKeyListener)
  {
      ::Application::RemoveKeyListener(m_aKeyListenerLink);
      m_bKeyListener = false;
  }
2295}

2297// virtual
2298void SAL_CALL VCLXToolkit::addFocusListener(
  css::uno::Reference< css::awt::XFocusListener > const & rListener)
2300{
  OSL_ENSURE(rListener.is(), "Null rListener")do { if (true && (!(rListener.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "2301" ": "), "%s", "Null rListener"); } } while (false);
  ::osl::ClearableMutexGuard aGuard(rBHelper.rMutex);
  if (rBHelper.bDisposed || rBHelper.bInDispose)
  {
      aGuard.clear();
      rListener->disposing(
          css::lang::EventObject(
              static_cast< ::cppu::OWeakObject * >(this)));
  }
  else if (m_aFocusListeners.addInterface(rListener) == 1
           && !m_bEventListener)
  {
      m_bEventListener = true;
      ::Application::AddEventListener(m_aEventListenerLink);
  }
2316}

2318// virtual
2319void SAL_CALL VCLXToolkit::removeFocusListener(
  css::uno::Reference< css::awt::XFocusListener > const & rListener)
2321{
  ::osl::MutexGuard aGuard(rBHelper.rMutex);
  if (!(rBHelper.bDisposed || rBHelper.bInDispose)
      && m_aFocusListeners.removeInterface(rListener) == 0
      && m_aTopWindowListeners.getLength() == 0 && m_bEventListener)
  {
      ::Application::RemoveEventListener(m_aEventListenerLink);
      m_bEventListener = false;
  }
2330}

2332// virtual
2333void SAL_CALL VCLXToolkit::fireFocusGained(
  css::uno::Reference<
  css::uno::XInterface > const &)
2336{
2337}

2339// virtual
2340void SAL_CALL VCLXToolkit::fireFocusLost(
  css::uno::Reference<
  css::uno::XInterface > const &)
2343{
2344}


2347IMPL_LINK(VCLXToolkit, eventListenerHandler, ::VclSimpleEvent&, rEvent, void)void VCLXToolkit::LinkStubeventListenerHandler(void * instance
, ::VclSimpleEvent& data) { return static_cast<VCLXToolkit
 *>(instance)->eventListenerHandler(data); } void VCLXToolkit
::eventListenerHandler(::VclSimpleEvent& rEvent)
2348{
  switch (rEvent.GetId())
  {
  case VclEventId::WindowShow:
      callTopWindowListeners(
          &rEvent, &css::awt::XTopWindowListener::windowOpened);
      break;
  case VclEventId::WindowHide:
      callTopWindowListeners(
          &rEvent, &css::awt::XTopWindowListener::windowClosed);
      break;
  case VclEventId::WindowActivate:
      callTopWindowListeners(
          &rEvent, &css::awt::XTopWindowListener::windowActivated);
      break;
  case VclEventId::WindowDeactivate:
      callTopWindowListeners(
          &rEvent, &css::awt::XTopWindowListener::windowDeactivated);
      break;
  case VclEventId::WindowClose:
      callTopWindowListeners(
          &rEvent, &css::awt::XTopWindowListener::windowClosing);
      break;
  case VclEventId::WindowGetFocus:
      callFocusListeners(&rEvent, true);
      break;
  case VclEventId::WindowLoseFocus:
      callFocusListeners(&rEvent, false);
      break;
  case VclEventId::WindowMinimize:
      callTopWindowListeners(
          &rEvent, &css::awt::XTopWindowListener::windowMinimized);
      break;
  case VclEventId::WindowNormalize:
      callTopWindowListeners(
          &rEvent, &css::awt::XTopWindowListener::windowNormalized);
      break;
  default: break;
  }
2387}

2389IMPL_LINK(VCLXToolkit, keyListenerHandler, ::VclWindowEvent&, rEvent, bool)bool VCLXToolkit::LinkStubkeyListenerHandler(void * instance,
 ::VclWindowEvent& data) { return static_cast<VCLXToolkit
 *>(instance)->keyListenerHandler(data); } bool VCLXToolkit
::keyListenerHandler(::VclWindowEvent& rEvent)
2390{
  switch (rEvent.GetId())
  {
  case VclEventId::WindowKeyInput:
      return callKeyHandlers(&rEvent, true);
  case VclEventId::WindowKeyUp:
      return callKeyHandlers(&rEvent, false);
  default: break;
  }
  return false;
2400}

2402void VCLXToolkit::callTopWindowListeners(
  ::VclSimpleEvent const * pEvent,
  void (SAL_CALL css::awt::XTopWindowListener::* pFn)(
      css::lang::EventObject const &))
2406{
  vcl::Window * pWindow
        = static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow();
  if (!pWindow->IsTopWindow())
      return;

  std::vector< css::uno::Reference< css::uno::XInterface > >
        aListeners(m_aTopWindowListeners.getElements());
  if (aListeners.empty())
      return;

  css::lang::EventObject aAwtEvent(
      static_cast< css::awt::XWindow * >(pWindow->GetWindowPeer()));
  for (const css::uno::Reference<XInterface> & i : aListeners)
  {
      css::uno::Reference< css::awt::XTopWindowListener >
            xListener(i, css::uno::UNO_QUERY);
      try
      {
          (xListener.get()->*pFn)(aAwtEvent);
      }
      catch (const css::uno::RuntimeException &)
      {
          DBG_UNHANDLED_EXCEPTION("toolkit")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "2429" ": ", "toolkit" );;
      }
  }
2432}

2434bool VCLXToolkit::callKeyHandlers(::VclSimpleEvent const * pEvent,
                                bool bPressed)
2436{
  std::vector< css::uno::Reference< css::uno::XInterface > >
        aHandlers(m_aKeyHandlers.getElements());

  if (!aHandlers.empty())
  {
      vcl::Window * pWindow = static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow();

      // See implementation in vclxwindow.cxx for mapping between VCL and UNO AWT event
      ::KeyEvent * pKeyEvent = static_cast< ::KeyEvent * >(
          static_cast< ::VclWindowEvent const * >(pEvent)->GetData());
      css::awt::KeyEvent aAwtEvent(
          static_cast< css::awt::XWindow * >(pWindow->GetWindowPeer()),
          (pKeyEvent->GetKeyCode().IsShift()
           ? css::awt::KeyModifier::SHIFT : 0)
          | (pKeyEvent->GetKeyCode().IsMod1()
             ? css::awt::KeyModifier::MOD1 : 0)
          | (pKeyEvent->GetKeyCode().IsMod2()
             ? css::awt::KeyModifier::MOD2 : 0)
          | (pKeyEvent->GetKeyCode().IsMod3()
             ? css::awt::KeyModifier::MOD3 : 0),
          pKeyEvent->GetKeyCode().GetCode(), pKeyEvent->GetCharCode(),
          sal::static_int_cast< sal_Int16 >(
              pKeyEvent->GetKeyCode().GetFunction()));
      for (const css::uno::Reference<XInterface> & i : aHandlers)
      {
          css::uno::Reference< css::awt::XKeyHandler > xHandler(
              i, css::uno::UNO_QUERY);
          try
          {
              if (bPressed ? xHandler->keyPressed(aAwtEvent)
                           : xHandler->keyReleased(aAwtEvent))
                  return true;
          }
          catch (const css::uno::RuntimeException &)
          {
              DBG_UNHANDLED_EXCEPTION("toolkit")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "2472" ": ", "toolkit" );;
          }
      }
  }
  return false;
2477}

2479void VCLXToolkit::callFocusListeners(::VclSimpleEvent const * pEvent,
                                   bool bGained)
2481{
  vcl::Window * pWindow
        = static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow();
  if (!pWindow->IsTopWindow())
      return;

  std::vector< css::uno::Reference< css::uno::XInterface > >
        aListeners(m_aFocusListeners.getElements());
  if (aListeners.empty())
      return;

  // Ignore the interior of compound controls when determining the
  // window that gets the focus next (see implementation in
  // vclxwindow.cxx for mapping between VCL and UNO AWT event):
  css::uno::Reference< css::uno::XInterface > xNext;
  vcl::Window * pFocus = ::Application::GetFocusWindow();
  for (vcl::Window * p = pFocus; p != nullptr; p = p->GetParent())
      if (!p->IsCompoundControl())
      {
          pFocus = p;
          break;
      }
  if (pFocus != nullptr)
      xNext = pFocus->GetComponentInterface();
  css::awt::FocusEvent aAwtEvent(
      static_cast< css::awt::XWindow * >(pWindow->GetWindowPeer()),
      static_cast<sal_Int16>(pWindow->GetGetFocusFlags()),
      xNext, false);
  for (const css::uno::Reference<XInterface> & i : aListeners)
  {
      css::uno::Reference< css::awt::XFocusListener > xListener(
          i, css::uno::UNO_QUERY);
      try
      {
          bGained ? xListener->focusGained(aAwtEvent)
              : xListener->focusLost(aAwtEvent);
      }
      catch (const css::uno::RuntimeException &)
      {
          DBG_UNHANDLED_EXCEPTION("toolkit")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/toolkit/source/awt/vclxtoolkit.cxx"
 ":" "2520" ": ", "toolkit" );;
      }
  }
2523}

2525// css::awt::XReschedule:

2527void SAL_CALL VCLXToolkit::reschedule()
2528{
  SolarMutexGuard aSolarGuard;
  Application::Reschedule(true);
2531}

2533// css::awt::XToolkitExperimental

2535void SAL_CALL VCLXToolkit::processEventsToIdle()
2536{
  SolarMutexGuard aSolarGuard;
  comphelper::ProfileZone aZone("processEvents");
  Scheduler::ProcessEventsToIdle();
2540}

2542sal_Int64 SAL_CALL VCLXToolkit::getOpenGLBufferSwapCounter()
2543{
2544#if HAVE_FEATURE_OPENGL1
  return OpenGLWrapper::getBufferSwapCounter();
2546#else
  return 0;
2548#endif
2549}

2551void SAL_CALL VCLXToolkit::setDeterministicScheduling(sal_Bool bDeterministicMode)
2552{
  SolarMutexGuard aSolarGuard;
  Scheduler::SetDeterministicMode(bDeterministicMode);
2555}

2557void SAL_CALL VCLXToolkit::pause(sal_Int32 nMilliseconds)
2558{
  new Pause(nMilliseconds);
2560}

2562void SAL_CALL VCLXToolkit::startRecording()
2563{
  ::comphelper::ProfileRecording::startRecording(true);
2565}

2567void SAL_CALL VCLXToolkit::stopRecording()
2568{
  ::comphelper::ProfileRecording::startRecording( false );
2570}

2572css::uno::Sequence< OUString > VCLXToolkit::getRecordingAndClear()
2573{
  return ::comphelper::ProfileRecording::getRecordingAndClear();
2575}

2577// css:awt:XToolkitRobot

2579void SAL_CALL VCLXToolkit::keyPress( const css::awt::KeyEvent & aKeyEvent )
2580{
  css::uno::Reference<css::awt::XWindow> xWindow ( aKeyEvent.Source, css::uno::UNO_QUERY_THROW );
  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
  if( !pWindow )
      throw css::uno::RuntimeException( "invalid event source" );

  ::KeyEvent aVCLKeyEvent = VCLUnoHelper::createVCLKeyEvent( aKeyEvent );
  ::Application::PostKeyEvent( VclEventId::WindowKeyInput, pWindow, &aVCLKeyEvent );
2588}

2590void SAL_CALL VCLXToolkit::keyRelease( const css::awt::KeyEvent & aKeyEvent )
2591{
  css::uno::Reference<css::awt::XWindow> xWindow ( aKeyEvent.Source, css::uno::UNO_QUERY_THROW );
  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
  if( !pWindow )
      throw css::uno::RuntimeException( "invalid event source" );

  ::KeyEvent aVCLKeyEvent = VCLUnoHelper::createVCLKeyEvent( aKeyEvent );
  ::Application::PostKeyEvent( VclEventId::WindowKeyUp, pWindow, &aVCLKeyEvent );
2599}


2602void SAL_CALL VCLXToolkit::mousePress( const css::awt::MouseEvent & aMouseEvent )
2603{
  css::uno::Reference<css::awt::XWindow> xWindow ( aMouseEvent.Source, css::uno::UNO_QUERY_THROW );
  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
  if( !pWindow )
      throw css::uno::RuntimeException( "invalid event source" );

  ::MouseEvent aVCLMouseEvent = VCLUnoHelper::createVCLMouseEvent( aMouseEvent );
  ::Application::PostMouseEvent( VclEventId::WindowMouseButtonDown, pWindow, &aVCLMouseEvent );
2611}

2613void SAL_CALL VCLXToolkit::mouseRelease( const css::awt::MouseEvent & aMouseEvent )
2614{
  css::uno::Reference<css::awt::XWindow> xWindow ( aMouseEvent.Source, css::uno::UNO_QUERY_THROW );
  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
  if( !pWindow )
      throw css::uno::RuntimeException( "invalid event source" );

  ::MouseEvent aVCLMouseEvent = VCLUnoHelper::createVCLMouseEvent( aMouseEvent );
  ::Application::PostMouseEvent( VclEventId::WindowMouseButtonUp, pWindow, &aVCLMouseEvent );
2622}

2624void SAL_CALL VCLXToolkit::mouseMove( const css::awt::MouseEvent & aMouseEvent )
2625{
  css::uno::Reference<css::awt::XWindow> xWindow ( aMouseEvent.Source, css::uno::UNO_QUERY_THROW );
  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
  if( !pWindow )
      throw css::uno::RuntimeException( "invalid event source" );

  ::MouseEvent aVCLMouseEvent = VCLUnoHelper::createVCLMouseEvent( aMouseEvent );
  ::Application::PostMouseEvent( VclEventId::WindowMouseMove, pWindow, &aVCLMouseEvent );
2633}


2636}

2638extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
2639stardiv_Toolkit_VCLXToolkit_get_implementation(
  css::uno::XComponentContext *,
  css::uno::Sequence<css::uno::Any> const &)
2642{
  return cppu::acquire(new VCLXToolkit());
2644}

2646/* 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)
  {}

  /** 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 );
15
←
Memory is allocated→
  }

  /** 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)
          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
)
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